limn-review 0.1.180 → 0.1.182

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/0165_withdraw_approval_on_push.sql

@@ -0,0 +1,6 @@
+-- WITHDRAWING LIMN'S OWN APPROVAL ON A PUSH (docs/CLAUDE-REVIEW.md § Withdrawing Limn's approval).
+-- ONE column, `workspaces.withdraw_approval_on_push`: when a PR's head moves off the commit Limn's OWN
+-- automatic approval was given on, Limn dismisses that approval. NULL = ON (the default); only a
+-- stored 0 is off. The claim and the outcome ride the approving run's `claude_reviews.auto_post` JSON
+-- (`approvalWithdrawal`), so no other DDL. Additive and nullable: no backfill.
+ALTER TABLE `workspaces` ADD `withdraw_approval_on_push` integer;

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

@@ -1149,6 +1149,20 @@
       "when": 1792224069016,
       "tag": "0163_pr_cross_repository",
       "breakpoints": true
+    },
+    {
+      "idx": 164,
+      "version": "6",
+      "when": 1792224071016,
+      "tag": "0164_teammate_block_lift",
+      "breakpoints": true
+    },
+    {
+      "idx": 165,
+      "version": "6",
+      "when": 1792224073016,
+      "tag": "0165_withdraw_approval_on_push",
+      "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),
@@ -1922,6 +1927,10 @@ export const workspaces = sqliteTable('workspaces', {
     // PR's head so teammates' Limn skips a commit someone is already reviewing with the same
     // provider. NULL/false = OFF, the default. The ONE writer is `setWorkspaceAutoReview`.
     teamClaimsEnabled: integer('team_claims_enabled', { mode: 'boolean' }),
+    // "Withdraw Limn's approval when new commits are pushed" (migration 0165; docs/CLAUDE-REVIEW.md
+    // § Withdrawing Limn's approval). NULL = ON, the default; only a stored false is off. The ONE
+    // writer is `setWorkspaceAutoReview`.
+    withdrawApprovalOnPush: integer('withdraw_approval_on_push', { mode: 'boolean' }),
     // WHO RUNS AUTO REVIEWS (migration 0135): NULL = the default provider (Settings → AI); 'both' =
     // Claude then Codex as one pair (docs/CLAUDE-REVIEW.md § Claude + Codex). The ONE writer is
     // `setWorkspaceAutoReview` (review/claude-review/auto-settings.ts).

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/approval-withdraw.js

@@ -0,0 +1,233 @@
+// WITHDRAWING LIMN'S OWN AUTOMATIC APPROVAL (docs/CLAUDE-REVIEW.md § Withdrawing Limn's approval).
+//
+// An auto-posted APPROVE is Limn's judgement of ONE head. When the head moves, or a later run at a new
+// head finds problems, that approval must not stay in force on GitHub. Two paths dismiss it:
+//
+//   1. THE RUN PATH (auto-post.ts, ALWAYS ON): a later auto run — or a "Review and post" run — at a NEW
+//      head that does not approve dismisses Limn's standing approval FIRST, then posts its review.
+//   2. THE PUSH PATH (`maybeWithdrawApprovalOnPush`, called fire-and-forget by sync/upsert.ts when it
+//      sees a PR's head move): only in a workspace with auto review AND auto-posting on and the
+//      per-workspace switch `withdraw_approval_on_push` on (ON by default, migration 0165), never on
+//      the reader's own PR.
+//
+// ⚠ RECOGNITION IS BY STORED ID ONLY: the approval is Limn's when an earlier run's `auto_post` record
+// holds its GitHub review id with `verdict.submitted === 'APPROVE'` (the twin of
+// `loadLimnAutoBlockIds`). Never by marker or body: a manual Post, or an approval by hand, carries the
+// same marker (or none) and is the reader's own judgement — never touched.
+// ⚠ LIVE: it is dismissed only while it is still the reader's standing review on GitHub.
+// ⚠ THE CLAIM: `approvalWithdrawal` on the APPROVING run's `auto_post` JSON, compare-and-set from
+// absent BEFORE the GitHub write (a `json_set` guarded by `json_extract … IS NULL`). Whichever path
+// claims first dismisses; the other does nothing. A failure is recorded in GitHub's words and NEVER
+// retried (the record is never cleared).
+import { and, asc, eq, lt, sql } from 'drizzle-orm';
+import { ownRunsOnly } from '../../db/teammate-reviews.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const s = (ctx) => ctx.schema;
+/* eslint-enable @typescript-eslint/no-explicit-any */
+const nowIso = () => new Date().toISOString();
+const errText = (err) => (err instanceof Error ? err.message : String(err)).slice(0, 300);
+const shortSha = (sha) => sha.slice(0, 7);
+/**
+ * Limn's own automatic APPROVE reviews on this PR (account-scoped), by GitHub review id: every own
+ * run (before `beforeReviewId`, when given) whose auto-post LANDED a review SENT as APPROVE. A pair's
+ * one review is recorded on both halves; the claim row is the half without `viaPairReviewId`.
+ */
+export async function loadLimnAutoApprovals(ctx, accountId, prId, beforeReviewId) {
+    const cr = s(ctx).claudeReviews;
+    const rows = (await ctx.db
+        .select({ id: cr.id, headSha: cr.headSha, autoPost: cr.autoPost })
+        .from(cr)
+        .where(and(eq(cr.prId, prId), eq(cr.accountId, accountId), ownRunsOnly(cr.kind), ...(beforeReviewId != null ? [lt(cr.id, beforeReviewId)] : [])))
+        .orderBy(asc(cr.id))
+        .execute());
+    const out = new Map();
+    for (const r of rows) {
+        const a = r.autoPost;
+        if (a?.githubReviewId == null || a.verdict?.submitted !== 'APPROVE')
+            continue;
+        const id = String(a.githubReviewId);
+        const via = a.viaPairReviewId != null;
+        const had = out.get(id);
+        if (had != null && !(had.via && !via))
+            continue;
+        out.set(id, { runId: r.id, githubReviewId: id, headSha: r.headSha, withdrawal: a.approvalWithdrawal ?? null, via });
+    }
+    return new Map([...out].map(([k, { via: _via, ...v }]) => [k, v]));
+}
+/** The dismissal message for a later run that found problems: counts by severity, then the head. */
+export function withdrawMessageForRun(counts, headSha) {
+    const parts = [];
+    if (counts.blockers > 0)
+        parts.push(counts.blockers === 1 ? '1 blocker' : `${counts.blockers} blockers`);
+    if (counts.warnings > 0)
+        parts.push(counts.warnings === 1 ? '1 warning' : `${counts.warnings} warnings`);
+    return parts.length > 0
+        ? `Limn withdrew its approval: ${parts.join(' and ')} found at ${shortSha(headSha)}.`
+        : `Limn withdrew its approval: not approved at ${shortSha(headSha)}.`;
+}
+/** The dismissal message for a push. */
+export function withdrawMessageForPush(headSha) {
+    return `Limn withdrew its approval: new commits since it approved (${shortSha(headSha)}).`;
+}
+/**
+ * THE CLAIM: write `approvalWithdrawal` (status 'withdrawing') on the approving run's record, only
+ * while it has none. false = someone (the other path, or an earlier attempt) already claimed it.
+ */
+export async function claimApprovalWithdrawal(ctx, accountId, runId, rec) {
+    const cr = s(ctx).claudeReviews;
+    const value = { ...rec, status: 'withdrawing', at: nowIso(), error: null };
+    const rows = (await ctx.db
+        .update(cr)
+        .set({ autoPost: sql `json_set(${cr.autoPost}, '$.approvalWithdrawal', json(${JSON.stringify(value)}))` })
+        .where(and(eq(cr.id, runId), eq(cr.accountId, accountId), sql `${cr.autoPost} is not null`, sql `json_extract(${cr.autoPost}, '$.approvalWithdrawal') is null`))
+        .returning({ id: cr.id })
+        .execute());
+    return rows.length > 0;
+}
+/** Settle a claimed withdrawal: 'withdrawn', or 'failed' with GitHub's words. */
+export async function settleApprovalWithdrawal(ctx, accountId, runId, rec) {
+    const cr = s(ctx).claudeReviews;
+    await ctx.db
+        .update(cr)
+        .set({ autoPost: sql `json_set(${cr.autoPost}, '$.approvalWithdrawal', json(${JSON.stringify(rec)}))` })
+        .where(and(eq(cr.id, runId), eq(cr.accountId, accountId), sql `${cr.autoPost} is not null`))
+        .execute();
+}
+/** Stamp the local review row dismissed (GitHub accepted the dismissal; a sync reconciles anyway). */
+export async function stampApprovalDismissed(ctx, prId, githubReviewId) {
+    const rv = s(ctx).reviews;
+    await ctx.db
+        .update(rv)
+        .set({ state: 'dismissed' })
+        .where(and(eq(rv.prId, prId), eq(rv.databaseId, githubReviewId)))
+        .execute();
+}
+/**
+ * Claim, dismiss, settle — ONE attempt, never retried. Returns null when the claim was lost (another
+ * path has it), else what GitHub said. Never throws.
+ */
+export async function withdrawApproval(ctx, a, dismiss) {
+    const base = {
+        why: a.why,
+        headSha: a.headSha,
+        message: a.message,
+        ...(a.byReviewId != null ? { byReviewId: a.byReviewId } : {}),
+    };
+    let claimed = false;
+    try {
+        claimed = await claimApprovalWithdrawal(ctx, a.accountId, a.approval.runId, base);
+    }
+    catch (err) {
+        ctx.log.warn(`withdraw approval ${a.approval.githubReviewId}: could not claim: ${errText(err)}`);
+    }
+    if (!claimed)
+        return null;
+    let res;
+    try {
+        res = await dismiss(a.approval.githubReviewId, a.message);
+    }
+    catch (err) {
+        res = { ok: false, message: errText(err) };
+    }
+    const rec = {
+        ...base,
+        status: res.ok ? 'withdrawn' : 'failed',
+        at: nowIso(),
+        error: res.ok ? null : res.message.slice(0, 300),
+    };
+    await settleApprovalWithdrawal(ctx, a.accountId, a.approval.runId, rec).catch((err) => ctx.log.warn(`withdraw approval ${a.approval.githubReviewId}: could not record the result: ${errText(err)}`));
+    if (res.ok) {
+        await stampApprovalDismissed(ctx, a.prId, a.approval.githubReviewId).catch((err) => ctx.log.warn(`withdraw approval ${a.approval.githubReviewId}: could not stamp the dismissal: ${errText(err)}`));
+    }
+    return rec;
+}
+export const defaultPushWithdrawDeps = {
+    async accountLogin(accountId) {
+        const { defaultAutoPostDeps } = await import('./auto-post.js');
+        return defaultAutoPostDeps.accountLogin(accountId);
+    },
+    async accountUserId(accountId) {
+        const { getAccountUserId } = await import('../../auth/account.js');
+        return getAccountUserId(accountId);
+    },
+    async liveReviews(owner, name, prNumber) {
+        const { defaultAutoPostDeps } = await import('./auto-post.js');
+        return defaultAutoPostDeps.liveReviews(owner, name, prNumber);
+    },
+    async dismissReview(accountId, owner, name, prNumber, reviewId, message) {
+        const { defaultAutoPostDeps } = await import('./auto-post.js');
+        return defaultAutoPostDeps.dismissReview(accountId, owner, name, prNumber, reviewId, message);
+    },
+    async settle({ accountId, prId }) {
+        const { settlePrAfterWrite } = await import('../../sync/resync-after-write.js');
+        const quiet = { info: () => { }, warn: () => { }, error: () => { } };
+        return settlePrAfterWrite({ accountId, prId, log: quiet });
+    },
+};
+/**
+ * A PR's head was seen at `headSha`: dismiss Limn's own automatic approval of an OLDER head, if it
+ * still stands live. DB pre-checks first (the workspace's switches, the reader's own PR, an
+ * unwithdrawn approval of another head), so an ordinary walk costs no GitHub call. Never throws.
+ */
+export async function maybeWithdrawApprovalOnPush(ctx, a, deps = defaultPushWithdrawDeps) {
+    try {
+        return await withdrawOnPush(ctx, a, deps);
+    }
+    catch (err) {
+        ctx.log.warn(`withdraw approval on push, PR ${a.prId}: ${errText(err)}`);
+        return { kind: 'none' };
+    }
+}
+async function withdrawOnPush(ctx, { accountId, prId, headSha }, deps) {
+    const t = s(ctx);
+    const { workspaces: w, workspaceRepos: wr, pullRequests: prs, repos } = t;
+    const rows = (await ctx.db
+        .select({
+        reviewOn: w.autoReviewEnabled,
+        postOn: w.autoPostEnabled,
+        withdrawOn: w.withdrawApprovalOnPush,
+        state: prs.state,
+        authorId: prs.authorId,
+        number: prs.number,
+        owner: repos.owner,
+        name: repos.name,
+    })
+        .from(prs)
+        .innerJoin(repos, and(eq(repos.id, prs.repoId), eq(repos.accountId, accountId)))
+        .innerJoin(wr, and(eq(wr.repoId, prs.repoId), eq(wr.accountId, accountId)))
+        .innerJoin(w, and(eq(w.id, wr.workspaceId), eq(w.accountId, accountId)))
+        .where(and(eq(prs.id, prId), eq(prs.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const pr = rows[0];
+    // Auto review AND auto-posting on (the approval could only exist there), and the switch not off.
+    if (!pr || pr.reviewOn !== true || pr.postOn !== true || pr.withdrawOn === false)
+        return { kind: 'off' };
+    if (pr.state !== 'open')
+        return { kind: 'none' };
+    // The latest unwithdrawn approval of ANOTHER head (only the latest can still stand).
+    const approvals = [...(await loadLimnAutoApprovals(ctx, accountId, prId)).values()]
+        .filter((x) => x.headSha !== headSha && x.withdrawal == null)
+        .sort((x, y) => y.runId - x.runId);
+    const approval = approvals[0];
+    if (approval == null)
+        return { kind: 'none' };
+    // Never on the reader's own PR (GitHub refuses self-approval; nothing of Limn's can stand there).
+    const me = await deps.accountUserId(accountId);
+    if (me != null && pr.authorId === me)
+        return { kind: 'none' };
+    // LIVE: still the reader's standing review on GitHub?
+    const [login, reviews] = await Promise.all([deps.accountLogin(accountId), deps.liveReviews(pr.owner, pr.name, pr.number)]);
+    const { ownStandingReview } = await import('./auto-post.js');
+    const standing = ownStandingReview(reviews, login, new Set(), new Set([approval.githubReviewId]));
+    if (standing.state !== 'LIMN_AUTO_APPROVED' || standing.reviewId !== approval.githubReviewId)
+        return { kind: 'not_standing' };
+    const rec = await withdrawApproval(ctx, { accountId, prId, approval, why: 'push', headSha, message: withdrawMessageForPush(headSha) }, (reviewId, message) => deps.dismissReview(accountId, pr.owner, pr.name, pr.number, reviewId, message));
+    if (rec == null)
+        return { kind: 'claimed_elsewhere' };
+    // SETTLE, THEN CASCADE (the post-write rule): a dismissal changes the PR's review decision.
+    if (rec.status === 'withdrawn')
+        await Promise.resolve(deps.settle({ accountId, prId })).catch(() => undefined);
+    return { kind: 'done', record: rec };
+}
+//# sourceMappingURL=approval-withdraw.js.map