limn-review 0.1.138 → 0.1.140

package/dist/ai/result-schemas.js

@@ -9,6 +9,8 @@ export const RESULT_TOOL_NAMES = [
     'submit_pr_card',
     'submit_ci_review',
     'submit_threads',
+    // The replies pass (review/claude-review/replies-check.ts): judgements of replies on Limn's findings.
+    'submit_replies',
     'submit_design',
     'submit_paths',
     'submit_alignment',
@@ -30,6 +32,7 @@ const BUILDERS = {
     submit_pr_card: async (z) => (await import('../review/ticket-review/schema.js')).buildSubmitPrCardShape(z),
     submit_ci_review: async (z) => (await import('../review/ci-review/schema.js')).buildSubmitCiReviewShape(z),
     submit_threads: async (z) => (await import('../review/claude-review/thread-check-schema.js')).buildSubmitThreadsShape(z),
+    submit_replies: async (z) => (await import('../review/claude-review/replies-check-schema.js')).buildSubmitRepliesShape(z),
     submit_design: async (z) => (await import('../review/diagrams/schema.js')).buildSubmitDesignShape(z),
     submit_paths: async (z) => (await import('../review/sprint-paths/schema.js')).buildSubmitPathsShape(z),
     submit_alignment: async (z) => (await import('../review/story-docs/schema.js')).buildSubmitAlignmentShape(z),

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

@@ -529,6 +529,11 @@ function tierFor(method, path) {
     // "Post reply" on a follow-up reply status: ONE GitHub thread reply (+ a resolve), no model.
     if (mutating && /^\/api\/claude-reviews\/\d+\/follow-up\/\d+\/reply$/.test(path))
         return [TIERS.githubWrite];
+    // TEAM CLAIMS "Clear" (review/claude-review/routes.ts): ONE commit-status write, no model. Spelled
+    // EXACTLY here, before the Claude Review family below would park it on the AI bucket (the
+    // `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];
     // 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

package/dist/api/routes/prs.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { REQUEST_CHANGES_DEFAULT_BODY, WITHDRAW_APPROVAL_MESSAGE } from '../../shared/index.js';
+import { REQUEST_CHANGES_DEFAULT_BODY, WITHDRAW_APPROVAL_MESSAGE, mergeStateWithoutLimn } from '../../shared/index.js';
 import { accountGithubLogin } from '../../db/review-threads-for-review.js';
 import { config } from '../../config.js';
 import { stampPrMergeQueueStateNonFatal } from '../../db/pr-merge-queue-stamp.js';
@@ -724,7 +724,8 @@ export async function prRoutes(app) {
                 allowedMethods: [...allowedMethods],
                 defaultMethod: allowedMethods[0] ?? 'merge',
                 mergeable: m.mergeable,
-                mergeStateStatus: m.mergeableState,
+                // ⚠ An UNSTABLE only Limn's own status lines caused reads CLEAN (shared limn-status.ts).
+                mergeStateStatus: mergeStateWithoutLimn(m.mergeableState, ctx.ciStatus),
                 conflicts,
                 behind,
                 blocked: m.mergeableState === 'blocked',

package/dist/db/limn-finding-severity.js

@@ -0,0 +1,126 @@
+// THE SEVERITY CHIP ON LIMN'S OWN POSTED FINDINGS — which review thread / PR-level comment of a PR
+// is a finding Limn posted, and the severity it was posted with. Read inside getPrDetail (the
+// payload the PR details pane already loads), so the chip costs no request of its own.
+//
+// The link is the thread-owner link the rest of Claude Review uses:
+//   - a finding's stored `github_comment_id` is the ROOT comment of the thread it started
+//     (`posted_comment_kind = 'inline'`) or the PR-level comment it became ('pr_comment');
+//   - its latest REMINDER's comment is the same finding, posted again;
+//   - an inline-posted finding with no stored id (its review read-back failed) is matched by the ONE
+//     shared matcher, `findFindingThread` (same file, the account's own login, the hidden marker,
+//     the finding's text at the start).
+// The severity goes through the shared grader seam `severityForPostedFinding`, the same call the
+// comment builders make, so the chip always says what GitHub says. Praise is never posted: no chip.
+import { and, eq, inArray, isNotNull } from 'drizzle-orm';
+import { severityForPostedFinding, } from '../shared/index.js';
+import { db, schema } from './client.js';
+import { findFindingThread } from '../review/claude-review/finding-thread.js';
+import { accountGithubLogin } from './review-threads-for-review.js';
+/** The pure fold (see the header). `threadComments` are every comment of the PR's threads. */
+export function limnSeverityTargets(input) {
+    const byThreadId = new Map();
+    const byPrCommentId = new Map();
+    const inline = new Map();
+    const prLevel = new Map();
+    const unlinked = [];
+    // Oldest first, so the finding that really posted owns its thread before a later one is tried.
+    for (const f of [...input.findings].sort((a, b) => a.id - b.id)) {
+        const sev = severityForPostedFinding(f);
+        if (sev == null)
+            continue;
+        if (f.githubCommentId != null) {
+            (f.postedCommentKind === 'pr_comment' ? prLevel : inline).set(f.githubCommentId, sev);
+        }
+        else if (f.postedCommentKind !== 'pr_comment') {
+            unlinked.push({ f, sev });
+        }
+        const r = f.reminder;
+        if (r?.githubCommentId)
+            (r.postedCommentKind === 'pr_comment' ? prLevel : inline).set(r.githubCommentId, sev);
+    }
+    if (inline.size + prLevel.size + unlinked.length === 0)
+        return { byThreadId, byPrCommentId };
+    // Each thread's ROOT comment (the earliest).
+    const roots = new Map();
+    for (const c of input.threadComments) {
+        const r = roots.get(c.threadId);
+        if (!r || c.createdAt < r.createdAt)
+            roots.set(c.threadId, c);
+    }
+    for (const [threadId, root] of roots) {
+        const sev = root.databaseId != null ? inline.get(root.databaseId) : undefined;
+        if (sev != null)
+            byThreadId.set(threadId, sev);
+    }
+    const taken = new Set(byThreadId.keys());
+    for (const { f, sev } of unlinked) {
+        const t = findFindingThread(f, input.threads, input.threadComments, input.accountLogin, taken);
+        if (t) {
+            byThreadId.set(t.id, sev);
+            taken.add(t.id);
+        }
+    }
+    for (const c of input.prComments) {
+        const sev = c.databaseId != null ? prLevel.get(c.databaseId) : undefined;
+        if (sev != null)
+            byPrCommentId.set(c.id, sev);
+    }
+    return { byThreadId, byPrCommentId };
+}
+/**
+ * Load this PR's posted findings and fold them over the thread / comment rows getPrDetail already
+ * read. One indexed query when nothing of Limn's is posted; the account login and the comment
+ * authors are read only when a posted inline finding has no stored comment id.
+ */
+export async function loadLimnSeverityTargets(accountId, prId, rows) {
+    const { claudeReviews: cr, claudeReviewFindings: crf } = schema;
+    const findings = (await db
+        .select({
+        id: crf.id,
+        severity: crf.severity,
+        path: crf.path,
+        line: crf.line,
+        body: crf.body,
+        editedBody: crf.editedBody,
+        githubCommentId: crf.githubCommentId,
+        postedCommentKind: crf.postedCommentKind,
+        reminder: crf.reminder,
+    })
+        .from(crf)
+        .innerJoin(cr, eq(cr.id, crf.reviewId))
+        .where(and(eq(cr.accountId, accountId), eq(cr.prId, prId), isNotNull(crf.postedAt)))
+        .execute());
+    if (findings.length === 0)
+        return { byThreadId: new Map(), byPrCommentId: new Map() };
+    const needsMatcher = findings.some((f) => f.githubCommentId == null && f.postedCommentKind !== 'pr_comment');
+    let accountLogin = null;
+    const loginById = new Map();
+    if (needsMatcher) {
+        accountLogin = await accountGithubLogin(accountId);
+        const authorIds = [...new Set(rows.threadComments.map((c) => c.authorId).filter((x) => x != null))];
+        if (authorIds.length > 0) {
+            const us = await db
+                .select({ id: schema.users.id, login: schema.users.githubLogin })
+                .from(schema.users)
+                .where(inArray(schema.users.id, authorIds))
+                .execute();
+            for (const u of us)
+                if (u.login)
+                    loginById.set(u.id, u.login);
+        }
+    }
+    return limnSeverityTargets({
+        findings,
+        threads: rows.threads,
+        threadComments: rows.threadComments.map((c) => ({
+            threadId: c.threadId,
+            databaseId: c.databaseId,
+            body: c.body,
+            authorLogin: c.authorId != null ? (loginById.get(c.authorId) ?? null) : null,
+            createdAt: c.createdAt.getTime(),
+        })),
+        prComments: rows.prComments,
+        accountLogin,
+    });
+}
+//# sourceMappingURL=limn-finding-severity.js.map

package/dist/db/migrations/0134_team_claims.sql

@@ -0,0 +1,10 @@
+-- TEAM CLAIMS (docs/CLAUDE-REVIEW.md § Team claims). Two additive columns:
+--   workspaces.team_claims_enabled  "Mark auto reviews on GitHub": an auto review posts a commit
+--                                   status (limn/review-claude | limn/review-codex) on the PR's head
+--                                   so teammates' Limn skips a commit someone is already reviewing.
+--                                   NULL/0 = OFF, the default for every workspace.
+--   claude_reviews.team_claim       what the claim did for THIS run (JSON, ClaudeTeamClaimRecord).
+--                                   NULL = no claim was attempted (a manual run, or the switch off).
+ALTER TABLE `workspaces` ADD `team_claims_enabled` integer;
+--> statement-breakpoint
+ALTER TABLE `claude_reviews` ADD `team_claim` text;

package/dist/db/migrations/0135_review_pairs.sql

@@ -0,0 +1,12 @@
+-- CLAUDE + CODEX PAIRS (docs/CLAUDE-REVIEW.md § Claude + Codex). A pair is two ordinary runs: Claude
+-- first, then Codex with Claude's findings as already raised. `pair_id` = the FIRST run's id, on both
+-- rows; `pair_role` = 'first' | 'second'; `pair_dropped` = how many of the second run's findings
+-- repeated a first-run finding and were dropped in code (second run only). NULL on every other row.
+ALTER TABLE `claude_reviews` ADD `pair_id` integer;
+--> statement-breakpoint
+ALTER TABLE `claude_reviews` ADD `pair_role` text;
+--> statement-breakpoint
+ALTER TABLE `claude_reviews` ADD `pair_dropped` integer;
+--> statement-breakpoint
+-- Who runs a workspace's AUTO reviews: NULL = the default provider (Settings → AI); 'both' = a pair.
+ALTER TABLE `workspaces` ADD `auto_review_providers` text;

package/dist/db/migrations/0136_review_kind.sql

@@ -0,0 +1,5 @@
+-- A REPLIES PASS (docs/CLAUDE-REVIEW.md § The replies pass): a light run that judges only people's
+-- replies on Limn's own posted findings, stored as a `claude_reviews` row so history shows it and
+-- its follow-up items read like any review's. 'replies' on such a row; NULL on every full review,
+-- older ones included. Additive only.
+ALTER TABLE `claude_reviews` ADD `kind` text;

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

@@ -939,6 +939,27 @@
       "when": 1792137620016,
       "tag": "0133_review_fresh",
       "breakpoints": true
+    },
+    {
+      "idx": 134,
+      "version": "6",
+      "when": 1792137621016,
+      "tag": "0134_team_claims",
+      "breakpoints": true
+    },
+    {
+      "idx": 135,
+      "version": "6",
+      "when": 1792137622016,
+      "tag": "0135_review_pairs",
+      "breakpoints": true
+    },
+    {
+      "idx": 136,
+      "version": "6",
+      "when": 1792137623016,
+      "tag": "0136_review_kind",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/pr-liveness.js

@@ -14,6 +14,7 @@
 // in this batch: queries.ts is already 9k lines and carries literal NUL bytes that make `rg`/
 // `grep` under-report against it, so new folds go in a file a search can actually find.
 import { and, eq, inArray } from 'drizzle-orm';
+import { mergeStateWithoutLimn } from '../shared/index.js';
 import { db, schema } from './client.js';
 import { READY_MERGE_STATES } from './triage.js';
 import { noteLiveMergeTransition } from '../sync/merge-notice.js';
@@ -44,6 +45,7 @@ export async function getPrLivenessTargets(accountId, repoIds, prIds) {
         inMergeQueue: pullRequests.inMergeQueue,
         mergeQueueEntryState: pullRequests.mergeQueueEntryState,
         updatedAt: pullRequests.updatedAt,
+        ciStatus: pullRequests.ciStatus,
     })
         .from(pullRequests)
         .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, repoIds), inArray(pullRequests.id, prIds)))
@@ -60,6 +62,7 @@ export async function getPrLivenessTargets(accountId, repoIds, prIds) {
         inMergeQueue: r.inMergeQueue ?? null,
         mergeQueueEntryState: r.mergeQueueEntryState ?? null,
         updatedAt: r.updatedAt,
+        ciStatus: r.ciStatus ?? null,
     }));
 }
 /**
@@ -221,8 +224,14 @@ export async function applyPrLiveness(accountId, target, obs) {
     // computation) keeps its previous state until the next full walk. That is the same staleness
     // every card had before this route existed, on a narrow slice of PRs, for a couple of minutes.
     const authoritative = (next, stored, unknown) => next !== undefined && next !== stored && !(next === unknown && stored != null);
-    if (authoritative(obs.mergeStateStatus, target.mergeStateStatus, 'unknown')) {
-        set.mergeStateStatus = obs.mergeStateStatus;
+    // ⚠ LIMN'S OWN LINES ARE NOT CI: an UNSTABLE that only they caused (the stored CI, which never
+    // counts them, is green) is written CLEAN — exactly as `persistPr` writes it. A stored CLEAN over
+    // a stored 'unknown' CI is `persistPr`'s "only Limn's lines, no other CI" answer (it read the
+    // contexts; this probe does not), so an UNSTABLE here does not flip it back.
+    const ciForMergeState = target.ciStatus === 'unknown' && target.mergeStateStatus === 'clean' ? 'none' : target.ciStatus;
+    const observedMergeState = mergeStateWithoutLimn(obs.mergeStateStatus, ciForMergeState);
+    if (authoritative(observedMergeState, target.mergeStateStatus, 'unknown')) {
+        set.mergeStateStatus = observedMergeState;
         change(true);
     }
     if (authoritative(obs.mergeable, target.mergeable, 'unknown')) {

package/dist/db/queries.js

@@ -47,6 +47,7 @@ import { hubReadingFor, loadRepoCoupling } from './file-coupling.js';
 import { DAYS_PER_MONTH, botWindowMs } from './bot-window.js';
 import { dormantBotUserIds } from './bot-dormancy.js';
 import { newestReviewCommentTimes } from './review-threads-for-review.js';
+import { loadLimnSeverityTargets } from './limn-finding-severity.js';
 import { automationVendorUserIds, exactAutomationVendorUsers, githubTypeBotUserIds, globalAutomationUserIds, } from './automation-ids.js';
 import { forwardKindOf, isConflicting, isRedCiStatus, RED_CI_STATUSES, } from './pending-classify.js';
 import { authorAutomationFor, dependencyPrState, dependencyStateDetail, MERGE_QUEUE_CARD_DETAIL, securityFixDetail, unionAdvisoryIds, } from './dependency-cards.js';
@@ -7289,6 +7290,12 @@ export async function getPrDetail(id, accountId) {
         arr.push(c);
         commentsByThread.set(c.threadId, arr);
     }
+    // Limn's own posted findings: the severity chip on their threads and PR-level comments.
+    const limnSeverity = await loadLimnSeverityTargets(accountId, id, {
+        threads: threadRows,
+        threadComments: commentRows,
+        prComments: prCommentRows,
+    });
     const threads = threadRows.map((t) => {
         const tComments = commentsByThread.get(t.id) ?? [];
         return {
@@ -7317,6 +7324,7 @@ export async function getPrDetail(id, accountId) {
             url: tComments[0]?.databaseId
                 ? `${prUrl}#discussion_r${tComments[0].databaseId}`
                 : null,
+            limnSeverity: limnSeverity.byThreadId.get(t.id) ?? null,
         };
     });
     // Bot-triage provenance (compute-on-read): which reviews were posted by an automated
@@ -7360,6 +7368,7 @@ export async function getPrDetail(id, accountId) {
         body: c.body ?? '',
         createdAt: c.createdAt.toISOString(),
         url: c.databaseId ? `${prUrl}#issuecomment-${c.databaseId}` : null,
+        limnSeverity: limnSeverity.byPrCommentId.get(c.id) ?? null,
     }));
     const commitsOut = commitRows.map((c) => ({
         id: c.id,
@@ -8033,7 +8042,9 @@ repoIds) {
         .from(claudeReviews)
         .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
         .innerJoin(repos, eq(repos.id, pullRequests.repoId))
-        .where(and(eq(repos.accountId, accountId), repoIds == null ? undefined : inArray(pullRequests.repoId, repoIds), eq(claudeReviews.status, 'succeeded'), eq(pullRequests.state, 'open')))
+        .where(and(eq(repos.accountId, accountId), repoIds == null ? undefined : inArray(pullRequests.repoId, repoIds), eq(claudeReviews.status, 'succeeded'), eq(pullRequests.state, 'open'), 
+    // A REPLIES PASS (kind 'replies') is not a review to action: the card follows the full one.
+    isNull(claudeReviews.kind)))
         .orderBy(desc(claudeReviews.finishedAt), desc(claudeReviews.createdAt))
         .execute();
     const seen = new Set(); // most-recent succeeded run per PR only
@@ -8145,7 +8156,12 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
         .select({ id: claudeReviews.id })
         .from(claudeReviews)
         .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .where(and(eq(claudeReviews.accountId, accountId), eq(claudeReviews.trigger, 'auto'), gte(claudeReviews.createdAt, new Date(opts.dayStartMs)), inArray(pullRequests.repoId, repoIds)))
+        .where(and(eq(claudeReviews.accountId, accountId), eq(claudeReviews.trigger, 'auto'), gte(claudeReviews.createdAt, new Date(opts.dayStartMs)), inArray(pullRequests.repoId, repoIds), 
+    // Replies passes have their own per-PR cap (review/claude-review/replies-check.ts).
+    isNull(claudeReviews.kind), 
+    // A CLAUDE + CODEX PAIR is ONE review of the PR: it counts once toward the daily cap (its
+    // first half's row), never twice.
+    or(isNull(claudeReviews.pairRole), ne(claudeReviews.pairRole, 'second'))))
         .execute();
     const autoToday = autoRows.length;
     if (opts.limit <= 0)
@@ -8163,7 +8179,7 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
         .execute();
     if (open.length === 0)
         return { prIds: [], autoToday, reReview: [], inFlightMoved: [], retry: [] };
-    const [bots, reviewed, reviewerBots] = await Promise.all([
+    const [bots, allRuns, reviewerBots] = await Promise.all([
         hiddenBotUserIds(accountId, workspaceId),
         db
             .select({
@@ -8178,6 +8194,8 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
             error: claudeReviews.error,
             provider: claudeReviews.provider,
             model: claudeReviews.model,
+            kind: claudeReviews.kind,
+            pairId: claudeReviews.pairId,
         })
             .from(claudeReviews)
             .where(and(eq(claudeReviews.accountId, accountId), inArray(claudeReviews.prId, open.map((r) => r.id))))
@@ -8185,6 +8203,11 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
         automatedReviewerUserIds(accountId, workspaceId, 'review'),
     ]);
     const botSet = new Set(bots);
+    // ⚠ A REPLIES PASS (kind 'replies') is NOT a review: it neither settles a head nor counts as a
+    // first review, a retry or a run in flight. Only its coverage of the own-finding replies is read
+    // (`repliesCoveredMs`, below). Every rule from here on reads full reviews alone.
+    const repliesRows = allRuns.filter((r) => r.kind === 'replies');
+    const reviewed = allRuns.filter((r) => r.kind == null);
     const hasRun = new Set(reviewed.map((r) => r.prId));
     const human = open.filter((r) => r.authorId != null && !botSet.has(r.authorId));
     // ⚠ THE ONBOARDING FLOOR GATES FIRST REVIEWS ONLY. A PR opened before the switch is never
@@ -8290,7 +8313,15 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
         // else its START (`created_at`) for a row that never recorded one — never 0, or a deploy would
         // re-review every PR that already has comments.
         const coveredMs = Math.max(...atHead.map((r) => (r.commentsThrough ?? r.createdAt).getTime()));
-        sameHead.push({ prId: pr.id, headSha: pr.headSha, coveredMs });
+        // How far the replies passes AT THIS HEAD reached (any status: one attempt per burst).
+        const passes = repliesRows.filter((r) => r.prId === pr.id && r.headSha === pr.headSha);
+        const repliesCoveredMs = passes.length > 0 ? Math.max(...passes.map((r) => (r.commentsThrough ?? r.createdAt).getTime())) : null;
+        // ⚠ OWN-FINDING REPLIES and a CLAUDE + CODEX PAIR: each half follows up ONLY its own provider's
+        // findings, so a reply on a Claude finding that landed while the Claude half ran is NOT judged by
+        // the Codex half, though that half's coverage reaches past it. A pair therefore covers own-thread
+        // replies only as far as its EARLIER-reaching half (`pairOwnCoveredMs`); an ordinary run as above.
+        const ownCoveredMs = pairOwnCoveredMs(atHead);
+        sameHead.push({ prId: pr.id, headSha: pr.headSha, coveredMs, ownCoveredMs, repliesCoveredMs });
     }
     // RE-REVIEW ON NEW COMMENTS: a qualifying review-thread comment (a person's or a bot's, in an
     // unresolved thread, never one Limn posted — db/review-threads-for-review.ts) newer than what
@@ -8334,8 +8365,13 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
             const ck = latestCheck.get(p.prId);
             const checkCoveredMs = ck && ck.headSha === p.headSha ? (ck.commentsThrough ?? ck.createdAt).getTime() : null;
             const ownMs = t.newestOwn?.getTime() ?? null;
-            const ownNeedsReview = ownMs != null && ownMs > p.coveredMs;
-            if (at <= Math.max(p.coveredMs, checkCoveredMs ?? 0) && !ownNeedsReview)
+            // A reply on Limn's own finding goes to a REPLIES PASS (review/claude-review/auto.ts
+            // `commentBurstRoute`), which covers it once a pass at this head reached it.
+            const ownNeedsPass = ownMs != null && ownMs > Math.max(p.ownCoveredMs, p.repliesCoveredMs ?? 0);
+            // Everything else goes to Check threads, as before.
+            const otherMs = t.newestOther?.getTime() ?? null;
+            const otherNeedsCheck = otherMs != null && otherMs > Math.max(p.coveredMs, checkCoveredMs ?? 0);
+            if (!ownNeedsPass && !otherNeedsCheck)
                 continue;
             reReview.push({
                 prId: p.prId,
@@ -8344,8 +8380,11 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
                 reason: 'comments',
                 lastRunAtMs: null,
                 coveredMs: p.coveredMs,
+                ownCoveredMs: p.ownCoveredMs,
                 checkCoveredMs,
                 newestOwnThreadCommentAtMs: ownMs,
+                repliesCoveredMs: p.repliesCoveredMs,
+                newestOtherCommentAtMs: otherMs,
             });
             if (reReview.length >= opts.limit)
                 break;
@@ -8353,6 +8392,27 @@ export async function getAutoReviewCandidates(accountId, workspaceId, opts) {
     }
     return { prIds, autoToday, reReview, inFlightMoved, retry };
 }
+/**
+ * How far the full reviews at one head covered replies on Limn's OWN findings: the max over runs of
+ * (comments_through ?? created_at), except that the two halves of a Claude + Codex pair (same
+ * `pairId`) count as their EARLIER-reaching half — each half follows up only its own provider's
+ * findings, so the later half's coverage says nothing about the other half's threads. Pure.
+ */
+export function pairOwnCoveredMs(runs) {
+    const byPair = new Map();
+    let best = 0;
+    for (const r of runs) {
+        const t = (r.commentsThrough ?? r.createdAt).getTime();
+        if (r.pairId == null) {
+            best = Math.max(best, t);
+            continue;
+        }
+        byPair.set(r.pairId, Math.min(byPair.get(r.pairId) ?? Number.POSITIVE_INFINITY, t));
+    }
+    for (const t of byPair.values())
+        best = Math.max(best, t);
+    return best;
+}
 // WHO MAY RE-TRIGGER AN AUTO REVIEW BY COMMENTING (the comment half of the re-review key). A
 // PERSON — not in the workspace's bot union `hiddenBotUserIds`, where a manual "this is a human"
 // wins both ways — or a bot whose role in THIS workspace is `'review'` (`automatedReviewerUserIds`
@@ -8716,6 +8776,7 @@ export async function getPrWriteContext(prId, accountId) {
         viewerPermission: repos.viewerPermission,
         mergeStateStatus: pullRequests.mergeStateStatus,
         reviewDecision: pullRequests.reviewDecision,
+        ciStatus: pullRequests.ciStatus,
     })
         .from(pullRequests)
         .innerJoin(repos, eq(repos.id, pullRequests.repoId))
@@ -8738,6 +8799,7 @@ export async function getPrWriteContext(prId, accountId) {
         prUrl: `https://github.com/${row.owner}/${row.name}/pull/${row.number}`,
         mergeStateStatus: row.mergeStateStatus ?? null,
         reviewDecision: row.reviewDecision ?? null,
+        ciStatus: row.ciStatus ?? null,
     };
 }
 // Optimistically stamp a PR as merged after a successful GitHub merge, so the UI reflects it

package/dist/db/review-threads-for-review.js

@@ -112,7 +112,8 @@ countsAuthor) {
 /**
  * `newestReviewCommentAt`, plus `newestOwn`: the newest of those comments inside a thread ROOTED on
  * one of Limn's own posted findings (the loader's `newestOwnThreadCommentAt`, same filter) — the
- * sweeper's "a reply on a Limn finding needs a full review" test, read in the same scan.
+ * sweeper's "a reply on a Limn finding goes to a replies pass" test, read in the same scan — and
+ * `newestOther`: the newest one in any OTHER thread (Check threads' half).
  */
 export async function newestReviewCommentTimes(accountId, prIds, since, countsAuthor) {
     const out = new Map();
@@ -183,13 +184,15 @@ export async function newestReviewCommentTimes(accountId, prIds, since, countsAu
         const prev = out.get(r.prId);
         const isOwn = r.threadId != null && ownRooted.has(r.threadId);
         if (!prev) {
-            out.set(r.prId, { newest: r.createdAt, newestOwn: isOwn ? r.createdAt : null });
+            out.set(r.prId, { newest: r.createdAt, newestOwn: isOwn ? r.createdAt : null, newestOther: isOwn ? null : r.createdAt });
             continue;
         }
         if (r.createdAt.getTime() > prev.newest.getTime())
             prev.newest = r.createdAt;
         if (isOwn && (!prev.newestOwn || r.createdAt.getTime() > prev.newestOwn.getTime()))
             prev.newestOwn = r.createdAt;
+        if (!isOwn && (!prev.newestOther || r.createdAt.getTime() > prev.newestOther.getTime()))
+            prev.newestOther = r.createdAt;
     }
     return out;
 }

package/dist/db/schema.sqlite.js

@@ -1103,6 +1103,20 @@ export const claudeReviews = sqliteTable('claude_reviews', {
     // A FROM-SCRATCH run (`GenerateReviewBody.fresh`): it read no earlier review — no follow-up, no
     // settled list, no carried thread judgements. true on such a run; NULL otherwise (migration 0133).
     fresh: integer('fresh', { mode: 'boolean' }),
+    // WHAT THE TEAM CLAIM DID FOR THIS RUN (migration 0134; review/claude-review/team-claim.ts): the
+    // GitHub status line it posted ("Marked on GitHub"), or why it ran without one. NULL = no claim
+    // was attempted (a manual run, or "Mark auto reviews on GitHub" off).
+    teamClaim: text('team_claim', { mode: 'json' }).$type(),
+    // A CLAUDE + CODEX PAIR (migration 0135; docs/CLAUDE-REVIEW.md § Claude + Codex): `pairId` = the
+    // FIRST run's id, on both halves; `pairRole` 'first' | 'second'; `pairDropped` = the second run's
+    // findings dropped in code as repeats of the first's. NULL on every ordinary run.
+    pairId: integer('pair_id'),
+    pairRole: text('pair_role', { enum: ['first', 'second'] }),
+    pairDropped: integer('pair_dropped'),
+    // A REPLIES PASS (review/claude-review/replies-check.ts): 'replies' on a run that judged only
+    // people's replies on Limn's own posted findings; NULL on every full review (migration 0136).
+    // ⚠ Every "the latest review" / "a run at this head" reader filters `kind IS NULL`.
+    kind: text('kind', { enum: ['replies'] }),
 }, (t) => ({
     prIdx: index('cr_pr_idx').on(t.prId),
     prShaIdx: index('cr_pr_sha_idx').on(t.prId, t.headSha),
@@ -1768,6 +1782,15 @@ export const workspaces = sqliteTable('workspaces', {
     // is off. Off stops only the automatic draw; Draw / Redraw still works. The ONE writer is
     // `setWorkspaceAutoReview` (review/claude-review/auto-settings.ts).
     autoDiagramsEnabled: integer('auto_diagrams_enabled', { mode: 'boolean' }).notNull().default(true),
+    // TEAM CLAIMS (migration 0134; docs/CLAUDE-REVIEW.md § Team claims): "Mark auto reviews on
+    // GitHub". An auto review posts a commit status (limn/review-claude | limn/review-codex) on the
+    // PR's head so teammates' Limn skips a commit someone is already reviewing with the same
+    // provider. NULL/false = OFF, the default. The ONE writer is `setWorkspaceAutoReview`.
+    teamClaimsEnabled: integer('team_claims_enabled', { mode: 'boolean' }),
+    // WHO RUNS AUTO REVIEWS (migration 0135): NULL = the default provider (Settings → AI); 'both' =
+    // Claude then Codex as one pair (docs/CLAUDE-REVIEW.md § Claude + Codex). The ONE writer is
+    // `setWorkspaceAutoReview` (review/claude-review/auto-settings.ts).
+    autoReviewProviders: text('auto_review_providers'),
     // DEPENDENCY AUTO-MERGE (migration 0093 / pg 0080): may the server arm "merge when ready" on
     // every open dependency-automation PR in this workspace's repos (merge/dependency-policy.ts)?
     // NULL/false = OFF, the default for every workspace; nullable with no default, so no insert

package/dist/github/branch-queries.js

@@ -37,6 +37,16 @@
 // re-fires every 120s for a hot repo. So the failing-check DETAIL is a SECOND query
 // (`buildCommitChecksQuery`) issued only for the commits whose rollup phase 1 already reported
 // as failure/error/pending. A green trunk therefore costs exactly the phase-1 walk.
+// LIMN'S OWN STATUS LINES ARE NOT CI (shared limn-status.ts). The commit's legacy STATUS names — a
+// plain list, NOT a connection, so it costs ZERO rate-limit points at any alias count — say whether
+// one of Limn's `limn/review-*` lines is folded into the rollup state beside it. Only then is the
+// state recomputed from the commit's contexts (sync/limn-ci.ts), so a commit without one costs
+// exactly what it did.
+export const LIMN_MARK_FIELDS = /* GraphQL */ `status {
+                  contexts {
+                    context
+                  }
+                }`;
 // One trunk-commit node, shared VERBATIM between the live snapshot query and the history
 // backfill below — the two walks must store identical rows, so the selection is written once.
 //
@@ -54,6 +64,7 @@ const BRANCH_COMMIT_FIELDS = /* GraphQL */ `
                 statusCheckRollup {
                   state
                 }
+                ${LIMN_MARK_FIELDS}
                 author {
                   name
                   avatarUrl
@@ -152,6 +163,9 @@ const COMMIT_CHECKS_SELECTION = /* GraphQL */ `
   statusCheckRollup {
     state
     contexts(first: 100) {
+      pageInfo {
+        hasNextPage
+      }
       nodes {
         __typename
         ... on CheckRun {
@@ -215,7 +229,7 @@ export const COMMIT_STATES_ALIAS_CAP = 100;
  * `GitObjectID!` variables, never interpolated into the query text. */
 export function buildCommitStatesQuery(count) {
     const vars = Array.from({ length: count }, (_, i) => `$s${i}: GitObjectID!`).join(', ');
-    const aliases = Array.from({ length: count }, (_, i) => `      c${i}: object(oid: $s${i}) { ... on Commit { oid statusCheckRollup { state } } }`).join('\n');
+    const aliases = Array.from({ length: count }, (_, i) => `      c${i}: object(oid: $s${i}) { ... on Commit { oid statusCheckRollup { state } ${LIMN_MARK_FIELDS} } }`).join('\n');
     return `query CommitStates($owner: String!, $name: String!, ${vars}) {
     rateLimit {
       cost

package/dist/github/check-context-state.js

@@ -0,0 +1,42 @@
+// Exported because sync/branch-status.ts maps the SAME contexts union for default-branch
+// commits. The CheckRun status/conclusion → CheckRunState table must not exist twice: if trunk
+// and PR surfaces disagreed about what "failing" means, the same check would render differently
+// depending on where you looked at it.
+export function checkContextState(c) {
+    if (c.__typename === 'StatusContext') {
+        switch ((c.state ?? '').toUpperCase()) {
+            case 'SUCCESS':
+                return 'success';
+            case 'FAILURE':
+                return 'failure';
+            case 'ERROR':
+                return 'error';
+            case 'PENDING':
+            case 'EXPECTED':
+                return 'pending';
+            default:
+                return 'unknown';
+        }
+    }
+    // CheckRun: outcome is meaningful only once completed.
+    if ((c.status ?? '').toUpperCase() !== 'COMPLETED')
+        return 'pending';
+    switch ((c.conclusion ?? '').toUpperCase()) {
+        case 'SUCCESS':
+            return 'success';
+        case 'FAILURE':
+        case 'TIMED_OUT':
+        case 'STARTUP_FAILURE':
+        case 'ACTION_REQUIRED':
+            return 'failure';
+        case 'CANCELLED':
+        case 'STALE':
+        case 'NEUTRAL':
+            return 'neutral';
+        case 'SKIPPED':
+            return 'skipped';
+        default:
+            return 'unknown';
+    }
+}
+//# sourceMappingURL=check-context-state.js.map

package/dist/github/commit-checks.js

@@ -1,4 +1,5 @@
 import { checkRunsFrom } from '../sync/upsert.js';
+import { rollupStateWithoutLimn } from '../shared/index.js';
 import { getGraphqlClientFor, ghRestGetFor, graphqlTolerant, isRateLimitError } from './client.js';
 import { isLimited, noteLimited } from './rate-budget.js';
 const SHA_RE = /^[0-9a-fA-F]{7,64}$/;
@@ -12,6 +13,9 @@ export const COMMIT_CHECKS_QUERY = /* GraphQL */ `
           statusCheckRollup {
             state
             contexts(first: 100) {
+              pageInfo {
+                hasNextPage
+              }
               nodes {
                 __typename
                 ... on CheckRun {
@@ -55,11 +59,18 @@ export async function fetchCommitChecks(token, args) {
         if (rollup.contexts == null && partial)
             return { ok: false, reason: 'no_check_access' };
         const nodes = (rollup.contexts?.nodes ?? []).filter((n) => n != null);
-        const checks = checkRunsFrom({
+        const all = checkRunsFrom({
             oid: obj.oid ?? args.sha,
             statusCheckRollup: { state: rollup.state ?? '', contexts: { nodes } },
         });
-        return { ok: true, rollupState: rollup.state ?? null, checks };
+        // ⚠ LIMN'S OWN STATUS LINES ARE NOT CI (shared limn-status.ts): the CI review and every other
+        // reader of this read see neither the lines nor their effect on the rollup.
+        const checks = all.filter((c) => !c.limnOwned);
+        return {
+            ok: true,
+            rollupState: rollupStateWithoutLimn(rollup.state, all, rollup.contexts?.pageInfo?.hasNextPage !== true),
+            checks,
+        };
     }
     catch (err) {
         const rl = isRateLimitError(err);