limn-review 0.1.180 → 0.1.181

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

@@ -177,6 +177,11 @@ function tierFor(method, path) {
     // EXACT `===` for the same near-miss.
     if (path === '/api/me/my-turn-settings')
         return [TIERS.read];
+    // GET /api/my-turn/pushed-since/:prId — the expanded "N commits since you …" list on a Pushed
+    // since card. FOLLOWING THE TOKEN: two DB reads over synced `commits`/`reviews`/comments, no
+    // GitHub call, no model. Recorded, EXACT pattern, so a future live variant is not inherited.
+    if (/^\/api\/my-turn\/pushed-since\/\d+$/.test(path))
+        return [TIERS.read];
     // PUT /api/me/feature-settings — Settings → Features (which sidebar destinations show). One
     // validated UPDATE plus DB-only reads; no GitHub, no model. Recorded, EXACT `===`.
     if (path === '/api/me/feature-settings')

package/dist/api/routes/me.js

@@ -15,7 +15,8 @@ import { codexDetailCached } from '../../ai/codex/detect.js';
 import { usageLockedUntilIso } from '../../ai/usage-lockout.js';
 import { aiEffortSettingStatus } from '../../ai/effort.js';
 import { aiProviderSettingStatus, ALL_RUN_KINDS, CODEX_NOT_AVAILABLE_MESSAGE, CODEX_RUNNABLE, getActiveProvider, } from '../../ai/provider.js';
-import { getMyTurn } from '../../db/queries.js';
+import { getMyTurn, resolveWorkspaceScope } from '../../db/queries.js';
+import { getPushedSinceCommits } from '../../db/my-turn-pushed-since.js';
 import { clearDailyBriefCountsFor } from '../../db/daily-brief.js';
 import { dismissMyTurn, restoreMyTurn } from '../../db/my-turn-dismissals.js';
 import { featureFacts } from '../../db/feature-gates.js';
@@ -425,6 +426,22 @@ export async function meRoutes(app) {
     // The account-wide inbox. Unscoped on purpose (see `getMyTurn`): the browser-notification
     // watcher reads exactly this call — and without `onePerPr`, which is the board's rule.
     app.get('/api/my-turn', async (req) => getMyTurn(accountIdOf(req)));
+    // EVERY commit a "Pushed since" card counts — its expanded "N commits since you …" list. The
+    // SAME fold as the count (db/my-turn-pushed-since.ts). DB only; the SPA fetches it only when the
+    // reader expands the card. Scoped by `?workspace=` (absent/unknown ⇒ the default); a PR outside
+    // the account or the workspace answers 404, so the route is no existence oracle.
+    app.get('/api/my-turn/pushed-since/:prId', async (req, reply) => {
+        const raw = req.params.prId ?? '';
+        if (!/^[1-9][0-9]{0,15}$/.test(raw)) {
+            return reply.code(400).send({ error: 'BadRequest', message: 'Unknown pull request.' });
+        }
+        const accountId = accountIdOf(req);
+        const scope = await resolveWorkspaceScope(accountId, req.query.workspace);
+        const body = await getPushedSinceCommits(accountId, Number(raw), scope.workspaceId, scope.repoIds);
+        if (body == null)
+            return reply.code(404).send({ error: 'NotFound', message: 'Not found' });
+        return body;
+    });
     // DISMISS / BRING BACK one My Turn subject — a pull request (`pr`) or, for a red default branch,
     // a repository (`repo`). ⚠ NOT the "Done" routes 0060 deleted: a dismissal lasts only until
     // something newer happens on the subject, and a subject that leaves your plate discharges it

package/dist/db/migrations/0164_teammate_block_lift.sql

@@ -0,0 +1,7 @@
+-- LIFTING A TEAMMATE'S LIMN BLOCK (docs/CLAUDE-REVIEW.md § Lifting a teammate's block). On an imported
+-- teammate review (`claude_reviews.kind = 'teammate'`), the reader's Limn's ONE attempt to dismiss that
+-- teammate's standing Request changes: JSON `TeammateLiftRecord` — claimed (NULL → 'dismissing') by a
+-- compare-and-set BEFORE the GitHub write, then settled 'dismissed' or 'failed' with GitHub's words.
+-- Never retried: a row that is not NULL is never claimed again. The teammate-review import never writes
+-- it. NULL on every run of the reader's own. Additive and nullable: no backfill.
+ALTER TABLE `claude_reviews` ADD `teammate_lift` text;

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

@@ -1149,6 +1149,13 @@
       "when": 1792224069016,
       "tag": "0163_pr_cross_repository",
       "breakpoints": true
+    },
+    {
+      "idx": 164,
+      "version": "6",
+      "when": 1792224071016,
+      "tag": "0164_teammate_block_lift",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/my-turn-pushed-since.js

@@ -0,0 +1,74 @@
+import { and, eq, inArray } from 'drizzle-orm';
+import { PUSHED_SINCE_LIST_MAX, } from '../shared/index.js';
+import { db, schema } from './client.js';
+import { lastActionClocks } from './queries.js';
+import { getAccountUserId } from '../auth/account.js';
+const { commits, pullRequests } = schema;
+// ── "N COMMITS SINCE YOU …" — THE EXPANDED LIST ON A "PUSHED SINCE" MY TURN CARD ───────────────
+//
+// The card carries the count (`NewPrBall.humanCommitsAfter`) and the newest `PUSHED_COMMITS_SHOWN`.
+// When the reader opens the card's disclosure, this lists EVERY commit that count names. It runs
+// the SAME fold (`lastActionClocks`) on the one PR, so the list and the count cannot disagree:
+// human commits by someone other than you, strictly after your last review (any state), review
+// comment, PR comment or push. NOT "since you last looked" — viewing is not acting (`pr_views` is
+// never read here, as in the fold). DB only; ⚠ fetched only on expand, never on the board's mount.
+/** null ⇔ the PR is not this account's, or not in the workspace's repos (→ 404). */
+export async function getPushedSinceCommits(accountId, prId, workspaceId, repoIds, listMax = PUSHED_SINCE_LIST_MAX) {
+    if (repoIds.length === 0)
+        return null;
+    const pr = await db
+        .select({ id: pullRequests.id })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.id, prId), eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, [...repoIds])))
+        .limit(1)
+        .execute();
+    if (pr.length === 0)
+        return null;
+    const empty = {
+        workspaceId,
+        prId,
+        yourLastAction: null,
+        anchorAt: null,
+        total: 0,
+        commits: [],
+    };
+    const viewerId = await getAccountUserId(accountId);
+    if (viewerId == null)
+        return empty;
+    const c = (await lastActionClocks(viewerId, [prId])).get(prId);
+    if (!c || c.mineLast == null)
+        return empty;
+    const counted = [...c.humanCommitIdsAfterMine].sort((a, b) => b.at.getTime() - a.at.getTime() || b.id - a.id);
+    const shownIds = counted.slice(0, Math.max(0, listMax)).map((x) => x.id);
+    let list = [];
+    if (shownIds.length > 0) {
+        const rows = await db
+            .select({
+            id: commits.id,
+            sha: commits.sha,
+            headline: commits.messageHeadline,
+            authorId: commits.authorId,
+            at: commits.committedAt,
+        })
+            .from(commits)
+            .where(and(eq(commits.prId, prId), inArray(commits.id, shownIds)))
+            .execute();
+        list = rows
+            .sort((a, b) => b.at.getTime() - a.at.getTime() || b.id - a.id)
+            .map((r) => ({
+            sha: r.sha,
+            headline: r.headline ?? null,
+            authorId: r.authorId,
+            at: r.at.toISOString(),
+        }));
+    }
+    return {
+        workspaceId,
+        prId,
+        yourLastAction: c.mineLastAction,
+        anchorAt: c.mineLast.toISOString(),
+        total: c.humanCommitsAfterMine,
+        commits: list,
+    };
+}
+//# sourceMappingURL=my-turn-pushed-since.js.map

package/dist/db/schema.sqlite.js

@@ -1235,6 +1235,11 @@ export const claudeReviews = sqliteTable('claude_reviews', {
     sourceUserId: integer('source_user_id').references(() => users.id),
     sourceReviewNodeId: text('source_review_node_id'),
     teammate: text('teammate', { mode: 'json' }).$type(),
+    // On a TEAMMATE review only (migration 0164; review/claude-review/teammate-lift.ts): the reader's
+    // Limn's ONE attempt to dismiss this teammate's standing Request changes. Claimed NULL →
+    // 'dismissing' BEFORE the GitHub write, settled 'dismissed' / 'failed'; never retried. The import
+    // never writes it.
+    teammateLift: text('teammate_lift', { mode: 'json' }).$type(),
 }, (t) => ({
     prIdx: index('cr_pr_idx').on(t.prId),
     prShaIdx: index('cr_pr_sha_idx').on(t.prId, t.headSha),

package/dist/db/teammate-reviews-import.js

@@ -47,6 +47,21 @@ const STATE_VERDICT = {
     changes_requested: 'REQUEST_CHANGES',
     commented: 'COMMENT',
 };
+/** A pair's finding comments → who raised each, from the lead's tag ("Codex", "Claude + Codex"). */
+function pairProviders(parsed) {
+    const out = {};
+    for (const { c, p } of parsed) {
+        const t = (p.tag ?? '').toLowerCase();
+        const who = [];
+        if (/\bclaude\b/.test(t))
+            who.push('claude');
+        if (/\bcodex\b/.test(t))
+            who.push('codex');
+        if (who.length > 0)
+            out[c.nodeId] = who;
+    }
+    return Object.keys(out).length > 0 ? { findingProviders: out } : {};
+}
 /**
  * Import every review a teammate's Limn posted on this PR (see the header). Returns what it wrote.
  * Safe to call after every walk of the PR; one transaction.
@@ -184,6 +199,9 @@ export async function importTeammateReviews(accountId, prId) {
                 ...(parsed.some((x) => x.p.severity == null)
                     ? { unlabelled: parsed.filter((x) => x.p.severity == null).map((x) => x.c.nodeId) }
                     : {}),
+                ...(meta.judged != null && meta.judged.length > 0 ? { judged: meta.judged } : {}),
+                ...(meta.liftConsent === true ? { liftConsent: true } : {}),
+                ...(meta.pair ? pairProviders(parsed) : {}),
             };
             const first = meta.runs[0];
             const values = {

package/dist/db/teammate-reviews.js

@@ -37,6 +37,7 @@ export async function listTeammateReviews(exec, accountId, prId) {
         postedAt: cr.postedAt,
         createdAt: cr.createdAt,
         teammate: cr.teammate,
+        teammateLift: cr.teammateLift,
         userId: users.id,
         login: users.githubLogin,
         displayName: users.displayName,
@@ -85,6 +86,14 @@ export async function listTeammateReviews(exec, accountId, prId) {
         const rec = (r.teammate ?? null);
         const unlabelled = new Set(rec?.unlabelled ?? []);
         const prUrl = `https://github.com/${r.owner}/${r.name}/pull/${r.number}`;
+        // Who raised each finding: a pair comment's lead tag, else the single run's provider.
+        const single = rec != null && !rec.pair && rec.runs.length === 1 ? rec.runs[0]?.provider ?? null : null;
+        const providersOf = (nodeId) => {
+            const tagged = nodeId != null ? rec?.findingProviders?.[nodeId] : undefined;
+            if (tagged != null && tagged.length > 0)
+                return { providers: tagged };
+            return single != null ? { providers: [single] } : {};
+        };
         const mine = findings
             .filter((f) => f.reviewId === r.id)
             .map((f) => {
@@ -103,6 +112,8 @@ export async function listTeammateReviews(exec, accountId, prId) {
                         ? `${prUrl}#discussion_r${f.githubCommentId}`
                         : `${prUrl}#issuecomment-${f.githubCommentId}`,
                 threadId: kind === 'inline' && f.nodeId != null ? (threadOf.get(f.nodeId) ?? null) : null,
+                ...providersOf(f.nodeId),
+                githubCommentId: f.githubCommentId ?? null,
             };
         });
         const at = r.postedAt ?? r.createdAt;
@@ -120,6 +131,9 @@ export async function listTeammateReviews(exec, accountId, prId) {
             runs: rec?.runs ?? [],
             limnVersion: rec?.limnVersion ?? null,
             findings: mine,
+            ...(rec?.judged != null && rec.judged.length > 0 ? { judged: rec.judged } : {}),
+            // The reader's Limn's one attempt to lift this block (migration 0164).
+            ...(r.teammateLift != null ? { lift: r.teammateLift } : {}),
         };
     });
 }

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

@@ -78,8 +78,9 @@ import { resolveFindingBody } from './follow-up.js';
 import { autoVerdictFor, findingsNotApproved, pairVerdict, reasonMayPost, safeReasonText, withReason, } from './auto-verdict.js';
 import { aiRunProviderName, autoPostFooter, findingSourceLabel, limnSeverityLabel, PAIR_AUTO_POST_FOOTER, } from '../../shared/index.js';
 import { pairRaisedByLead, pairReviewBody } from './pair.js';
-import { limnMetaForReview } from './post-meta.js';
+import { limnMetaForReview, loadJudgedForPost } from './post-meta.js';
 import { TEAMMATE_KIND, ownRunsOnly } from '../../db/teammate-reviews.js';
+import { claimTeammateLift, liveLiftCheck, loadTeammateLiftCandidates, settleTeammateLift, teammateLiftMessage, } from './teammate-lift.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 */
@@ -171,6 +172,17 @@ export function selectFindingsToPost(findings, kinds, earlier) {
     }
     return { toPost, alreadyPosted };
 }
+/**
+ * May this post carry `lift=1` (the poster's consent to a teammate's Limn lifting its block)? Only
+ * when every BLOCKER the verdict counts is one of the post's own comments. A blocker already on GitHub
+ * from an earlier post is left out of this one, yet still makes it a REQUEST_CHANGES: a teammate's
+ * Limn reads the block's points from its comments alone (teammate-lift.ts `pointsBehindBlock`), so
+ * it could lift a block whose real reason it never checked.
+ */
+export function blockersAllInPost(findings, toPost) {
+    const posted = new Set(toPost.map((f) => f.id));
+    return findings.every((f) => f.severity !== 'blocker' || f.story != null || isReaderIgnoredFinding(f) || posted.has(f.id));
+}
 // 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. */
@@ -324,7 +336,7 @@ export const defaultAutoPostDeps = {
         for (let page = 1; page <= 10; page += 1) {
             const rows = await ghRestGet(`/repos/${owner}/${name}/pulls/${prNumber}/reviews?per_page=100&page=${page}`);
             for (const r of rows)
-                out.push({ id: r.id, login: r.user?.login ?? null, state: r.state });
+                out.push({ id: r.id, login: r.user?.login ?? null, state: r.state, body: r.body ?? null });
             if (rows.length < 100)
                 return out;
         }
@@ -714,10 +726,35 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
     // (Read for a REQUEST_CHANGES too: the gate must tell Limn's own standing block from a person's.)
     const limnBlockIds = !facts.authorIsMe ? await loadLimnAutoBlockIds(ctx, accountId, prId, reviewId) : new Set();
     const mayLift = noBlocker && unjudgedBlockers.length === 0 && limnBlockIds.size > 0;
+    // LIFTING A TEAMMATE'S LIMN BLOCK (./teammate-lift.ts): the DB pre-check first (both opt-ins, every
+    // point behind the block settled), so an ordinary run costs no extra GitHub read.
+    let readerLogin = null;
+    let teammateCandidates = [];
+    if (ws.settings.liftTeammateBlocks && !facts.authorIsMe && noBlocker && unjudgedBlockers.length === 0) {
+        try {
+            readerLogin = await deps.accountLogin(accountId);
+            teammateCandidates = await loadTeammateLiftCandidates(ctx, {
+                accountId,
+                prId,
+                reviewId,
+                headSha: review.headSha,
+                leftovers: rules.approveLeftovers,
+                readerLogin,
+            });
+        }
+        catch (err) {
+            ctx.log.warn(`auto post review ${reviewId}: could not read teammates' blocks: ${errText(err)}`);
+        }
+    }
+    const mayLiftTeammate = teammateCandidates.length > 0;
     // A COMMENT-only run with a reason still to tell GitHub goes on (to the reason-only review).
     // (Never while a review request of the reader is open: any review answers it.)
     const commentReasonToPost = wanted === 'COMMENT' && reasonMayPost(verdict) && !reasonAlreadyAtHead && facts.openRequestOfMe !== true;
-    if (picked.toPost.length === 0 && (wanted == null || wanted === 'COMMENT') && !mayLift && !commentReasonToPost) {
+    if (picked.toPost.length === 0 &&
+        (wanted == null || wanted === 'COMMENT') &&
+        !mayLift &&
+        !mayLiftTeammate &&
+        !commentReasonToPost) {
         return skip(...nothingReason());
     }
     const pctx = await getReviewPostContext(ctx, reviewId, accountId);
@@ -747,13 +784,17 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
     }
     const impactHeld = impact != null && !impactAllowsApprove(impact.level, impact.allowed);
     let standing = { state: 'unreadable', reviewId: null };
-    if (!facts.authorIsMe && ((wantsVerdict && !impactHeld) || mayLift)) {
+    // A teammate block still standing LIVE, with Limn's marker and the consent in its live body.
+    let teammateLifts = [];
+    if (!facts.authorIsMe && ((wantsVerdict && !impactHeld) || mayLift || mayLiftTeammate)) {
         try {
             const [login, reviews] = await Promise.all([
                 deps.accountLogin(accountId),
                 deps.liveReviews(pctx.owner, pctx.name, pctx.prNumber),
             ]);
+            readerLogin = login;
             standing = ownStandingReview(reviews, login, limnBlockIds);
+            teammateLifts = teammateCandidates.filter((c) => liveLiftCheck(reviews, c, login) == null);
         }
         catch (err) {
             ctx.log.warn(`auto post review ${reviewId}: could not read the PR's reviews: ${errText(err)}`);
@@ -793,12 +834,18 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
     // Limn's own automatic request for changes still stands, this run has no blocker and none behind
     // the block is left unjudged: lift it — superseded by the APPROVE this run sends, else dismissed.
     const liftId = noBlocker && !blockersRemain && standing.state === 'LIMN_AUTO_CHANGES_REQUESTED' ? standing.reviewId : null;
-    if (picked.toPost.length === 0 && (verdict?.submitted ?? 'COMMENT') === 'COMMENT' && liftId == null && !reasonOnly) {
+    if (picked.toPost.length === 0 &&
+        (verdict?.submitted ?? 'COMMENT') === 'COMMENT' &&
+        liftId == null &&
+        !reasonOnly &&
+        teammateLifts.length === 0) {
         return skip(...nothingReason());
     }
     const event = verdict?.submitted ?? 'COMMENT';
-    // Nothing but the lift to do: no review is sent at all.
-    const sendsReview = picked.toPost.length > 0 || event !== 'COMMENT' || reasonOnly;
+    // Nothing but the lift of Limn's own block to do: no review is sent at all. Lifting a TEAMMATE'S
+    // block always sends the reader's own review (APPROVE when the gate allows it, else COMMENT): it
+    // carries the judgements (`j=`) the teammate's Limn reads.
+    const sendsReview = picked.toPost.length > 0 || event !== 'COMMENT' || reasonOnly || teammateLifts.length > 0;
     const record = {
         status: 'posting',
         at: nowIso(),
@@ -834,6 +881,8 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
         first = null;
     }
     const pairFirst = first;
+    // The earlier Limn findings on GitHub this review judged, for the marker's `j=` (DB only, never throws).
+    const judged = await loadJudgedForPost(ctx, accountId, prId, pairFirst != null ? [pairFirst, review] : [review]);
     // 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;
@@ -861,6 +910,8 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
                     return { by: aiRunProviderName(r), text: autoReviewBodyLead(r.summary, n, aiRunProviderName(r)) };
                 }), withReasonLine(reason, footer));
     };
+    // The poster's consent rides only a post whose comments hold every blocker behind it.
+    const liftConsent = ws.settings.teamLiftConsent && blockersAllInPost(allFindings, picked.toPost);
     const submit = (ev) => ctx.review.postReview({
         owner: pctx.owner,
         name: pctx.name,
@@ -879,8 +930,10 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
                     model: r.model || null,
                     effort: r.effort ?? null,
                 })),
+                judged,
+                liftConsent,
             }
-            : limnMetaForReview(review),
+            : { ...limnMetaForReview(review), judged, liftConsent },
         // 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), tagOf(f))),
@@ -969,6 +1022,43 @@ async function autoPostReview(ctx, { accountId, prId, reviewId, pairFirstReviewI
             }
         }
     }
+    // A TEAMMATE'S BLOCK, after the reader's review landed at the PR's current head: claim it on the
+    // teammate's row (compare-and-set, once ever), dismiss, record what GitHub said. Never retried.
+    if (teammateLifts.length > 0 && landed && !reviewFailed) {
+        const lifted = [];
+        for (const c of teammateLifts) {
+            const message = teammateLiftMessage(readerLogin ?? 'you', c.points, pctx.reviewHeadSha);
+            const base = { byReviewId: reviewId, headSha: pctx.reviewHeadSha, points: c.points, message };
+            let claimed = false;
+            try {
+                claimed = await claimTeammateLift(ctx, accountId, c.teammateReviewId, base);
+            }
+            catch (err) {
+                ctx.log.warn(`auto post review ${reviewId}: could not claim the teammate lift: ${errText(err)}`);
+            }
+            // Another run tried this block already: never twice.
+            if (!claimed)
+                continue;
+            let res;
+            try {
+                res = deps.dismissReview
+                    ? await deps.dismissReview(accountId, pctx.owner, pctx.name, pctx.prNumber, c.githubReviewId, message)
+                    : { ok: false, message: 'Dismissing is not available.' };
+            }
+            catch (err) {
+                res = { ok: false, message: errText(err) };
+            }
+            const error = res.ok ? null : res.message.slice(0, 300);
+            const status = res.ok ? 'dismissed' : 'failed';
+            await settleTeammateLift(ctx, accountId, c.teammateReviewId, { ...base, status, at: nowIso(), error }).catch((err) => ctx.log.warn(`auto post review ${reviewId}: could not record the teammate lift: ${errText(err)}`));
+            if (res.ok) {
+                await stampReviewDismissed(ctx, prId, c.githubReviewId).catch((err) => ctx.log.warn(`auto post review ${reviewId}: could not stamp the dismissal: ${errText(err)}`));
+            }
+            lifted.push({ teammateReviewId: c.teammateReviewId, login: c.login, status, error });
+        }
+        if (lifted.length > 0)
+            record.liftedTeammateBlocks = lifted;
+    }
     // A run whose only write was the lift: posted when it took, failed (GitHub's words) when not.
     const liftOnly = !sendsReview;
     const final = {

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

@@ -1,5 +1,5 @@
 import { and, eq } from 'drizzle-orm';
-import { AUTO_FIX_DEFAULT_AUTO_PUSH, AUTO_FIX_DEFAULT_INCLUDE, AUTO_POST_DEFAULT_APPROVE_IMPACT, AUTO_POST_DEFAULT_AUTO_RESOLVE, AUTO_POST_DEFAULT_AUTO_VERDICT, AUTO_POST_DEFAULT_KINDS, AUTO_POST_DEFAULT_SCOPE, } from '../../shared/index.js';
+import { AUTO_FIX_DEFAULT_AUTO_PUSH, AUTO_FIX_DEFAULT_INCLUDE, AUTO_POST_DEFAULT_APPROVE_IMPACT, AUTO_POST_DEFAULT_AUTO_RESOLVE, AUTO_POST_DEFAULT_AUTO_VERDICT, AUTO_POST_DEFAULT_KINDS, AUTO_POST_DEFAULT_LIFT_TEAMMATE_BLOCKS, AUTO_POST_DEFAULT_SCOPE, AUTO_POST_DEFAULT_TEAM_LIFT_CONSENT, } from '../../shared/index.js';
 import { dropAutoReviews } from './manager.js';
 import { resolveAutoReviewProviders, storedAutoReviewProviders } from './pair.js';
 import { DEFAULT_VERDICT_RULES, resolveApproveLeftovers, resolvePairStrictness, } from './auto-verdict.js';
@@ -42,6 +42,8 @@ import { onOff, writeSettingEvent } from '../../db/setting-event-write.js';
 // while auto review is off, but switching auto review off and on keeps it. The `autoVerdict` and
 // `autoResolve` switches (both OFF by default) ride the same overrides JSON (no column), and so
 // does `approveImpact` (which blast-radius levels an auto verdict may APPROVE; all by default).
+// So do the two TEAMMATE-LIFT opt-ins, `teamLiftConsent` and `liftTeammateBlocks` (both OFF by
+// default; docs/CLAUDE-REVIEW.md § Lifting a teammate's block).
 //
 // THE AUTO VERDICT'S TWO RULES ride the same route as two more columns (migration 0145), OVERRIDES
 // ONLY (NULL = today's rule): `pair_verdict_strictness` ('relaxed', else strict — wire
@@ -103,6 +105,8 @@ approveLeftovers) {
         autoResolve: typeof stored?.autoResolve === 'boolean' ? stored.autoResolve : AUTO_POST_DEFAULT_AUTO_RESOLVE,
         approveImpact,
         approveLeftovers: resolveApproveLeftovers(approveLeftovers),
+        teamLiftConsent: typeof stored?.teamLiftConsent === 'boolean' ? stored.teamLiftConsent : AUTO_POST_DEFAULT_TEAM_LIFT_CONSENT,
+        liftTeammateBlocks: typeof stored?.liftTeammateBlocks === 'boolean' ? stored.liftTeammateBlocks : AUTO_POST_DEFAULT_LIFT_TEAMMATE_BLOCKS,
     };
 }
 /** The settings in force → what to store: only what differs from the product default (null = none). */
@@ -120,6 +124,12 @@ export function autoPostOverrides(s) {
         out.autoVerdict = s.autoVerdict;
     if (s.autoResolve !== undefined && s.autoResolve !== AUTO_POST_DEFAULT_AUTO_RESOLVE)
         out.autoResolve = s.autoResolve;
+    if (s.teamLiftConsent !== undefined && s.teamLiftConsent !== AUTO_POST_DEFAULT_TEAM_LIFT_CONSENT) {
+        out.teamLiftConsent = s.teamLiftConsent;
+    }
+    if (s.liftTeammateBlocks !== undefined && s.liftTeammateBlocks !== AUTO_POST_DEFAULT_LIFT_TEAMMATE_BLOCKS) {
+        out.liftTeammateBlocks = s.liftTeammateBlocks;
+    }
     if (s.approveImpact !== undefined) {
         const levels = {};
         for (const k of APPROVE_IMPACT_KEYS) {
@@ -184,6 +194,18 @@ export function autoReviewOf(row) {
  * by auto-posting before it touches GitHub. A repo with no membership row (or an unknown PR) reads
  * null, i.e. OFF: this switch WRITES as the reader, so a workspace it cannot find never says yes.
  */
+/**
+ * The BLOCKED side's consent (`teamLiftConsent`) for the PR's workspace: does a post carry `lift=1`?
+ * Never throws — a failed read is no consent (docs/CLAUDE-REVIEW.md § Lifting a teammate's block).
+ */
+export async function readTeamLiftConsent(ctx, accountId, prId) {
+    try {
+        return (await readWorkspaceAutoPostForPr(ctx, accountId, prId))?.settings.teamLiftConsent === true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function readWorkspaceAutoPostForPr(ctx, accountId, prId) {
     const { workspaces: w, workspaceRepos: wr, pullRequests: prs } = ctx.schema;
     const rows = (await ctx.db
@@ -338,6 +360,8 @@ export async function setWorkspaceAutoReview(ctx, accountId, workspaceId, change
         autoResolve: autoPost?.autoResolve ?? postBefore.autoResolve,
         approveImpact: { ...postBefore.approveImpact },
         approveLeftovers: autoPost?.approveLeftovers ?? postBefore.approveLeftovers,
+        teamLiftConsent: autoPost?.teamLiftConsent ?? postBefore.teamLiftConsent,
+        liftTeammateBlocks: autoPost?.liftTeammateBlocks ?? postBefore.liftTeammateBlocks,
     };
     // The leftovers rule is its own column (migration 0145): NULL = the default.
     const leftoversStored = postAfter.approveLeftovers === 'nits_questions' ? null : postAfter.approveLeftovers;
@@ -654,6 +678,8 @@ export function registerAutoReviewSettingsRoutes(app, ctx) {
                             },
                             autoVerdict: { type: 'boolean' },
                             autoResolve: { type: 'boolean' },
+                            teamLiftConsent: { type: 'boolean' },
+                            liftTeammateBlocks: { type: 'boolean' },
                             approveImpact: {
                                 type: 'object',
                                 minProperties: 1,
@@ -691,7 +717,11 @@ export function registerAutoReviewSettingsRoutes(app, ctx) {
             const notBool = (o, k) => k in o && typeof o[k] !== 'boolean';
             if ((post != null &&
                 typeof post === 'object' &&
-                (notBool(post, 'enabled') || notBool(post, 'autoVerdict') || notBool(post, 'autoResolve'))) ||
+                (notBool(post, 'enabled') ||
+                    notBool(post, 'autoVerdict') ||
+                    notBool(post, 'autoResolve') ||
+                    notBool(post, 'teamLiftConsent') ||
+                    notBool(post, 'liftTeammateBlocks'))) ||
                 (kinds != null && typeof kinds === 'object' && Object.values(kinds).some((v) => typeof v !== 'boolean')) ||
                 (impact != null && typeof impact === 'object' && Object.values(impact).some((v) => typeof v !== 'boolean'))) {
                 reply.status(400);

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

@@ -14,7 +14,7 @@ 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 { loadAuthorReviewAnchor, mergeAuthorAnchor } from './teammate-anchor.js';
+import { loadAuthorReviewAnchor, loadStandingBlockAnchors, mergeAuthorAnchor, mergeStandingBlocks } from './teammate-anchor.js';
 import { planThreadReview, reconcileThreads } from './threads.js';
 import { currentThreadAssessmentsForPrs, priorAssessmentsForProvider } from './thread-judgements.js';
 import { activeProviderId } from '../../ai/provider-setting.js';
@@ -876,8 +876,26 @@ async function runPipeline(item, controller, emit) {
             ctx.log.warn(`claude review pr ${item.prId}: author's review not read: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    const prior = authorAnchor && authorAnchor.findings.length > 0 ? mergeAuthorAnchor(authorAnchor, ownPrior, settledIds) : ownPrior;
-    const teammateAnchor = authorAnchor && prior !== ownPrior ? authorAnchor.teammate : null;
+    const anchored = authorAnchor && authorAnchor.findings.length > 0 ? mergeAuthorAnchor(authorAnchor, ownPrior, settledIds) : ownPrior;
+    // A TEAMMATE'S STANDING REQUEST FOR CHANGES (teammate-anchor.ts `loadStandingBlockAnchors`): its
+    // findings join as carried, so this run checks them too. A failure costs those findings only.
+    let blocks = [];
+    if (!fresh) {
+        try {
+            blocks = await loadStandingBlockAnchors(ctx, item.prId, item.accountId, authorAnchor?.reviewId ?? null, item.headSha);
+        }
+        catch (err) {
+            ctx.log.warn(`claude review pr ${item.prId}: teammates' standing reviews not read: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const prior = mergeStandingBlocks(anchored, blocks, settledIds);
+    // The follow-up names a teammate when THEIR review anchors it: the author's, else (no review of the
+    // reader's at all) the newest standing block's.
+    const teammateAnchor = authorAnchor && anchored !== ownPrior
+        ? authorAnchor.teammate
+        : anchored == null && prior != null
+            ? (prior.teammate ?? null)
+            : 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/persist.js

@@ -5,7 +5,7 @@ import { storedList, stripStoredStoryLead } from '../../shared/index.js';
 import { referenceDocCitationsFromStored, reviewDocReferencesFromStored } from '../../shared/index.js';
 import { automaticRetryTarget, pressRetryTarget } from '../../db/auto-retry-at-head.js';
 import { TEAMMATE_KIND, newestTeammateReviewsForPrs, ownFindingsOnly, ownRunsOnly } from '../../db/teammate-reviews.js';
-import { teamReviewLead } from './team-view.js';
+import { loadTeamStandingsForPrs, teamReviewLead } from './team-view.js';
 import { ticketEntriesOf } from './ticket.js';
 import { overlayFollowUpItems } from './replies-pass.js';
 import { findFindingThread } from './finding-thread.js';
@@ -85,6 +85,9 @@ export function autoPostWireOf(v) {
             : {}),
         ...(r.verdict != null && typeof r.verdict === 'object' ? { verdict: r.verdict } : {}),
         ...(r.liftedBlock != null && typeof r.liftedBlock === 'object' ? { liftedBlock: r.liftedBlock } : {}),
+        ...(Array.isArray(r.liftedTeammateBlocks) && r.liftedTeammateBlocks.length > 0
+            ? { liftedTeammateBlocks: r.liftedTeammateBlocks }
+            : {}),
         ...(typeof r.viaPairReviewId === 'number' ? { viaPairReviewId: r.viaPairReviewId } : {}),
         ...(typeof r.reasonPosted === 'string' && r.reasonPosted !== '' ? { reasonPosted: true } : {}),
         ...(r.reasonOnly === true ? { reasonOnly: true } : {}),
@@ -903,7 +906,24 @@ fixRunning) {
     await foldStateSummaries(ctx, out, latestByPr, repliesAfter);
     if (fixRunning)
         await foldFixStates(ctx, out, latestByPr, accountId, fixRunning);
-    await foldTeammateLeads(ctx, out, latestByPr, prIds, accountId);
+    // The reader's latest run that REVIEWED, per PR (succeeded, not a skip; a pair's verdict is the
+    // pair's when it is the latest run) — the standings' "you reviewed last".
+    const ownLatest = new Map();
+    const stateOf = new Map(out.map((st) => [st.prId, st]));
+    for (const r of rows) {
+        if (r.kind != null || ownLatest.has(r.prId) || r.status !== 'succeeded' || r.reviewMode === 'skip')
+            continue;
+        const latest = latestByPr.get(r.prId);
+        const st = stateOf.get(r.prId);
+        const isLatest = latest != null && (latest.reviewId === r.reviewId || (latest.pairId != null && latest.pairId === r.pairId));
+        ownLatest.set(r.prId, {
+            reviewId: isLatest ? latest.reviewId : r.reviewId,
+            verdict: isLatest && st != null ? st.verdict : r.verdict,
+            at: (r.finishedAt ?? r.createdAt).getTime(),
+            headSha: r.headSha,
+        });
+    }
+    await foldTeammateLeads(ctx, out, latestByPr, prIds, accountId, ownLatest);
     return out;
 }
 /**
@@ -913,7 +933,21 @@ fixRunning) {
  * PR with no run of the reader's but a teammate review is appended, so its column is not blank.
  * Mutates `states` in place. DB-only.
  */
-async function foldTeammateLeads(ctx, states, latestByPr, prIds, accountId) {
+async function foldTeammateLeads(ctx, states, latestByPr, prIds, accountId, ownLatest = new Map()) {
+    // STANDING VERDICTS (team-view.ts `teamStandings`): the strictest verdict still in force on GitHub.
+    // A failed read costs the field only.
+    let standings = new Map();
+    try {
+        standings = await loadTeamStandingsForPrs(ctx.db, accountId, prIds, ownLatest);
+    }
+    catch (err) {
+        ctx.log.warn(`review standings: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    for (const st of states) {
+        const got = standings.get(st.prId);
+        if (got != null)
+            st.standing = got;
+    }
     const newest = await newestTeammateReviewsForPrs(ctx.db, accountId, prIds);
     if (newest.size === 0)
         return;
@@ -930,6 +964,7 @@ async function foldTeammateLeads(ctx, states, latestByPr, prIds, accountId) {
                 status: state.status,
                 reviewMode: row.reviewMode,
                 at: (row.finishedAt ?? row.createdAt).getTime(),
+                lastReviewedAt: ownLatest.get(prId)?.at ?? null,
             }
             : null;
         if (teamReviewLead(own, mate.postedAt.getTime()) !== 'teammate')
@@ -960,6 +995,7 @@ async function foldTeammateLeads(ctx, states, latestByPr, prIds, accountId) {
             headMoved: false,
             currentHeadSha: mate.prHeadSha,
             teammateLead,
+            ...(standings.get(prId) != null ? { standing: standings.get(prId) } : {}),
         });
     }
 }