limn-review 0.1.183 → 0.1.185

package/dist/ai/credentials.js

@@ -2,7 +2,7 @@
 // Fix, the ticket / CI reviews, diagrams, sprint paths, the docs build and chat, resolve with
 // Claude, every chat) AND the one-shot completions (review/llm.ts `cheapComplete`, which the
 // sprint briefs/themes, story labels, docs ranking, sprint Ask Claude and every platform feature —
-// reports, synthesis, work-plan wording, pointers, bot themes, the Slack
+// reports, synthesis, pointers, bot themes, the Slack
 // report — all go through).
 //
 //   1. THE LOCAL CLAUDE CODE LOGIN (default) — a `claude` session on disk or

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

@@ -332,30 +332,8 @@ function tierFor(method, path) {
             return [TIERS.ai, TIERS.aiHourly];
         return [TIERS.search, TIERS.read];
     }
-    // ---- The work plan (must sit ABOVE the /api/pro/ AI-tier catch-all) ----
-    // ONE endpoint, two verbs, two costs — the synthesis shape exactly, and tiered by copying it:
-    //   POST /api/pro/work-plan  the generate path — one Haiku call behind a payload-hash $0 cache,
-    //                            plus the evidence fold below. The catch-all's `generates` branch
-    //                            would land it on `ai` anyway; spelled here so the family's two
-    //                            tiers are DECIDED together (this file's failure mode is a tier
-    //                            nobody re-examined).
-    //   GET  /api/pro/work-plan  the free cached read — but it re-runs the whole `getWorkPlan`
-    //                            evidence fold to recompute the payload hash for the `stale` probe,
-    //                            and that fold reaches getWorkspaceInsights (the stalled-review /
-    //                            untouched-thread / reviewer-load / merge / update_branch cards).
-    //                            That is the synthesis / bot-behaviour shape of cost — this
-    //                            process's event loop and this database, not GitHub quota and not
-    //                            Anthropic — so it takes the same 60/min `search` bucket, NOT the
-    //                            catch-all's 600/min GET→read branch. The narration now decorates
-    //                            the Pending board, so this GET fires whenever that board is
-    //                            mounted. It must NEVER grow a generation leg.
-    if (path === '/api/pro/work-plan') {
-        if (mutating)
-            return [TIERS.ai, TIERS.aiHourly];
-        return [TIERS.search, TIERS.read];
-    }
     // ---- Chronology pointers (must sit ABOVE the /api/pro/ AI-tier catch-all) ----
-    // The work plan's shape and costs exactly: POST is one Haiku call behind a payload-hash $0 cache
+    // The synthesis shape and costs exactly: POST is one Haiku call behind a payload-hash $0 cache
     // (the `ai` pair); the free GET re-runs the whole Chronology fold (`getFlowCourts` — the lane
     // resolver plus chunked action scans over every merge in the window) plus the exemplar text
     // reads to recompute the hash for its `stale` probe, so it takes `search`, never the
@@ -581,6 +559,11 @@ function tierFor(method, path) {
     // `hitsGithub` alternation further down is never reached by a `/claude-review` path).
     if (mutating && /^\/api\/prs\/\d+\/claude-review\/team-claim\/clear$/.test(path))
         return [TIERS.githubWrite];
+    // SEEN (db/queries.ts `markClaudeReviewSeen`): the AI Review tab showed a finished run — one
+    // UPDATE of one column; no GitHub, no model. `read`, EXACT, so it never lands on the AI bucket
+    // the `/claude-review` family's generic POST rule below would give it.
+    if (mutating && /^\/api\/prs\/\d+\/claude-review\/seen$/.test(path))
+        return [TIERS.read];
     // AI Fix PLAN MODE (coding/ai-fix/routes.ts, LOCAL ONLY). Spelled out so the family cannot drift
     // with the /api/pro/ catch-all below, which would also have parked the DB-only discard on `ai`:
     //   POST /api/pro/prs/:id/ai-fix/plan             starts a planning agent pass  → ai + ai_hourly
@@ -723,7 +706,7 @@ function tierFor(method, path) {
     // GET /api/attention — the Pending board. RE-TIERED off the 600/min blanket `read` when it
     // absorbed the ranked head: one request now runs `getWorkspaceInsights` (including the
     // maintained-repo resolution, which the merge-card emitter makes effectively unconditional)
-    // AND `rankWorkPlan` on top of it — the approvals fold, the untouched-thread group-by and a
+    // AND `rankPendingTabs` (`scoreCards`) on top of it — the approvals fold, the untouched-thread group-by and a
     // narrow PR select. Same cost shape as the daily brief above, same 60/min bucket.
     // ⚠ "This route is DB-only" is exactly the sentence this file exists to distrust: the fold
     // moved into it, so the tier moves with it. The board mounts on navigation and refetches on a
@@ -746,6 +729,11 @@ function tierFor(method, path) {
     // GitHub, it reads.)
     if (mutating && path === '/api/attention/liveness')
         return [TIERS.prDetail, TIERS.read];
+    // POST /api/attention/ai-reviews/seen — "AI reviews" was looked at (db/ai-reviews-seen.ts).
+    // FOLLOWING THE TOKEN: one UPDATE of one column; no GitHub, no model. `read`, decided rather than
+    // inherited; EXACT `===`.
+    if (mutating && path === '/api/attention/ai-reviews/seen')
+        return [TIERS.read];
     // GET /api/flow-findings — the Chronology tab (deterministic, no model and no GitHub). DECIDED,
     // not inherited: "this
     // route is DB-only" is the sentence this file exists to distrust, and one call here runs the

package/dist/api/routes/insights.js

@@ -5,11 +5,23 @@ import { getMergedPrsInWindow } from '../../db/merged-prs.js';
 import { getStories } from '../../db/stories.js';
 import { getReportingWindow, reportingWindowInfo } from '../../db/reporting-window.js';
 import { buildPendingBoard } from '../../db/pending-tabs.js';
+import { markAiReviewsSeen } from '../../db/ai-reviews-seen.js';
 import { PR_LIVENESS_MAX_IDS, sweepPrLiveness } from '../../sync/pr-liveness-sweep.js';
 import { accountIdOf } from '../plugins/auth.js';
 // The liveness body. `maxItems` is a coarse guard only — the real cap is applied in the handler
 // AFTER de-duplication (a board legitimately renders several cards for one PR), and it 400s
 // rather than truncating.
+const aiReviewsSeenSchema = {
+    querystring: {
+        type: 'object',
+        properties: { workspace: { type: 'string' } },
+    },
+    body: {
+        type: ['object', 'null'],
+        additionalProperties: false,
+        properties: { through: { type: 'string', maxLength: 40 } },
+    },
+};
 const livenessSchema = {
     querystring: {
         type: 'object',
@@ -228,6 +240,27 @@ export async function insightsRoutes(app) {
         }
         return { workspaceId: scope.workspaceId, ...swept };
     });
+    // POST /api/attention/ai-reviews/seen — THE READER LOOKED AT "AI REVIEWS" (db/ai-reviews-seen.ts).
+    // Moves the workspace's stamp to `through` (the newest review time the reader's list showed; absent
+    // = now), never back. Sent by the SPA when the tab is ON SCREEN — never on the board's mount for
+    // another tab. DB only (one UPDATE): no GitHub, no model. `?workspace=` resolves like every scoped
+    // route (absent / unknown ⇒ the Default) and is echoed.
+    app.post('/api/attention/ai-reviews/seen', { schema: aiReviewsSeenSchema }, async (req, reply) => {
+        const q = req.query;
+        const body = (req.body ?? {});
+        let through = null;
+        if (body.through != null) {
+            const ms = Date.parse(body.through);
+            if (!Number.isFinite(ms)) {
+                return reply.code(400).send({ error: 'BadThrough', message: '`through` must be an ISO date.' });
+            }
+            through = new Date(ms);
+        }
+        const accountId = accountIdOf(req);
+        const scope = await resolveWorkspaceScope(accountId, q.workspace);
+        const at = await markAiReviewsSeen(accountId, scope.workspaceId, through);
+        return { workspaceId: scope.workspaceId, seenAt: (at ?? new Date()).toISOString() };
+    });
     // Heavier per-repo analytics for the drill-down chart panel — loaded on demand.
     // Ownership-scoped: a repo not owned by the account 404s.
     app.get('/api/insights/:repoId/analytics', async (req, reply) => {

package/dist/api/routes/me.js

@@ -131,10 +131,9 @@ const myTurnSettingsSchema = {
                         additionalProperties: false,
                         properties: Object.fromEntries(MY_TURN_TOGGLES.map((k) => [k, { type: 'boolean' }])),
                     },
-                    trunkScope: { type: 'string', maxLength: 32 },
                     order: {
                         type: 'array',
-                        maxItems: 15,
+                        maxItems: MY_TURN_TOGGLES.length,
                         items: { type: 'string', maxLength: 32 },
                     },
                     weights: {
@@ -442,8 +441,7 @@ export async function meRoutes(app) {
             return reply.code(404).send({ error: 'NotFound', message: 'Not found' });
         return body;
     });
-    // DISMISS / BRING BACK one My Turn subject — a pull request (`pr`) or, for a red default branch,
-    // a repository (`repo`). ⚠ NOT the "Done" routes 0060 deleted: a dismissal lasts only until
+    // DISMISS / BRING BACK one My Turn subject — a pull request (`pr`), whatever its card type. ⚠ NOT the "Done" routes 0060 deleted: a dismissal lasts only until
     // something newer happens on the subject, and a subject that leaves your plate discharges it
     // (db/my-turn-dismissals.ts). DB-only, both modes, free.
     //
@@ -481,7 +479,7 @@ export async function meRoutes(app) {
 /** `:kind/:id` → a target, or null for anything else (a non-integer id, an unknown kind). */
 export function parseDismissTarget(params) {
     const p = (params ?? {});
-    if (p.kind !== 'pr' && p.kind !== 'repo')
+    if (p.kind !== 'pr')
         return null;
     const raw = typeof p.id === 'string' ? p.id : '';
     if (!/^[1-9][0-9]{0,15}$/.test(raw))

package/dist/db/ai-reviews-seen.js

@@ -0,0 +1,176 @@
+// ── PENDING → "AI REVIEWS": THE NEWEST AI REVIEW ON EACH PR (docs/BACKEND.md § The AI reviews list) ──
+//
+// The tab's one list: a stable REFERENCE, never an inbox. One `ai_review` card per PR of the
+// workspace, open or not — the NEWEST of:
+//   • the reader's OWN Limn — a finished full review (`kind IS NULL`, `succeeded`, not a router
+//     skip). A Claude + Codex pair is ONE review: listed once, on its first half, with the pair's
+//     one verdict and both halves' findings (a merged-away repeat never counts);
+//   • a TEAMMATE's Limn — a review it posted to GitHub, imported as `kind = 'teammate'`.
+// Newest first, at most `AI_REVIEWS_LIST_CAP` rows.
+//
+// ⚠ LOOKING NEVER REMOVES A ROW. The workspace's `ai_reviews_seen_at` stamp only says which rows are
+// newer than the reader's last look: the SPA tags them "New" (against the stamp its visit started
+// with) and the tab's badge counts them (`PendingTab.newTotal`). It is moved ONLY by the reader
+// looking (`markAiReviewsSeen`, the SPA's POST while the tab is on screen), never by a read.
+//
+// ⚠ LIVE BOARD ONLY and COUNTED ONLY IN ITS TAB: `buildPendingBoard` appends these after the fold,
+// so the daily brief, Slack, the My Turn counts and the notifications never see one.
+//
+// DB only — no GitHub call.
+import { AI_REVIEWS_LIST_CAP } from '../shared/index.js';
+import { and, eq, inArray, isNotNull, isNull, or, sql } from 'drizzle-orm';
+import { db, schema } from './client.js';
+import { TEAMMATE_KIND } from './teammate-reviews.js';
+const { claudeReviews: cr, claudeReviewFindings: crf, pullRequests, repos, workspaces } = schema;
+/** The stamp, or null when the reader never looked in this workspace. Account-scoped. */
+export async function getAiReviewsSeenAt(accountId, workspaceId) {
+    const rows = await db
+        .select({ at: workspaces.aiReviewsSeenAt })
+        .from(workspaces)
+        .where(and(eq(workspaces.id, workspaceId), eq(workspaces.accountId, accountId)))
+        .limit(1)
+        .execute();
+    return rows[0]?.at ?? null;
+}
+/** How many listed rows are newer than the stamp (null = never looked: all of them). Pure. */
+export function countNewAiReviews(cards, seenAt) {
+    if (seenAt == null)
+        return cards.length;
+    const ms = seenAt.getTime();
+    return cards.filter((c) => Date.parse(c.at) > ms).length;
+}
+/**
+ * THE ONE WRITER. The reader looked: stamp `through` (the newest review time their list showed),
+ * else `now`. Clamped to `now`, and NEVER BACK — an older `through` (a second tab, a stale list)
+ * leaves the stamp where it is. Scoped to the account's own workspace; returns the stamp after the
+ * call, or null when the workspace is not the account's.
+ */
+export async function markAiReviewsSeen(accountId, workspaceId, through, now = Date.now()) {
+    const wanted = Math.floor(Math.min(through?.getTime() ?? now, now) / 1000);
+    const rows = await db
+        .update(workspaces)
+        .set({
+        aiReviewsSeenAt: sql `max(coalesce(${workspaces.aiReviewsSeenAt}, 0), ${wanted})`,
+    })
+        .where(and(eq(workspaces.id, workspaceId), eq(workspaces.accountId, accountId)))
+        .returning({ at: workspaces.aiReviewsSeenAt })
+        .execute();
+    return rows[0]?.at ?? null;
+}
+/**
+ * The `ai_review` cards for one workspace scope: the newest AI review on each PR, newest first, at
+ * most `AI_REVIEWS_LIST_CAP` — plus the teammates they name (for `users[]`). DB only.
+ */
+export async function buildAiReviewCards(accountId, repoIds) {
+    if (repoIds.length === 0)
+        return { cards: [], userIds: [] };
+    // Own runs by FINISH time, teammates' reviews by POST time (else import time) — the two clocks
+    // `listTeammateReviews` and the run panel already show.
+    const clock = sql `case when ${cr.kind} = ${TEAMMATE_KIND} then coalesce(${cr.postedAt}, ${cr.createdAt}) else coalesce(${cr.finishedAt}, ${cr.createdAt}) end`;
+    const all = await db
+        .select({
+        id: cr.id,
+        prId: cr.prId,
+        kind: cr.kind,
+        verdict: cr.verdict,
+        trigger: cr.trigger,
+        pairId: cr.pairId,
+        pairRole: cr.pairRole,
+        pairConsolidation: cr.pairConsolidation,
+        finishedAt: cr.finishedAt,
+        postedAt: cr.postedAt,
+        createdAt: cr.createdAt,
+        sourceUserId: cr.sourceUserId,
+        repoId: pullRequests.repoId,
+        prNumber: pullRequests.number,
+        prTitle: pullRequests.title,
+        owner: repos.owner,
+        name: repos.name,
+    })
+        .from(cr)
+        .innerJoin(pullRequests, eq(pullRequests.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
+        .where(and(eq(cr.accountId, accountId), eq(repos.accountId, accountId), inArray(pullRequests.repoId, [...repoIds]), or(and(isNull(cr.kind), eq(cr.status, 'succeeded'), 
+    // A router SKIP is not a review: nothing was read.
+    sql `coalesce(${cr.reviewMode}, '') <> 'skip'`, 
+    // A pair is ONE review, listed on its first half.
+    sql `coalesce(${cr.pairRole}, 'first') = 'first'`), and(eq(cr.kind, TEAMMATE_KIND), 
+    // Never unnamed: a teammate's review with no poster would read as the reader's own.
+    isNotNull(cr.sourceUserId)))))
+        .orderBy(sql `${clock} desc`, sql `${cr.id} desc`)
+        .execute();
+    // ONE ROW PER PR — its newest review — and at most the cap.
+    const onPr = new Set();
+    const rows = [];
+    for (const r of all) {
+        if (onPr.has(r.prId))
+            continue;
+        onPr.add(r.prId);
+        rows.push(r);
+        if (rows.length >= AI_REVIEWS_LIST_CAP)
+            break;
+    }
+    if (rows.length === 0)
+        return { cards: [], userIds: [] };
+    // A pair's second half: its findings count, and its finish time when it ended later.
+    const pairIds = [...new Set(rows.map((r) => r.pairId).filter((id) => id != null))];
+    const secondOf = new Map();
+    if (pairIds.length > 0) {
+        for (const h of await db
+            .select({ id: cr.id, pairId: cr.pairId, finishedAt: cr.finishedAt })
+            .from(cr)
+            .where(and(eq(cr.accountId, accountId), inArray(cr.pairId, pairIds), eq(cr.pairRole, 'second'), eq(cr.status, 'succeeded')))
+            .execute()) {
+            if (h.pairId != null)
+                secondOf.set(h.pairId, { id: h.id, finishedAt: h.finishedAt });
+        }
+    }
+    const runIdsOf = (r) => {
+        const second = r.pairId != null ? secondOf.get(r.pairId) : undefined;
+        return second != null ? [r.id, second.id] : [r.id];
+    };
+    // ONE grouped count over every listed run: findings that ask for something.
+    const findingCount = new Map();
+    for (const f of await db
+        .select({ reviewId: crf.reviewId, n: sql `count(*)` })
+        .from(crf)
+        .where(and(inArray(crf.reviewId, rows.flatMap(runIdsOf)), isNull(crf.mergedInto), sql `${crf.severity} <> 'praise'`))
+        .groupBy(crf.reviewId)
+        .execute()) {
+        findingCount.set(f.reviewId, Number(f.n));
+    }
+    const userIds = new Set();
+    const cards = rows.map((r) => {
+        const teammate = r.kind === TEAMMATE_KIND;
+        const second = r.pairId != null ? secondOf.get(r.pairId) : undefined;
+        const ownAt = Math.max((r.finishedAt ?? r.createdAt).getTime(), second?.finishedAt?.getTime() ?? 0);
+        const at = teammate ? (r.postedAt ?? r.createdAt).getTime() : ownAt;
+        const verdict = !teammate && r.pairId != null ? (r.pairConsolidation?.verdict ?? r.verdict) : r.verdict;
+        if (teammate && r.sourceUserId != null)
+            userIds.add(r.sourceUserId);
+        return {
+            id: `ai_review:${r.id}`,
+            kind: 'ai_review',
+            severity: 'info',
+            reviewId: r.id,
+            prId: r.prId,
+            repoId: r.repoId,
+            repoFullName: `${r.owner}/${r.name}`,
+            prNumber: r.prNumber,
+            prTitle: r.prTitle,
+            githubUrl: `https://github.com/${r.owner}/${r.name}/pull/${r.prNumber}`,
+            ranByUserId: teammate ? r.sourceUserId : null,
+            auto: !teammate && r.trigger === 'auto',
+            verdict,
+            findingCount: runIdsOf(r).reduce((n, id) => n + (findingCount.get(id) ?? 0), 0),
+            at: new Date(at).toISOString(),
+        };
+    });
+    cards.sort(compareAiReviews);
+    return { cards, userIds: [...userIds] };
+}
+/** Newest first; ties to the higher review id — a total order, so two polls list alike. */
+export function compareAiReviews(a, b) {
+    return Date.parse(b.at) - Date.parse(a.at) || b.reviewId - a.reviewId;
+}
+//# sourceMappingURL=ai-reviews-seen.js.map

package/dist/db/bot-dormancy.js

@@ -32,7 +32,7 @@
 // any observed work at all keeps a reviewer visible.
 //
 // The predicate is CORE so no second surface can grow its own rule: the benchmark reaches this
-// through the OPTIONAL `ProHostQueries.dormantBotUserIds` seam (apiVersion stays 21 — the `getWorkPlan` /
+// through the OPTIONAL `ProHostQueries.dormantBotUserIds` seam (apiVersion stays 21 — the `registerAccountErasure?` /
 // `workspaceHumanSeatCount` precedent; an older host simply hides nothing).
 //
 // ⚠ IT DELIBERATELY IMPORTS NOTHING FROM `queries.ts` — a cycle with the app's largest module

package/dist/db/branch-queries.js

@@ -14,7 +14,7 @@ export function trunkHeadKey(repoId, sha) {
 }
 /**
  * THE ONE READER OF A DEFAULT-BRANCH HEAD'S FAILING CHECKS — `/api/branch-status` and the Pending
- * board's red-trunk cards (ci_failing's trunk arm, the promoted `trunk_red` my_turn card) both read
+ * board's red-trunk card (ci_failing's trunk arm) reads
  * through it, so the two surfaces cannot name different checks for one red head.
  *
  * The head's own `branch_commits` row holds them (written by the branch snapshot in the same

package/dist/db/claude-review-seen.js

@@ -0,0 +1,36 @@
+// MY TURN → "NEW AI REVIEWS BY YOUR LIMN": THE ONE SEEN WRITER (docs/BACKEND.md § My Turn).
+//
+// The reader had a finished run of their own Limn on screen in the PR's AI Review tab
+// (`POST /api/prs/:id/claude-review/seen`, sent by the tab once per run while `seenAt` is null). The
+// run — and, for a Claude + Codex pair, every half — is stamped only where `seen_at` is still NULL,
+// so a repeat is a no-op and the stamp never moves. A stamped run is no longer a `claude_review` My
+// Turn card (`getUnseenOwnAiReviews`). ⚠ This module opens NO database at import (it takes an
+// executor): the review routes import it.
+import { and, eq, isNull } from 'drizzle-orm';
+import * as schema from './schema.sqlite.js';
+const cr = schema.claudeReviews;
+/**
+ * Stamp one finished own run (and its pair) seen. Account- and PR-scoped. Returns how many rows it
+ * stamped: 0 for a run that is not the account's, not this PR's, not a full review, not finished, or
+ * already seen — the route answers 404 only for the first three (`null`).
+ */
+export async function markClaudeReviewSeen(exec, accountId, prId, reviewId, now = new Date()) {
+    const run = (await exec
+        .select({ id: cr.id, pairId: cr.pairId, status: cr.status })
+        .from(cr)
+        .where(and(eq(cr.id, reviewId), eq(cr.accountId, accountId), eq(cr.prId, prId), isNull(cr.kind)))
+        .limit(1)
+        .execute())[0];
+    if (run == null)
+        return null;
+    if (run.status !== 'succeeded')
+        return 0;
+    const stamped = await exec
+        .update(cr)
+        .set({ seenAt: now })
+        .where(and(eq(cr.accountId, accountId), eq(cr.prId, prId), isNull(cr.seenAt), run.pairId != null ? eq(cr.pairId, run.pairId) : eq(cr.id, run.id)))
+        .returning({ id: cr.id })
+        .execute();
+    return stamped.length;
+}
+//# sourceMappingURL=claude-review-seen.js.map

package/dist/db/daily-brief.js

@@ -239,11 +239,7 @@ async function computeBriefCounts(accountId, workspaceId) {
         cached(anomalyCache, `${accountId}:${scope.workspaceId}`, ANOMALY_TTL_MS, () => briefBotAnomalies(accountId, scope)),
         trunkRedRepos(accountId, scope),
     ]);
-    // ⚠ A RED TRUNK THE READER PROMOTED INTO MY TURN IS COUNTED THERE, NOT HERE — it is a my_turn
-    // card (and in `myTurn` below), so listing it on this line too would count one red branch twice.
-    // Filtered after the fold resolves, then capped.
-    const promotedTrunks = new Set(insights.myTurnTrunkRepoIds ?? []);
-    const trunkRed = allRedTrunks.filter((t) => !promotedTrunks.has(t.repoId)).slice(0, TRUNK_CAP);
+    const trunkRed = allRedTrunks.slice(0, TRUNK_CAP);
     let myTurn = 0;
     // The `MyTurnCard.personal` subset of the same cards — the figure the NOTIFICATION surfaces
     // display, where the board keeps displaying `myTurn`. Counted off the cards for exactly the
@@ -287,9 +283,6 @@ async function computeBriefCounts(accountId, workspaceId) {
     for (const c of insights.cards) {
         if (c.kind === 'ci_failing')
             ciFailing += 1;
-        // A finished Claude review is listed in its own tab, not My turn, so no My turn line counts it.
-        else if (c.kind === 'my_turn' && c.reason === 'claude_review')
-            continue;
         else if (c.kind === 'my_turn') {
             myTurn += 1;
             if (c.personal)

package/dist/db/erase-account.js

@@ -177,6 +177,8 @@ export async function eraseAccountData(accountId) {
         await tx.delete(schema.teamClaimLines).where(eq(schema.teamClaimLines.accountId, accountId)).execute();
         // The teammate lines the AI Review tab names (migration 0159): GitHub logins. No FK.
         await tx.delete(schema.teamClaimSeen).where(eq(schema.teamClaimSeen.accountId, accountId)).execute();
+        // The skipped lines (migration 0166): heads and providers. No FK.
+        await tx.delete(schema.teamClaimSkipLines).where(eq(schema.teamClaimSkipLines.accountId, accountId)).execute();
         // The worktree ledger (migration 0146): which PR / ticket a checkout on disk was for. No FK. The
         // directories themselves become unledgered orphans the worktree sweep collects by age.
         await tx.delete(schema.worktreeLedger).where(eq(schema.worktreeLedger.accountId, accountId)).execute();
@@ -370,6 +372,8 @@ export function accountScopedTables() {
         { name: 'teamClaimLines', col: schema.teamClaimLines.accountId, table: schema.teamClaimLines },
         // The teammate lines (migration 0159), erased explicitly above.
         { name: 'teamClaimSeen', col: schema.teamClaimSeen.accountId, table: schema.teamClaimSeen },
+        // The skipped lines (migration 0166), erased explicitly above.
+        { name: 'teamClaimSkipLines', col: schema.teamClaimSkipLines.accountId, table: schema.teamClaimSkipLines },
         // The worktree ledger (migration 0146), erased explicitly above.
         { name: 'worktreeLedger', col: schema.worktreeLedger.accountId, table: schema.worktreeLedger },
         { name: 'workspaceSonar', col: schema.workspaceSonar.accountId, table: schema.workspaceSonar },

package/dist/db/migrations/0166_team_claim_skip_lines.sql

@@ -0,0 +1,20 @@
+-- AN AUTO REVIEW THIS LIMN SKIPPED, SAID ON THE PR (docs/CLAUDE-REVIEW.md § Team claims → The skipped
+-- line). When the reader's Limn does not start an auto review it would otherwise run (the AI budget is
+-- used, the workspace's daily limit is reached, the provider is over its usage limit, AI is not signed
+-- in), it posts ONE green `limn/review-<provider>` line on the head. One row per (account, PR, head,
+-- provider, reason), claimed BEFORE the GitHub write: at most once, never retried. Additive.
+CREATE TABLE `team_claim_skip_lines` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`pr_id` integer NOT NULL,
+	`head_sha` text NOT NULL,
+	`provider` text NOT NULL,
+	`reason` text NOT NULL,
+	`state` text NOT NULL,
+	`description` text,
+	`last_error` text,
+	`created_at` integer DEFAULT (unixepoch()) NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `team_claim_skip_lines_key` ON `team_claim_skip_lines` (`account_id`,`pr_id`,`head_sha`,`provider`,`reason`);

package/dist/db/migrations/0167_ai_reviews_seen.sql

@@ -0,0 +1,4 @@
+-- PENDING → "AI REVIEWS" SINCE THE READER LAST LOOKED (docs/BACKEND.md § The AI reviews list): when the
+-- reader last looked at the tab in this workspace. NULL = never (the list covers the last 7 days).
+-- Additive and nullable; no backfill.
+ALTER TABLE `workspaces` ADD `ai_reviews_seen_at` integer;

package/dist/db/migrations/0168_ai_review_seen_per_run.sql

@@ -0,0 +1,12 @@
+-- MY TURN → "NEW AI REVIEWS BY YOUR LIMN" (docs/BACKEND.md § My Turn): when the reader first had a run
+-- on screen in the PR's AI Review tab after it finished. NULL = not seen — the newest such run on an
+-- open PR is a `claude_review` My Turn card until it is seen or dismissed.
+ALTER TABLE `claude_reviews` ADD `seen_at` integer;
+--> statement-breakpoint
+-- Every run that already finished is treated as seen: the card's meaning changed (it used to be
+-- "un-posted findings"), and an upgrade must not drop every PR's latest review onto My Turn at once.
+UPDATE `claude_reviews` SET `seen_at` = coalesce(`finished_at`, `created_at`) WHERE `status` = 'succeeded';
+--> statement-breakpoint
+-- The red default branch is no longer a My Turn type: its repository-subject dismissals have no item
+-- to hide. (The `repo_id` column stays, dormant.)
+DELETE FROM `my_turn_dismissals` WHERE `pr_id` IS NULL;

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

@@ -1163,6 +1163,27 @@
       "when": 1792224073016,
       "tag": "0165_withdraw_approval_on_push",
       "breakpoints": true
+    },
+    {
+      "idx": 166,
+      "version": "6",
+      "when": 1792224075016,
+      "tag": "0166_team_claim_skip_lines",
+      "breakpoints": true
+    },
+    {
+      "idx": 167,
+      "version": "6",
+      "when": 1792224077016,
+      "tag": "0167_ai_reviews_seen",
+      "breakpoints": true
+    },
+    {
+      "idx": 168,
+      "version": "6",
+      "when": 1792224079016,
+      "tag": "0168_ai_review_seen_per_run",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/my-turn-dismissals.js

@@ -5,8 +5,7 @@
 //
 // ── 1. A DISMISSAL SETS ONE ITEM DOWN UNTIL SOMETHING NEW HAPPENS ────────────────────────────
 //
-// The reader can take a subject — a pull request, or a repository for a red default branch — off
-// their plate. ⚠ This is NOT the "Done" button migration 0060 deleted, and the difference is the
+// The reader can take a subject — a pull request — off their plate. ⚠ This is NOT the "Done" button migration 0060 deleted, and the difference is the
 // whole design. That one stored "I dealt with this" and never expired, so a PR whose ball came back
 // stayed hidden behind it for weeks. This one stores a TIMESTAMP and lets the fold decide:
 //
@@ -39,10 +38,10 @@
 // ⚠ IT IS A BOARD RULE, NOT A NOTIFICATION RULE. `getWorkspaceInsights` asks for it; the
 // account-wide `GET /api/my-turn` does not, because the browser-notification watcher diffs item
 // ids — a deduplicated list would flip the winner whenever the top job cleared and announce the
-// runner-up as "new". Red default branches are repo-grained and never collide with a PR.
+// runner-up as "new".
 import { and, eq, inArray } from 'drizzle-orm';
 import { db, schema } from './client.js';
-const { myTurnDismissals, pullRequests, repos } = schema;
+const { myTurnDismissals, pullRequests } = schema;
 export const subjectKey = (t) => `${t.kind}:${t.id}`;
 /** Every dismissal the account holds. One indexed select plus a join for the PR's repo/state. */
 export async function readMyTurnDismissals(accountId) {
@@ -68,14 +67,6 @@ export async function readMyTurnDismissals(accountId) {
                 closed: r.prState !== 'open',
             });
         }
-        else if (r.repoId != null) {
-            out.push({
-                target: { kind: 'repo', id: r.repoId },
-                dismissedAtMs: r.dismissedAt.getTime(),
-                repoId: r.repoId,
-                closed: false,
-            });
-        }
     }
     return out;
 }
@@ -97,38 +88,19 @@ export function dismissalInstant(nowMs) {
  */
 export async function dismissMyTurn(accountId, target, nowMs = Date.now()) {
     const at = dismissalInstant(nowMs);
-    if (target.kind === 'pr') {
-        const owned = await db
-            .select({ id: pullRequests.id })
-            .from(pullRequests)
-            .where(and(eq(pullRequests.id, target.id), eq(pullRequests.accountId, accountId)))
-            .limit(1)
-            .execute();
-        if (owned[0] == null)
-            return null;
-        await db
-            .insert(myTurnDismissals)
-            .values({ accountId, prId: target.id, repoId: null, dismissedAt: at })
-            .onConflictDoUpdate({
-            target: [myTurnDismissals.accountId, myTurnDismissals.prId],
-            set: { dismissedAt: at },
-        })
-            .execute();
-        return at;
-    }
     const owned = await db
-        .select({ id: repos.id })
-        .from(repos)
-        .where(and(eq(repos.id, target.id), eq(repos.accountId, accountId)))
+        .select({ id: pullRequests.id })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.id, target.id), eq(pullRequests.accountId, accountId)))
         .limit(1)
         .execute();
     if (owned[0] == null)
         return null;
     await db
         .insert(myTurnDismissals)
-        .values({ accountId, prId: null, repoId: target.id, dismissedAt: at })
+        .values({ accountId, prId: target.id, repoId: null, dismissedAt: at })
         .onConflictDoUpdate({
-        target: [myTurnDismissals.accountId, myTurnDismissals.repoId],
+        target: [myTurnDismissals.accountId, myTurnDismissals.prId],
         set: { dismissedAt: at },
     })
         .execute();
@@ -136,30 +108,22 @@ export async function dismissMyTurn(accountId, target, nowMs = Date.now()) {
 }
 /** Bring a subject back. True when a dismissal existed. Scoped by account on the row itself. */
 export async function restoreMyTurn(accountId, target) {
-    const col = target.kind === 'pr' ? myTurnDismissals.prId : myTurnDismissals.repoId;
     const deleted = await db
         .delete(myTurnDismissals)
-        .where(and(eq(myTurnDismissals.accountId, accountId), eq(col, target.id)))
+        .where(and(eq(myTurnDismissals.accountId, accountId), eq(myTurnDismissals.prId, target.id)))
         .returning({ id: myTurnDismissals.id })
         .execute();
     return deleted.length > 0;
 }
 /** Drop the rows the fold found nothing left for — see `MyTurnDismissalFilter.dischargeable`. */
 export async function dischargeMyTurnDismissals(accountId, targets) {
-    const prIds = targets.filter((t) => t.kind === 'pr').map((t) => t.id);
-    const repoIds = targets.filter((t) => t.kind === 'repo').map((t) => t.id);
+    const prIds = targets.map((t) => t.id);
     if (prIds.length > 0) {
         await db
             .delete(myTurnDismissals)
             .where(and(eq(myTurnDismissals.accountId, accountId), inArray(myTurnDismissals.prId, prIds)))
             .execute();
     }
-    if (repoIds.length > 0) {
-        await db
-            .delete(myTurnDismissals)
-            .where(and(eq(myTurnDismissals.accountId, accountId), inArray(myTurnDismissals.repoId, repoIds)))
-            .execute();
-    }
 }
 /**
  * The per-fold filter. `keep` is called once per candidate item, in any order; it records which
@@ -271,6 +235,7 @@ export function onePerPr(mt, order) {
         approvedPrs: pr('pr_approved'),
         ownReady: pr('own_ready'),
         yourPrs: pr('your_pr'),
+        approvedMerged: pr('ai_approved_merged'),
         watchedRepoPrs: pr('watched_repo_pr'),
     };
     const thread = (reason) => ({
@@ -309,6 +274,8 @@ export function onePerPr(mt, order) {
         offer(S.ownReady.of(i));
     for (const i of mt.yourPrs)
         offer(S.yourPrs.of(i));
+    for (const i of mt.approvedMerged)
+        offer(S.approvedMerged.of(i));
     for (const i of mt.watchedRepoPrs)
         offer(S.watchedRepoPrs.of(i));
     for (const i of mt.threadsAwaiting)
@@ -333,8 +300,7 @@ export function onePerPr(mt, order) {
         ownThreads: mt.ownThreads.filter((i) => winnerIs(ownThreads.of(i))),
         // Exempt (header, rule 2): every Claude review keeps its own card.
         claudeReviewsToAction: mt.claudeReviewsToAction,
-        // Repo-grained: a branch is not a pull request, and never shares a key with one.
-        redTrunks: mt.redTrunks,
+        approvedMerged: mt.approvedMerged.filter((i) => winnerIs(S.approvedMerged.of(i))),
     };
 }
 //# sourceMappingURL=my-turn-dismissals.js.map