limn-review 0.1.140 → 0.1.142

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/erase-account.js

@@ -168,6 +168,8 @@ export async function eraseAccountData(accountId) {
         // hold third-party analysis of the account's code. No FK on the snapshots, so this is the whole
         // guarantee; workspace_sonar cascades from workspaces too, and is explicit anyway.
         await tx.delete(schema.sonarSnapshots).where(eq(schema.sonarSnapshots.accountId, accountId)).execute();
+        // The team-claim ledger (migration 0138): GitHub logins and heads. No FK, so this is the whole guarantee.
+        await tx.delete(schema.teamClaimLines).where(eq(schema.teamClaimLines.accountId, accountId)).execute();
         await tx.delete(schema.workspaceSonar).where(eq(schema.workspaceSonar.accountId, accountId)).execute();
         // Sequence diagrams (migration 0115 / pg 0102): no FKs, so this is the whole guarantee (story rows
         // carry no pr_id and are reached ONLY here).
@@ -330,6 +332,8 @@ export function accountScopedTables() {
         { name: 'workspaceTrackers', col: schema.workspaceTrackers.accountId, table: schema.workspaceTrackers },
         // SonarCloud (migration 0114 / pg 0101), erased explicitly above; `workspaceSonar` holds a credential.
         { name: 'sonarSnapshots', col: schema.sonarSnapshots.accountId, table: schema.sonarSnapshots },
+        // The team-claim ledger (migration 0138), erased explicitly above.
+        { name: 'teamClaimLines', col: schema.teamClaimLines.accountId, table: schema.teamClaimLines },
         { name: 'workspaceSonar', col: schema.workspaceSonar.accountId, table: schema.workspaceSonar },
         // Sequence diagrams (migration 0115 / pg 0102), erased explicitly above.
         { name: 'sequenceDiagrams', col: schema.sequenceDiagrams.accountId, table: schema.sequenceDiagrams },

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/0138_team_claim_lines.sql

@@ -0,0 +1,55 @@
+-- THE TEAM-CLAIM LEDGER (docs/CLAUDE-REVIEW.md § Team claims → Releasing stale lines). One row per
+-- GitHub status line (`limn/review-claude` | `limn/review-codex`) Limn holds or released on a PR
+-- head, written BEFORE the pending line is posted, so a restart, a dropped run or a failed final write
+-- never leaves this machine's line pending: the reconciler releases every open row whose run is not
+-- running. `whose = 'teammate'` records a teammate's expired line released once.
+CREATE TABLE `team_claim_lines` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`pr_id` integer NOT NULL,
+	`repo_id` integer,
+	`owner` text,
+	`name` text,
+	`head_sha` text NOT NULL,
+	`provider` text NOT NULL,
+	`review_id` integer,
+	`whose` text DEFAULT 'mine' NOT NULL,
+	`state` text NOT NULL,
+	`login` text,
+	`final_description` text,
+	`final_target_url` text,
+	`release_attempts` integer DEFAULT 0 NOT NULL,
+	`last_error` text,
+	`created_at` integer DEFAULT (unixepoch()) NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `team_claim_lines_state` ON `team_claim_lines` (`state`);
+--> statement-breakpoint
+CREATE INDEX `team_claim_lines_account_pr_head` ON `team_claim_lines` (`account_id`,`pr_id`,`head_sha`);
+--> statement-breakpoint
+-- Lines older Limn versions left PENDING (a failed run's "didn't finish · free to claim", or a run that
+-- died mid-way): the newest auto run's record per (PR, head, context), when it is still pending, from
+-- the last 14 days. The reconciler replaces each with the success release line at boot — only where the
+-- head's newest line is still this account's pending one (it reads GitHub first).
+INSERT INTO `team_claim_lines` (`account_id`, `pr_id`, `repo_id`, `owner`, `name`, `head_sha`, `provider`, `review_id`, `whose`, `state`)
+SELECT cr.`account_id`, cr.`pr_id`, pr.`repo_id`, r.`owner`, r.`name`, cr.`head_sha`,
+	CASE json_extract(cr.`team_claim`, '$.context') WHEN 'limn/review-codex' THEN 'codex' ELSE 'claude' END,
+	cr.`id`, 'mine', 'pending'
+FROM `claude_reviews` cr
+JOIN `pull_requests` pr ON pr.`id` = cr.`pr_id`
+JOIN `repos` r ON r.`id` = pr.`repo_id`
+WHERE cr.`team_claim` IS NOT NULL
+	AND json_valid(cr.`team_claim`)
+	AND json_extract(cr.`team_claim`, '$.state') = 'marked'
+	AND json_extract(cr.`team_claim`, '$.lastLine') IN ('reviewing', 'unfinished')
+	AND cr.`created_at` >= unixepoch() - 14 * 86400
+	AND cr.`id` = (
+		SELECT MAX(c2.`id`) FROM `claude_reviews` c2
+		WHERE c2.`account_id` = cr.`account_id`
+			AND c2.`pr_id` = cr.`pr_id`
+			AND c2.`head_sha` = cr.`head_sha`
+			AND c2.`team_claim` IS NOT NULL
+			AND json_valid(c2.`team_claim`)
+			AND json_extract(c2.`team_claim`, '$.context') = json_extract(cr.`team_claim`, '$.context')
+	);

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

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

package/dist/db/queries.js

@@ -18,6 +18,7 @@ const REASON_PRIORITY = [
 ];
 import { db, schema } from './client.js';
 import { dropRepoRelations } from './related-repos.js';
+import { deleteSettledClaimLinesForPrs } from './team-claim-lines-delete.js';
 import { runTransaction } from './client.js';
 import { enrichMyTurn } from '../feed/my-turn.js';
 import { resolvePrTickets } from '../pr/detail-enricher.js';
@@ -7873,6 +7874,9 @@ export async function deleteRepo(id, accountId) {
             await tx.delete(schema.trackerTickets).where(inArray(schema.trackerTickets.prId, prIds)).execute();
             // SonarCloud snapshots (migration 0114 / pg 0101). No FKs, so nothing would cascade.
             await tx.delete(schema.sonarSnapshots).where(inArray(schema.sonarSnapshots.prId, prIds)).execute();
+            // The team-claim ledger (migration 0138). No FKs, so nothing would cascade. This machine's OPEN
+            // rows stay: their lines still need releasing on GitHub (db/team-claim-lines-delete.ts).
+            await deleteSettledClaimLinesForPrs(tx, prIds);
             // Sequence diagrams of these PRs, and the story diagrams naming any of them (migration 0115 /
             // pg 0102). No FKs, so nothing would cascade. Before the PRs go: it reads their accounts.
             await pruneSequenceDiagramsForPrs(tx, prIds);
@@ -8038,6 +8042,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 +8054,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 +8100,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 +8110,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 +8131,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/retention.js

@@ -4,6 +4,7 @@ import { config } from '../config.js';
 import { pruneTicketReviewsForPrs } from './ticket-review-prune.js';
 import { pruneCiReviewsForPrs } from './ci-review-prune.js';
 import { pruneSequenceDiagramsForPrs } from './sequence-diagram-prune.js';
+import { deleteSettledClaimLinesForPrs } from './team-claim-lines-delete.js';
 // Time-based retention sweep. Per-account server data (events, PRs + their whole subtree)
 // accumulates forever otherwise; this prunes anything past the retention window so the DB
 // stays bounded (the pre-launch, tight-budget scalability lever). Runs periodically from
@@ -100,6 +101,9 @@ async function deletePrSubtree(tx, prIds) {
     await tx.delete(schema.trackerTickets).where(inArray(schema.trackerTickets.prId, prIds)).execute();
     // SonarCloud snapshots (migration 0114 / pg 0101). No FKs — explicit, pr-keyed.
     await tx.delete(schema.sonarSnapshots).where(inArray(schema.sonarSnapshots.prId, prIds)).execute();
+    // The team-claim ledger (migration 0138). No FKs — explicit, pr-keyed. This machine's OPEN rows
+    // stay: their lines still need releasing on GitHub (db/team-claim-lines-delete.ts).
+    await deleteSettledClaimLinesForPrs(tx, prIds);
     // Sequence diagrams of these PRs, and the story diagrams naming any of them (migration 0115 / pg
     // 0102). No FKs. Before the PRs go: it reads their accounts.
     await pruneSequenceDiagramsForPrs(tx, prIds);

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
@@ -3378,4 +3390,51 @@ export const storyDocsAlignments = sqliteTable('story_docs_alignments', {
         foreignColumns: [workspaces.id, workspaces.accountId],
     }).onDelete('cascade'),
 }));
+// team_claim_lines — THE TEAM-CLAIM LEDGER (migration 0138; docs/CLAUDE-REVIEW.md § Team claims →
+// Releasing stale lines). ONE row per GitHub status line Limn holds or has released on a PR head, so a
+// line this machine posted is never left pending by a restart, a dropped run or a failed final write:
+//   whose 'mine'     a claim this machine made. Written as 'claiming' BEFORE the pending line is posted,
+//                    'pending' once it is up, 'finished' when the success line ("reviewed") is up,
+//                    'released' when the release line ("didn't finish · free to claim"), a Clear, a
+//                    newer claim at the same head, or GitHub's refusal ended it.
+//   whose 'teammate' a teammate's expired line this machine released ("Released: bob's claim
+//                    expired"), recorded so it is posted ONCE. Always 'released'.
+// The reconciler (review/claude-review/team-claim-release.ts) releases every 'claiming' / 'pending'
+// row whose run is not queued or running in this process. No FK on pr_id (the sonar_snapshots
+// precedent): BOTH delete paths (deleteRepo, retention's deletePrSubtree) delete its rows EXCEPT this
+// machine's OPEN ones (a pending line on GitHub still needs its release; the row carries owner/name);
+// the erasure deletes everything.
+export const teamClaimLines = sqliteTable('team_claim_lines', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    accountId: integer('account_id').notNull(),
+    prId: integer('pr_id').notNull(),
+    repoId: integer('repo_id'),
+    // The repo's owner/name when the row was written: an open line is still released after its PR or
+    // repo left Limn (the delete paths keep OPEN 'mine' rows for exactly that).
+    owner: text('owner'),
+    name: text('name'),
+    headSha: text('head_sha').notNull(),
+    // 'claude' | 'codex' — the status context (`limn/review-<provider>`).
+    provider: text('provider').notNull(),
+    // The run the claim was for (NULL until its row is written, and on a teammate's line).
+    reviewId: integer('review_id'),
+    whose: text('whose', { enum: ['mine', 'teammate'] }).notNull().default('mine'),
+    state: text('state', { enum: ['claiming', 'pending', 'finished', 'released'] }).notNull(),
+    // The GitHub login the line names (NULL on a row backfilled from before the ledger: the
+    // account's login is used).
+    login: text('login'),
+    // A success line that could not be written when the run finished: the reconciler posts IT
+    // instead of the release line.
+    finalDescription: text('final_description'),
+    finalTargetUrl: text('final_target_url'),
+    releaseAttempts: integer('release_attempts').notNull().default(0),
+    lastError: text('last_error'),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull().default(sql `(unixepoch())`),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull().default(sql `(unixepoch())`),
+}, (t) => ({
+    // The reconciler's read (open rows).
+    stateIdx: index('team_claim_lines_state').on(t.state),
+    // One head's rows (supersede, Clear, the tab's "Clear" offer).
+    prHeadIdx: index('team_claim_lines_account_pr_head').on(t.accountId, t.prId, t.headSha),
+}));
 //# sourceMappingURL=schema.sqlite.js.map

package/dist/db/team-claim-lines-delete.js

@@ -0,0 +1,18 @@
+// The team-claim ledger's DELETE-PATH rule (migration 0138; docs/CLAUDE-REVIEW.md § Team claims →
+// Releasing stale lines). When PRs leave Limn (deleteRepo, retention's deletePrSubtree), their ledger
+// rows go — EXCEPT this machine's OPEN ones ('mine', 'claiming' / 'pending'): each stands for a line
+// that may still be pending on GitHub, and the reconciler releases it from the row's own owner/name
+// (it closes a row that has neither). The account erasure deletes every row regardless.
+import { and, eq, inArray, not } from 'drizzle-orm';
+import { schema } from './client.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export async function deleteSettledClaimLinesForPrs(tx, prIds) {
+    if (prIds.length === 0)
+        return;
+    const tl = schema.teamClaimLines;
+    await tx
+        .delete(tl)
+        .where(and(inArray(tl.prId, prIds), not(and(eq(tl.whose, 'mine'), inArray(tl.state, ['claiming', 'pending'])))))
+        .execute();
+}
+//# sourceMappingURL=team-claim-lines-delete.js.map

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/agentic.js

@@ -101,6 +101,11 @@ export async function startAgenticBackground(app) {
     catch (err) {
         app.log.warn({ err }, 'claude review: startup reconcile failed');
     }
+    // TEAM CLAIMS: a run this process lost (a restart mid-review) left its limn/review-* line pending on
+    // GitHub; release every such line now, in the BACKGROUND (GitHub calls; never fails or delays the boot).
+    void import('./claude-review/team-claim-release.js')
+        .then((m) => m.releaseStaleTeamClaims(ctx))
+        .catch((err) => app.log.warn({ err }, 'team claim release at boot failed'));
     try {
         await reconcileThreadChecksOnStartup(ctx);
     }

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/auto.js

@@ -572,6 +572,11 @@ export function registerAutoReview(ctx) {
         return;
     ctx.registerScheduledJob(AUTO_REVIEW_CRON, async () => {
         await runAutoReviewSweep(ctx);
+        // TEAM CLAIMS: release every limn/review-* line of ours no run holds any more, and teammates'
+        // expired ones (team-claim-release.ts). Never throws; never blocks the sweep.
+        await import('./team-claim-release.js')
+            .then((m) => m.releaseStaleTeamClaims(ctx))
+            .catch((err) => ctx.log.warn(`team claim release: ${err instanceof Error ? err.message : String(err)}`));
     }, 'claude-auto-review');
 }
 //# sourceMappingURL=auto.js.map