limn-review 0.1.140 → 0.1.141

package/dist/coding/ai-fix/manager.js

@@ -1,7 +1,7 @@
 import { and, desc, eq } from 'drizzle-orm';
 import { AI_FIX_PLAN_MAX_REVISIONS, aiRunProvider } from '../../shared/index.js';
 import { getFixPrContext } from './pr-context.js';
-import { getClaudeReviewById } from '../../review/claude-review/persist.js';
+import { getReviewView } from '../../review/claude-review/persist.js';
 import { currentThreadAssessmentsForPrs } from '../../review/claude-review/thread-judgements.js';
 import { pickReviewNonce } from '../../review/claude-review/prompts.js';
 import { buildPickerPreview, buildReviewSeed, } from './review-seed.js';
@@ -103,7 +103,9 @@ function emitFixStream(prId, e) {
 async function loadSourceReview(ctx, accountId, prId, reviewId) {
     if (reviewId == null)
         return null;
-    const review = await getClaudeReviewById(ctx, reviewId, accountId);
+    // A Claude + Codex pair seeds from its ONE consolidated review (both halves' findings, merged-away
+    // duplicates never read — pair-view.ts), never from one half.
+    const review = await getReviewView(ctx, reviewId, accountId);
     if (!review || review.prId !== prId || review.status !== 'succeeded')
         return null;
     // A later Check threads run judged threads since this review: when this IS the latest review,

package/dist/db/migrations/0137_review_pair_consolidation.sql

@@ -0,0 +1,8 @@
+-- CLAUDE + CODEX: ONE REVIEW BY BOTH (docs/CLAUDE-REVIEW.md § Claude + Codex). When a pair ends its two
+-- halves are consolidated into one review. `pair_consolidation` (on the pair's FIRST row only) holds
+-- the one summary, the code-computed verdict, each kept finding's source, the merged-away duplicates
+-- and the half that did not finish; NULL everywhere else. `merged_into` marks a finding the other
+-- half's finding stands for (never shown, posted, counted or sent to AI Fix); NULL everywhere else.
+ALTER TABLE `claude_reviews` ADD `pair_consolidation` text;
+--> statement-breakpoint
+ALTER TABLE `claude_review_findings` ADD `merged_into` integer;

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

@@ -960,6 +960,13 @@
       "when": 1792137623016,
       "tag": "0136_review_kind",
       "breakpoints": true
+    },
+    {
+      "idx": 137,
+      "version": "6",
+      "when": 1792137624016,
+      "tag": "0137_review_pair_consolidation",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/queries.js

@@ -8038,6 +8038,7 @@ repoIds) {
         reviewHead: claudeReviews.headSha,
         prHead: pullRequests.headSha,
         trigger: claudeReviews.trigger,
+        pairId: claudeReviews.pairId,
     })
         .from(claudeReviews)
         .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
@@ -8049,16 +8050,41 @@ repoIds) {
         .execute();
     const seen = new Set(); // most-recent succeeded run per PR only
     const candidates = [];
+    // A CLAUDE + CODEX PAIR is ONE review (review/claude-review/pair-view.ts): its succeeded halves
+    // are read together — posted when either was posted as a review, its findings both halves' (a
+    // merged-away duplicate never counts), its verdict the pair's one verdict.
+    const halvesOf = new Map();
+    for (const r of rows) {
+        if (r.pairId == null)
+            continue;
+        const list = halvesOf.get(r.pairId) ?? [];
+        list.push(r);
+        halvesOf.set(r.pairId, list);
+    }
     for (const r of rows) {
         if (seen.has(r.prId))
             continue;
         seen.add(r.prId);
-        if (r.postedAt != null)
+        const halves = r.pairId != null ? (halvesOf.get(r.pairId) ?? [r]) : [r];
+        if (halves.some((h) => h.postedAt != null))
             continue; // the run itself was posted → actioned, no findings needed
         candidates.push(r);
     }
     if (candidates.length === 0)
         return [];
+    const runIdsOf = (c) => c.pairId != null ? (halvesOf.get(c.pairId) ?? [c]).map((h) => h.reviewId) : [c.reviewId];
+    // The pairs' one verdicts (on each pair's FIRST row), in ONE read.
+    const pairIds = [...new Set(candidates.map((c) => c.pairId).filter((id) => id != null))];
+    const pairVerdicts = new Map();
+    if (pairIds.length > 0) {
+        const recs = await db
+            .select({ id: claudeReviews.id, rec: claudeReviews.pairConsolidation })
+            .from(claudeReviews)
+            .where(inArray(claudeReviews.id, pairIds))
+            .execute();
+        for (const p of recs)
+            pairVerdicts.set(p.id, p.rec?.verdict ?? null);
+    }
     // ONE grouped read over the candidate runs — never one query per run, and never a per-run
     // EXISTS in the select above, which would run the sub-query for every historical run of every
     // open PR rather than the handful that got this far.
@@ -8070,7 +8096,7 @@ repoIds) {
         postedAt: claudeReviewFindings.postedAt,
     })
         .from(claudeReviewFindings)
-        .where(inArray(claudeReviewFindings.reviewId, candidates.map((c) => c.reviewId)))
+        .where(and(inArray(claudeReviewFindings.reviewId, candidates.flatMap(runIdsOf)), isNull(claudeReviewFindings.mergedInto)))
         .execute();
     const findingsByRun = new Map();
     for (const f of findingRows) {
@@ -8080,7 +8106,7 @@ repoIds) {
     }
     const out = [];
     for (const r of candidates) {
-        const findings = findingsByRun.get(r.reviewId) ?? [];
+        const findings = runIdsOf(r).flatMap((id) => findingsByRun.get(id) ?? []);
         // STATE ONE: nothing from this run has reached GitHub. It was never worked, so it stays —
         // including a run with no findings at all, whose summary and verdict are still yours to post
         // or discard. ⚠ This branch is what keeps a fresh run visible: `included` defaults to false,
@@ -8101,7 +8127,7 @@ repoIds) {
             repoFullName: `${r.owner}/${r.name}`,
             prNumber: r.prNumber,
             prTitle: r.prTitle,
-            verdict: r.verdict,
+            verdict: r.pairId != null ? (pairVerdicts.get(r.pairId) ?? r.verdict) : r.verdict,
             finishedAt: iso(r.finishedAt),
             headStale: r.reviewHead !== r.prHead,
             githubUrl: `https://github.com/${r.owner}/${r.name}/pull/${r.prNumber}`,

package/dist/db/schema.sqlite.js

@@ -1113,6 +1113,12 @@ export const claudeReviews = sqliteTable('claude_reviews', {
     pairId: integer('pair_id'),
     pairRole: text('pair_role', { enum: ['first', 'second'] }),
     pairDropped: integer('pair_dropped'),
+    // THE PAIR'S ONE REVIEW (migration 0137; review/claude-review/pair-consolidate.ts): on the pair's
+    // FIRST row only, written ONCE when the pair ends — the consolidated summary, the code verdict,
+    // each kept finding's source, the merged-away duplicates and the half that did not finish.
+    // NULL on every other row, on a pair still running, and on a pair from before the column (read as
+    // the two halves joined in code).
+    pairConsolidation: text('pair_consolidation', { mode: 'json' }).$type(),
     // 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`.
@@ -1207,6 +1213,12 @@ export const claudeReviewFindings = sqliteTable('claude_review_findings', {
     // The reference-library sections this finding rests on, server-checked (migration 0117 / pg 0104).
     // NULL = none.
     docCitations: text('doc_citations', { mode: 'json' }).$type(),
+    // A CLAUDE + CODEX PAIR'S DUPLICATE (migration 0137): the id of the finding kept in this one's
+    // place when the pair was consolidated (the other half made the same point). A soft reference to
+    // a finding of the same pair (no FK, like `prior_finding_id`). A merged-away finding stays here
+    // but is NEVER shown, posted, counted in a verdict or sent to AI Fix; the next follow-up of its
+    // provider follows up the kept one instead. NULL on every other finding.
+    mergedInto: integer('merged_into'),
 }, (t) => ({ reviewIdx: index('crf_review_idx').on(t.reviewId) }));
 // ---- Claude Review chat (CORE table, written by the Pro plugin) ----
 // One row per chat MESSAGE about one succeeded review: a general thread (`finding_id` NULL) and

package/dist/platform/slack/signals.js

@@ -3,7 +3,7 @@ import { proSchemaFor } from '../db.js';
 import { escapeSlack, prLink, slackLink } from './links.js';
 import { postToSlack } from './send.js';
 import { readTargetRow } from './targets.js';
-import { aiRunProviderName } from '../../shared/index.js';
+import { aiRunProviderName, PAIR_RUN_LABEL } from '../../shared/index.js';
 // ── THE TWO SLACK EVENT SIGNALS (Pro, `slackDigest`; plugin migration 0040) ──────────────────
 //
 // Per workspace, each its own switch on the delivery row, both OFF by default:
@@ -105,7 +105,9 @@ const trimSummary = (s) => {
 };
 /** Pure builder for the "Claude Review ran" message ("Codex Review ran" when Codex ran it). Exported
  *  for its test. */
-export function reviewMessage(ctx, workspaceId, f, verdict, summary, ranBy = 'Claude') {
+export function reviewMessage(ctx, workspaceId, f, verdict, summary, 
+// 'Claude + Codex' for a pair's one review.
+ranBy = 'Claude') {
     const by = f.authorLogin ? ` by @${escapeSlack(f.authorLogin)}` : '';
     const head = `*${ranBy} Review ran* on ${prLine(ctx, workspaceId, f)}${by}`;
     const lines = [head];
@@ -161,6 +163,8 @@ export async function onClaudeReviewCompleted(ctx, e) {
         summary: cr.summary,
         reviewMode: cr.reviewMode,
         trigger: cr.trigger,
+        // A Claude + Codex pair announces its ONE review (pair-view.ts): the consolidation on its first row.
+        ...(cr.pairId != null ? { pairId: cr.pairId } : {}),
         // The provider that ran it: the stored `provider` (Phase 4, sqlite 0128), else read from the
         // model id (aiRunProvider). A schema without the columns reads as Claude.
         ...(cr.model != null ? { model: cr.model } : {}),
@@ -177,10 +181,30 @@ export async function onClaudeReviewCompleted(ctx, e) {
     // The STORED trigger agrees, or nothing is sent (no claim either).
     if (run.trigger !== 'auto')
         return;
+    // A PAIR: its one summary and verdict, named "Claude + Codex" (an older pair reads as this half).
+    let verdict = run.verdict;
+    let summary = run.summary;
+    let ranBy = aiRunProviderName(run);
+    if (run.pairId != null) {
+        const rec = (await ctx.db
+            .select({ pairConsolidation: cr.pairConsolidation })
+            .from(cr)
+            .where(and(eq(cr.id, run.pairId), eq(cr.accountId, e.accountId), eq(cr.prId, e.prId)))
+            .limit(1)
+            .execute())[0]?.pairConsolidation;
+        if (rec != null && typeof rec === 'object') {
+            if (typeof rec.summary === 'string')
+                summary = rec.summary;
+            if (rec.verdict === 'APPROVE' || rec.verdict === 'REQUEST_CHANGES' || rec.verdict === 'COMMENT')
+                verdict = rec.verdict;
+            if (rec.how !== 'single')
+                ranBy = PAIR_RUN_LABEL;
+        }
+    }
     if (!(await claimNotice(ctx, e.accountId, 'review', e.reviewId)))
         return;
     try {
-        await postToSlack(target.row.webhookUrl, reviewMessage(ctx, target.workspaceId, facts, run.verdict, run.summary, aiRunProviderName(run)));
+        await postToSlack(target.row.webhookUrl, reviewMessage(ctx, target.workspaceId, facts, verdict, summary, ranBy));
     }
     catch (err) {
         ctx.log.warn({ err, accountId: e.accountId, workspaceId: target.workspaceId, reviewId: e.reviewId }, 'slack review signal send failed');

package/dist/review/agent-context.js

@@ -30,6 +30,7 @@ export function buildAgentContext(log) {
                 const r = detectProviderAuth(provider, kind);
                 return r.status === 'ok' ? { status: 'ok' } : { status: 'none', message: r.message };
             },
+            complete: async (opts) => (await import('./llm.js')).cheapComplete(opts),
         },
         recordAiUsage: (row) => recordAiUsage(row),
         github: {

package/dist/review/claude-review/auto-post.js

@@ -62,10 +62,13 @@ import {} from '../../shared/index.js';
 import { readWorkspaceAutoPostForPr } from './auto-settings.js';
 import { similarTitles } from './settled-by-reply.js';
 import { prAuthorIsAccount } from '../../coding/ai-fix/auto-fix.js';
-import { getClaudeReviewById, getReviewPostContext, isAlreadyPostedReraise, isReaderIgnoredFinding, markReviewPosted, } from './persist.js';
+import { getClaudeReviewById, getReviewPostContext, isAlreadyPostedReraise, isReaderIgnoredFinding, markReviewPosted, readPairConsolidation, } from './persist.js';
 import { resolveFindingBody } from './follow-up.js';
-import { aiRunProviderName, autoPostFooter, limnSeverityLabel, PAIR_AUTO_POST_FOOTER } from '../../shared/index.js';
+import { autoVerdictFor } from './auto-verdict.js';
+import { aiRunProviderName, autoPostFooter, findingSourceLabel, limnSeverityLabel, PAIR_AUTO_POST_FOOTER, } from '../../shared/index.js';
 import { pairRaisedByLead, pairReviewBody, pairVerdict } from './pair.js';
+// A pair's body names both when it falls back to a count ("3 comments from Claude and Codex.").
+const PAIR_BODY_BY = 'Claude and Codex';
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const s = (ctx) => ctx.schema;
 /** May auto-posting write on this PR? null = yes; else why not. */
@@ -143,21 +146,8 @@ export function selectFindingsToPost(findings, kinds, earlier) {
     }
     return { toPost, alreadyPosted };
 }
-/**
- * The verdict an auto post wants — Claude's, made STRICTER. Counts the run's non-story findings
- * a reader did not ignore (whatever the kind toggles say): any blocker ⇒ REQUEST_CHANGES; APPROVE only when
- * Claude approved and there is no warning either; everything else ⇒ COMMENT.
- */
-export function autoVerdictFor(claudeVerdict, findings) {
-    // ⚠ Everything except a READER'S ignore counts — a re-raise the server left out because its
-    // comment is already on this commit is still an open issue (persist.ts `isReaderIgnoredFinding`).
-    const counted = findings.filter((f) => f.story == null && !isReaderIgnoredFinding(f));
-    if (counted.some((f) => f.severity === 'blocker'))
-        return 'REQUEST_CHANGES';
-    if (claudeVerdict === 'APPROVE' && !counted.some((f) => f.severity === 'warning'))
-        return 'APPROVE';
-    return 'COMMENT';
-}
+// THE VERDICT RULE (./auto-verdict.ts), re-exported under its old name.
+export { autoVerdictFor } from './auto-verdict.js';
 /** May an automatic APPROVE go out at this impact level? ⚠ 'unknown' is judged as HIGH. */
 export function impactAllowsApprove(level, allowed) {
     return allowed[level === 'unknown' ? 'high' : level];
@@ -355,9 +345,13 @@ export async function loadUnpostedBlockersOfBlock(ctx, accountId, prId, githubRe
         .from(cr)
         .where(and(eq(cr.prId, prId), eq(cr.accountId, accountId)))
         .execute());
-    const blockRun = runs.find((r) => r.autoPost?.githubReviewId != null && String(r.autoPost.githubReviewId) === githubReviewId);
+    // Every run whose record carries this GitHub review: a pair's combined post is recorded on BOTH
+    // halves, and either half may hold the blocker that was posted (or merged away).
+    const blockRunIds = runs
+        .filter((r) => r.autoPost?.githubReviewId != null && String(r.autoPost.githubReviewId) === githubReviewId)
+        .map((r) => r.id);
     // No such run: the caller only passes ids `loadLimnAutoBlockIds` read, so this is a race — hold.
-    if (!blockRun)
+    if (blockRunIds.length === 0)
         return [-1];
     const rows = (await ctx.db
         .select({
@@ -371,7 +365,9 @@ export async function loadUnpostedBlockersOfBlock(ctx, accountId, prId, githubRe
         storyRef: crf.storyRef,
     })
         .from(crf)
-        .where(eq(crf.reviewId, blockRun.id))
+        // A pair's merged-away duplicate is never posted and never read as a finding: its kept finding
+        // stands for it.
+        .where(and(inArray(crf.reviewId, blockRunIds), isNull(crf.mergedInto)))
         .execute());
     const onGithub = new Map(earlier.map((e) => [e.id, e.onGithub]));
     return rows
@@ -491,9 +487,10 @@ async function writeRecord(ctx, reviewId, rec) {
     const cr = s(ctx).claudeReviews;
     await ctx.db.update(cr).set({ autoPost: rec }).where(eq(cr.id, reviewId)).execute();
 }
-// `inPair`: the comment rides a Claude + Codex pair's one review, so it opens by naming who raised it
-// (story findings are never auto-posted, so the lead slot is free).
-const toPostFinding = (f, by, inPair = false) => ({
+// `tag`: the comment rides a Claude + Codex pair's one review, so it names who raised it — "Claude",
+// "Codex" or "Claude + Codex" (`findingSourceLabel`); null on an ordinary run. (Story findings are never
+// auto-posted, so the lead slot is free.) `by` is the provider whose run holds the finding (its footer).
+const toPostFinding = (f, by, tag = null) => ({
     id: f.id,
     path: f.path,
     line: f.line,
@@ -505,8 +502,8 @@ const toPostFinding = (f, by, inPair = false) => ({
     severity: f.severity,
     // A pair's comment names who raised it ON the ONE severity lead ("**Warning** · Codex"); a finding
     // with no label word (none posted today) falls back to its own "Raised by" line.
-    severityTag: inPair ? by : null,
-    storyLead: inPair && limnSeverityLabel(f.severity) == null ? pairRaisedByLead(by) : null,
+    severityTag: tag,
+    storyLead: tag != null && limnSeverityLabel(f.severity) == null ? pairRaisedByLead(tag) : null,
     // The footer names the provider that ran the review (Claude's text unchanged).
     footer: autoPostFooter(by),
 });
@@ -731,6 +728,15 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
         first = null;
     }
     const pairFirst = first;
+    // THE PAIR'S ONE REVIEW (pair-consolidate.ts): its summary, and who raised each kept finding. A pair
+    // from before the record reads as the two summaries joined and each half's own provider.
+    const consolidation = pairFirst != null ? await readPairConsolidation(ctx, pairFirst.id, prId).catch(() => null) : null;
+    const tagOf = (f) => {
+        if (pairFirst == null)
+            return null;
+        const src = consolidation?.sourceOf[String(f.id)];
+        return src != null ? findingSourceLabel(src) : (byOf.get(f.id) ?? aiRunProviderName(review));
+    };
     const posted = new Set();
     const errors = [];
     const submit = (ev) => ctx.review.postReview({
@@ -739,17 +745,20 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
         prNumber: pctx.prNumber,
         reviewHeadSha: pctx.reviewHeadSha,
         body: pairFirst != null
-            ? pairReviewBody([pairFirst, review].map((r) => {
-                const mine = new Set(r.findings.map((x) => x.id));
-                const n = picked.toPost.filter((f) => mine.has(f.id)).length;
-                return { by: aiRunProviderName(r), text: autoReviewBodyLead(r.summary, n, aiRunProviderName(r)) };
-            }), PAIR_AUTO_POST_FOOTER)
+            ? consolidation?.how === 'pass'
+                ? `${autoReviewBodyLead(consolidation.summary, picked.toPost.length, PAIR_BODY_BY)}\n\n${PAIR_AUTO_POST_FOOTER}`
+                : // Joined in code (or an older pair): each half's lead, named.
+                    pairReviewBody([pairFirst, review].map((r) => {
+                        const mine = new Set(r.findings.map((x) => x.id));
+                        const n = picked.toPost.filter((f) => mine.has(f.id)).length;
+                        return { by: aiRunProviderName(r), text: autoReviewBodyLead(r.summary, n, aiRunProviderName(r)) };
+                    }), PAIR_AUTO_POST_FOOTER)
             : autoReviewBody(review.summary, picked.toPost.length, aiRunProviderName(review)),
         // COMMENT unless auto verdict is on AND its gate let the verdict through.
         verdict: ev,
         // Questions ride the same review: the seam anchors each inline, else falls back. In a pair each
         // comment carries its own provider's footer and names who raised it.
-        includedFindings: picked.toPost.map((f) => toPostFinding(f, byOf.get(f.id) ?? aiRunProviderName(review), pairFirst != null)),
+        includedFindings: picked.toPost.map((f) => toPostFinding(f, byOf.get(f.id) ?? aiRunProviderName(review), tagOf(f))),
         dryRun: false,
     });
     // Did the review half go wrong outright (thrown, or the head moved)? Then nothing more is written.

package/dist/review/claude-review/auto-verdict.js

@@ -0,0 +1,17 @@
+import { isReaderIgnoredFinding } from './finding-facts.js';
+/**
+ * The verdict an auto post wants — Claude's, made STRICTER. Counts the run's non-story findings
+ * a reader did not ignore (whatever the kind toggles say): any blocker ⇒ REQUEST_CHANGES; APPROVE only when
+ * Claude approved and there is no warning either; everything else ⇒ COMMENT.
+ */
+export function autoVerdictFor(claudeVerdict, findings) {
+    // ⚠ Everything except a READER'S ignore counts — a re-raise the server left out because its
+    // comment is already on this commit is still an open issue (`isReaderIgnoredFinding`).
+    const counted = findings.filter((f) => f.story == null && !isReaderIgnoredFinding(f));
+    if (counted.some((f) => f.severity === 'blocker'))
+        return 'REQUEST_CHANGES';
+    if (claudeVerdict === 'APPROVE' && !counted.some((f) => f.severity === 'warning'))
+        return 'APPROVE';
+    return 'COMMENT';
+}
+//# sourceMappingURL=auto-verdict.js.map

package/dist/review/claude-review/chat.js

@@ -2,7 +2,7 @@ import { and, asc, desc, eq, inArray, isNull } from 'drizzle-orm';
 import { CLAUDE_REVIEW_CHAT_EXPLAIN_DEFAULT_QUESTION, CLAUDE_REVIEW_CHAT_MAX_QUESTION_CHARS, CLAUDE_REVIEW_MODELS, aiRunProvider, DEFAULT_CLAUDE_REVIEW_MODEL, } from '../../shared/index.js';
 import { requestModelOf } from '../../ai/provider.js';
 import { AGENTIC_AI_ENABLED, chatMayApplyAuthEnv } from './manager.js';
-import { getClaudeReviewById, getReviewPrContext } from './persist.js';
+import { getReviewPrContext, getReviewView } from './persist.js';
 import { pickReviewNonce } from './prompts.js';
 import { EXPLAIN_INSTRUCTION, EXPLAIN_SYSTEM_ADDENDUM, explainSectionLines, explanationsMarkdown, findingPinLabel, findingPinText, parsePinRefs, questionWithPins, storyPinLabel, storyPinText, validateExplanations, } from './chat-explain.js';
 import { providerName } from '../../ai/prompt-tools.js';
@@ -389,7 +389,8 @@ export async function answerReviewChat(ctx, accountId, reviewId, body) {
     }
     inFlight.set(accountId, reviewId);
     try {
-        const review = await getClaudeReviewById(ctx, reviewId, accountId);
+        // A Claude + Codex pair is asked about as its ONE review (both halves' findings).
+        const review = await getReviewView(ctx, reviewId, accountId);
         if (!review) {
             return { ok: false, status: 404, error: 'NotFound', message: `Review ${reviewId} not found` };
         }
@@ -611,7 +612,8 @@ export function registerClaudeReviewChatRoutes(app, ctx) {
         const { reviewId } = req.params;
         const findingId = req.query.findingId ?? null;
         const accountId = ctx.accountIdOf(req);
-        const review = await getClaudeReviewById(ctx, reviewId, accountId);
+        // A Claude + Codex pair is asked about as its ONE review (both halves' findings).
+        const review = await getReviewView(ctx, reviewId, accountId);
         if (!review)
             return notFound(reply, `Review ${reviewId}`);
         if (findingId != null && !review.findings.some((f) => f.id === findingId)) {

package/dist/review/claude-review/finding-facts.js

@@ -0,0 +1,27 @@
+// PURE FACTS ABOUT A STORED FINDING, shared by persist.ts, the verdict rule (./auto-verdict.ts) and
+// the pair's consolidated view (./pair-view.ts). No imports, so any of them may read these without a
+// cycle. persist.ts re-exports all three under their old names.
+/**
+ * The server's own left-out re-raise: `included: false` stored on a RE-RAISE (a `priorFindingId`)
+ * of a comment already posted on this same commit (follow-up.ts `isAlreadyOnThisCommit`, written
+ * by persist.ts) — an issue still OPEN, just not posted twice.
+ */
+export function isAlreadyPostedReraise(f) {
+    return f.included === false && f.postedAt == null && f.priorFindingId != null;
+}
+/**
+ * `included = false` is TWO facts, and only one is a READER'S IGNORE — every reader of the flag
+ * meaning "the reader ignored it" goes through this, never a bare `included === false`.
+ */
+export function isReaderIgnoredFinding(f) {
+    return f.included === false && !isAlreadyPostedReraise(f);
+}
+/**
+ * A CLAUDE + CODEX PAIR'S MERGED-AWAY DUPLICATE (`claude_review_findings.merged_into`, migration
+ * 0137): the other half's finding stands for it. It stays stored but is never shown, posted, counted
+ * in a verdict or sent to AI Fix — every read of a run's findings leaves it out.
+ */
+export function isMergedAway(f) {
+    return f.mergedInto != null;
+}
+//# sourceMappingURL=finding-facts.js.map

package/dist/review/claude-review/manager.js

@@ -8,6 +8,8 @@ import { decideReviewMode } from './routing.js';
 import { offeredSpecialists } from './specialists.js';
 import { buildUserPrompt, peerRef, pickReviewNonce, skipSummary, sonarHasContent, systemPromptForMode, untrustedTexts, } from './prompts.js';
 import { dropPairRepeats, pairInputOf, pairProvidersReady, readAutoReviewProvidersForPr } from './pair.js';
+import { consolidatePair, notStartedHalf } from './pair-consolidate.js';
+import { markPairBusy } from './pair-view.js';
 import { preflightFor } from '../../ai/run-choice.js';
 import { linkReraisedFindings, reconcileFollowUp, dropAcceptedReraises, isResolvedWithReplies, selectPriorFindings, SINCE_PATCH_CHARS, } from './follow-up.js';
 import { planThreadReview, reconcileThreads } from './threads.js';
@@ -404,11 +406,15 @@ function launch(item) {
     if (item.teamClaim)
         startTeamClaimRenew(ctx, item.teamClaim);
     void runPipeline(item, controller, emit)
-        .then((succeeded) => {
+        .then(async (succeeded) => {
         item.succeeded = succeeded;
         // A pair's FIRST half hands over to its second; everything after a run waits for the pair's end.
         if (pairContinues(item))
             return;
+        // ⚠ A PAIR'S END: the two halves become ONE review BEFORE anything is posted (pair-consolidate.ts).
+        // Still inside the run (slot, claim and stream held), so the tab shows "Merging the two reviews…".
+        if (item.pair?.role === 'second')
+            await consolidateAtPairEnd(item, emit);
         item.autoPosted = runEnded(item, endOf(item, succeeded));
     })
         .catch(async (err) => {
@@ -416,9 +422,12 @@ function launch(item) {
         ctx.log.error({ err }, `claude review pr ${prId} failed: ${err instanceof Error ? err.message : String(err)}`);
         await markReviewFailed(ctx, reviewId, err instanceof Error ? err.message : String(err)).catch(() => { });
         item.succeeded = false;
-        // A pair's second half failing this way still ends the pair: the first half's results stand.
-        if (item.pair?.role === 'second')
+        // A pair's second half failing this way still ends the pair: the first half's results stand,
+        // consolidated as the pair's one review.
+        if (item.pair?.role === 'second') {
+            await consolidateAtPairEnd(item, emit);
             item.autoPosted = runEnded(item, endOf(item, false));
+        }
     })
         .finally(() => {
         // ⚠ A pair's first half keeps the PR's claim and its slot (`startingPair`, taken BEFORE the
@@ -435,8 +444,11 @@ function launch(item) {
         reviewIdByPr.delete(prId);
         controllers.delete(reviewId);
         progressByReview.delete(reviewId);
-        if (continues)
+        if (continues) {
             startingPair.set(prId, item);
+            // The pair reads as running until it ends (pair-view.ts), never as its first half alone.
+            markPairBusy(item.pair.pairId, true);
+        }
         else {
             claimed.delete(prId);
             emitDone(ctx, prId, item.accountId, reviewId);
@@ -447,6 +459,29 @@ function launch(item) {
             void startPairSecond(item);
     });
 }
+/**
+ * A pair's end, on its second half (succeeded, failed or stopped): consolidate the two into ONE review
+ * and store it (pair-consolidate.ts) — with the quick pass when both succeeded ("Merging the two
+ * reviews…"), else in code. Marked "merging" meanwhile, so every read shows the pair as running.
+ * Never throws: a consolidation failure never fails the pair.
+ */
+async function consolidateAtPairEnd(item, emit) {
+    const p = item.pair;
+    if (p?.role !== 'second')
+        return;
+    markPairBusy(p.pairId, true);
+    try {
+        if (p.firstSucceeded && item.succeeded)
+            emit({ phase: 'merging' });
+        await consolidatePair(item.ctx, { accountId: item.accountId, prId: item.prId, pairId: p.pairId, secondId: item.reviewId });
+    }
+    catch (err) {
+        item.ctx.log.warn(`claude review pr ${item.prId}: consolidating the pair failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        markPairBusy(p.pairId, false);
+    }
+}
 function emitDone(ctx, prId, accountId, reviewId) {
     void getLatestClaudeReview(ctx, prId, accountId)
         .then((latest) => emitReviewStream(prId, { type: 'done', status: latest?.status ?? 'failed', reviewId }))
@@ -578,8 +613,11 @@ async function startPairSecond(first) {
     const provider = pair.secondProvider;
     let launched = false;
     let teamClaim = null;
+    // Why the second half did not start (the pair's one review names it).
+    let why = 'error';
     try {
         if (first.trigger === 'auto' && !pair.pressed && !(await automaticRunAllowed(ctx, accountId, 'auto review (second half)'))) {
+            why = 'budget';
             return;
         }
         // TEAM CLAIMS: an AUTO pair's second half claims its OWN provider's context. A teammate's Limn
@@ -594,8 +632,10 @@ async function startPairSecond(first) {
                 headSha: first.headSha,
                 provider,
             }, { pressed: pair.pressed === true });
-            if (claim.kind === 'skip')
+            if (claim.kind === 'skip') {
+                why = 'claimed';
                 return;
+            }
             teamClaim = claim.kind === 'run' ? claim.handle : null;
         }
         const firstReview = first.succeeded ? await getClaudeReviewById(ctx, first.reviewId, accountId) : null;
@@ -605,6 +645,8 @@ async function startPairSecond(first) {
             await saveTeamClaimRecord(ctx, reviewId, teamClaim.record).catch(() => { });
         startingPair.delete(prId);
         launched = true;
+        // The second half's row is running now; the end (consolidateAtPairEnd) marks the merge itself.
+        markPairBusy(pair.pairId, false);
         launch({
             ctx,
             accountId,
@@ -623,7 +665,7 @@ async function startPairSecond(first) {
                 first,
                 firstSucceeded: first.succeeded === true,
                 input: firstFindings.length > 0 ? pairInputOf(first.provider, firstFindings) : null,
-                firstFindings: firstFindings.map((f) => ({ path: f.path, line: f.line, title: f.title })),
+                firstFindings: firstFindings.map((f) => ({ path: f.path, line: f.line, title: f.title, priorFindingId: f.priorFindingId ?? null })),
             },
         });
     }
@@ -632,11 +674,18 @@ async function startPairSecond(first) {
     }
     finally {
         if (!launched) {
-            // The pair ends on its first half.
+            // The pair ends on its first half: stored as the pair's one review (naming the half that did
+            // not start) BEFORE the end is announced and anything is posted.
             startingPair.delete(prId);
             claimed.delete(prId);
-            emitDone(ctx, prId, accountId, first.reviewId);
-            first.autoPosted = runEnded(first, { reviewId: first.reviewId, succeeded: first.succeeded === true });
+            const consolidated = first.succeeded === true
+                ? consolidatePair(ctx, { accountId, prId, pairId: pair.pairId, secondId: null, notStarted: notStartedHalf(provider, why) })
+                : Promise.resolve(null);
+            first.autoPosted = consolidated.then(() => {
+                markPairBusy(pair.pairId, false);
+                emitDone(ctx, prId, accountId, first.reviewId);
+                return runEnded(first, { reviewId: first.reviewId, succeeded: first.succeeded === true });
+            });
             // TEAM CLAIMS: a claim this half posted before its row could be written is released, and the
             // first half's held line gets its final one.
             if (teamClaim)
@@ -699,7 +748,7 @@ async function runPipeline(item, controller, emit) {
     const settledIds = new Set(settled.map((f) => f.id));
     const prior = fresh
         ? null
-        : await loadPriorReviewForFollowUp(ctx, item.prId, item.accountId, reviewId, settledIds, item.provider);
+        : await loadPriorReviewForFollowUp(ctx, item.prId, item.accountId, reviewId, settledIds, item.provider, item.pair != null);
     // BACKWARD COMPATIBILITY: findings the RETIRED settle-on-sight rule took out of the chain were
     // never judged. Load them as carried items; only the ones whose thread is resolved WITH a
     // person's reply are kept (below), so they are judged once like any other.

package/dist/review/claude-review/manual-reply.js

@@ -14,7 +14,7 @@
 // re-claim of a refused record (local-only feature: one process).
 import { and, eq, isNull } from 'drizzle-orm';
 import { FINDING_REPLY_MARKER, } from '../../shared/index.js';
-import { getClaudeReviewById } from './persist.js';
+import { getReviewView } from './persist.js';
 import { findFindingThread } from './finding-thread.js';
 import { PUSHBACK_MARKER, accountLoginOf, isClearReplyRefusal, loadPrThreads, loadThreadOwners, pushbackMayBePosted, resolveReplyMayBePosted, threadHasPushback, } from './finding-replies.js';
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -68,7 +68,8 @@ const inFlight = new Set(); // thread OWNER finding ids
 const conflict = (code, message) => ({ kind: 'conflict', code, message });
 /** Post the reply a reply status drafted, on that finding's thread. Never posts twice. */
 export async function postFollowUpReply(ctx, { accountId, reviewId, priorFindingId }, deps = defaultManualReplyDeps) {
-    const review = await getClaudeReviewById(ctx, reviewId, accountId);
+    // A Claude + Codex pair is one review: its follow-up holds both halves' items (pair-view.ts).
+    const review = await getReviewView(ctx, reviewId, accountId);
     if (!review || review.status !== 'succeeded')
         return { kind: 'not_found' };
     const item = review.followUp?.items.find((it) => it.priorFindingId === priorFindingId);