limn-review 0.1.183 → 0.1.184

package/dist/db/erase-account.js

@@ -177,6 +177,8 @@ export async function eraseAccountData(accountId) {
         await tx.delete(schema.teamClaimLines).where(eq(schema.teamClaimLines.accountId, accountId)).execute();
         // The teammate lines the AI Review tab names (migration 0159): GitHub logins. No FK.
         await tx.delete(schema.teamClaimSeen).where(eq(schema.teamClaimSeen.accountId, accountId)).execute();
+        // The skipped lines (migration 0166): heads and providers. No FK.
+        await tx.delete(schema.teamClaimSkipLines).where(eq(schema.teamClaimSkipLines.accountId, accountId)).execute();
         // The worktree ledger (migration 0146): which PR / ticket a checkout on disk was for. No FK. The
         // directories themselves become unledgered orphans the worktree sweep collects by age.
         await tx.delete(schema.worktreeLedger).where(eq(schema.worktreeLedger.accountId, accountId)).execute();
@@ -370,6 +372,8 @@ export function accountScopedTables() {
         { name: 'teamClaimLines', col: schema.teamClaimLines.accountId, table: schema.teamClaimLines },
         // The teammate lines (migration 0159), erased explicitly above.
         { name: 'teamClaimSeen', col: schema.teamClaimSeen.accountId, table: schema.teamClaimSeen },
+        // The skipped lines (migration 0166), erased explicitly above.
+        { name: 'teamClaimSkipLines', col: schema.teamClaimSkipLines.accountId, table: schema.teamClaimSkipLines },
         // The worktree ledger (migration 0146), erased explicitly above.
         { name: 'worktreeLedger', col: schema.worktreeLedger.accountId, table: schema.worktreeLedger },
         { name: 'workspaceSonar', col: schema.workspaceSonar.accountId, table: schema.workspaceSonar },

package/dist/db/migrations/0166_team_claim_skip_lines.sql

@@ -0,0 +1,20 @@
+-- AN AUTO REVIEW THIS LIMN SKIPPED, SAID ON THE PR (docs/CLAUDE-REVIEW.md § Team claims → The skipped
+-- line). When the reader's Limn does not start an auto review it would otherwise run (the AI budget is
+-- used, the workspace's daily limit is reached, the provider is over its usage limit, AI is not signed
+-- in), it posts ONE green `limn/review-<provider>` line on the head. One row per (account, PR, head,
+-- provider, reason), claimed BEFORE the GitHub write: at most once, never retried. Additive.
+CREATE TABLE `team_claim_skip_lines` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`pr_id` integer NOT NULL,
+	`head_sha` text NOT NULL,
+	`provider` text NOT NULL,
+	`reason` text NOT NULL,
+	`state` text NOT NULL,
+	`description` text,
+	`last_error` text,
+	`created_at` integer DEFAULT (unixepoch()) NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `team_claim_skip_lines_key` ON `team_claim_skip_lines` (`account_id`,`pr_id`,`head_sha`,`provider`,`reason`);

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

@@ -1163,6 +1163,13 @@
       "when": 1792224073016,
       "tag": "0165_withdraw_approval_on_push",
       "breakpoints": true
+    },
+    {
+      "idx": 166,
+      "version": "6",
+      "when": 1792224075016,
+      "tag": "0166_team_claim_skip_lines",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/schema.sqlite.js

@@ -3980,6 +3980,28 @@ export const teamClaimSeen = sqliteTable('team_claim_seen', {
 }, (t) => ({
     prHeadProviderUx: uniqueIndex('team_claim_seen_account_pr_head_provider').on(t.accountId, t.prId, t.headSha, t.provider),
 }));
+// 0166. AN AUTO REVIEW THIS LIMN SKIPPED, SAID ON THE PR (docs/CLAUDE-REVIEW.md § Team claims → The
+// skipped line): one row per (account, PR, head, provider, reason) — the claim, written BEFORE the
+// GitHub write, so the line "Cleared by alex: auto review skipped · AI budget used" goes out at most
+// ONCE and a failed write is never retried. `reason` 'budget' | 'daily_cap' | 'usage_limit' |
+// 'not_ready'; `state` 'posting' (claimed) → 'posted' | 'failed' (GitHub refused; `last_error`) |
+// 'not_needed' (another line already sits on the head). No FK on pr_id: BOTH delete paths delete its
+// rows (db/team-claim-lines-delete.ts), the erasure deletes everything.
+export const teamClaimSkipLines = sqliteTable('team_claim_skip_lines', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    accountId: integer('account_id').notNull(),
+    prId: integer('pr_id').notNull(),
+    headSha: text('head_sha').notNull(),
+    provider: text('provider').notNull(),
+    reason: text('reason').notNull(),
+    state: text('state', { enum: ['posting', 'posted', 'failed', 'not_needed'] }).notNull(),
+    description: text('description'),
+    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) => ({
+    keyUx: uniqueIndex('team_claim_skip_lines_key').on(t.accountId, t.prId, t.headSha, t.provider, t.reason),
+}));
 // 0139. THIS DATABASE'S OWN FACTS (key → value) — never an account's, so not account-scoped and not
 // erased with one. `instance_id`: a random id written once (db/instance-id.ts) that names this
 // database file wherever it is moved; the reference-docs janitor's ownership marker.

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

@@ -17,5 +17,8 @@ export async function deleteSettledClaimLinesForPrs(tx, prIds) {
     // The teammate lines the AI Review tab names (migration 0159): nothing on GitHub to release, so
     // every row of these PRs goes.
     await tx.delete(schema.teamClaimSeen).where(inArray(schema.teamClaimSeen.prId, prIds)).execute();
+    // The skipped lines this machine posted (migration 0166): a settled success on GitHub, nothing to
+    // release, so every row of these PRs goes.
+    await tx.delete(schema.teamClaimSkipLines).where(inArray(schema.teamClaimSkipLines.prId, prIds)).execute();
 }
 //# sourceMappingURL=team-claim-lines-delete.js.map

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

@@ -5,7 +5,7 @@
 //
 // THE RULE, in order (the first that fails decides):
 //   0. the workspace holding the PR's repo has auto-posting ON and its `ciFailures` kind on
-//      (default on, inside auto-posting, which is itself OFF until switched on). Off ⇒ nothing is
+//      (default on, inside auto-posting, itself ON by default since 2026-11-04). Off ⇒ nothing is
 //      recorded at all;
 //   1. the run is an AUTO run that SUCCEEDED (a CI check you started yourself is never posted) and
 //      has never been claimed;

package/dist/review/claude-review/approval-withdraw.js

@@ -201,7 +201,7 @@ async function withdrawOnPush(ctx, { accountId, prId, headSha }, deps) {
         .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)
+    if (!pr || pr.reviewOn !== true || pr.postOn === false || pr.withdrawOn === false)
         return { kind: 'off' };
     if (pr.state !== 'open')
         return { kind: 'none' };

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

@@ -3,7 +3,7 @@
 //
 // THE RULE, in order (the first that fails decides):
 //   0. the workspace holding the PR's repo has auto-posting ON (`workspaces.auto_post_enabled`,
-//      migration 0087 / pg 0074 — OFF for every workspace until switched on). Off ⇒ nothing is
+//      migration 0087 — ON by default since 2026-11-04: only a stored false is off). Off ⇒ nothing is
 //      recorded at all;
 //   1. WHICH PRs (`autoPostEligibility`, pure): open (never merged or closed), not a draft, not
 //      bot-authored (the workspace's bot union), and under scope 'mine' the PR is the reader's own,

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

@@ -35,12 +35,14 @@ import { onOff, writeSettingEvent } from '../../db/setting-event-write.js';
 // by the wire shape and the sweeper's roster alike. Bounded 1..500 at the route.
 //
 // AUTO-POSTING rides the same route as two more columns (migration 0087 / pg 0074):
-// `auto_post_enabled` (NULL/false = OFF — for every workspace, existing and new, until someone
-// switches it on: it writes to GitHub AS THE READER) and `auto_post_settings`, OVERRIDES ONLY
+// `auto_post_enabled` (⚠ ON BY DEFAULT since 2026-11-04 — NULL reads ON, only a stored false is
+// off, in every reader and in the writer; it writes to GitHub AS THE READER, but only for AUTO runs,
+// so it does nothing until auto review is switched on) and `auto_post_settings`, OVERRIDES ONLY
 // ({ scope?, kinds? }; NULL = the product defaults), resolved through `resolveAutoPostSettings`.
 // Stored independently of `auto_review_enabled`: it only ever acts on AUTO runs, so it does nothing
-// 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
+// while auto review is off, but switching auto review off and on keeps it. The `autoVerdict` (ON by
+// default since 2026-11-04: absent = on, a stored false = off) and `autoResolve` (OFF by default)
+// switches 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).
@@ -103,7 +105,8 @@ approveLeftovers) {
                 approveImpact[k] = si[k];
     }
     return {
-        enabled: enabled === true,
+        // ON unless explicitly switched off (2026-11-04).
+        enabled: enabled !== false,
         scope: isScope(stored?.scope) ? stored.scope : AUTO_POST_DEFAULT_SCOPE,
         kinds,
         autoVerdict: typeof stored?.autoVerdict === 'boolean' ? stored.autoVerdict : AUTO_POST_DEFAULT_AUTO_VERDICT,
@@ -218,6 +221,7 @@ export async function readWorkspaceAutoPostForPr(ctx, accountId, prId) {
     const rows = (await ctx.db
         .select({
         workspaceId: w.id,
+        autoReviewOn: w.autoReviewEnabled,
         enabled: w.autoPostEnabled,
         stored: w.autoPostSettings,
         ...verdictRuleCols(w),
@@ -234,6 +238,7 @@ export async function readWorkspaceAutoPostForPr(ctx, accountId, prId) {
             workspaceId: r.workspaceId,
             settings: resolveAutoPostSettings(r.enabled, r.stored, r.approveLeftovers),
             pairStrictness: resolvePairStrictness(r.pairStrictness),
+            autoReviewOn: r.autoReviewOn === true,
         }
         : null;
 }
@@ -450,7 +455,7 @@ export async function setWorkspaceAutoReview(ctx, accountId, workspaceId, change
         set.approveLeftovers = leftoversStored;
     }
     if (autoPost !== undefined) {
-        if (postAfter.enabled !== (existing.autoPostEnabled === true))
+        if (postAfter.enabled !== (existing.autoPostEnabled !== false))
             set.autoPostEnabled = postAfter.enabled;
         if (JSON.stringify(postOverrides) !== JSON.stringify(existing.autoPostSettings ?? null)) {
             set.autoPostSettings = postOverrides;
@@ -524,7 +529,7 @@ function settingChanges(set, existing, next) {
         ]);
     }
     if ('autoPostEnabled' in set)
-        out.push(['auto_post', `Auto-posting ${onOff(next.autoPostEnabled === true)}`]);
+        out.push(['auto_post', `Auto-posting ${onOff(next.autoPostEnabled !== false)}`]);
     else if ('autoPostSettings' in set)
         out.push(['auto_post', 'Auto-posting settings changed']);
     return out;

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

@@ -188,9 +188,26 @@ export async function runAutoReviewSweep(ctx, nowMs = Date.now(), press = null)
     // row that would use up its one automatic review. The PRs still qualify on a later tick.
     if (!agenticRunReady(ctx, 'review')) {
         result.stopped = 'ai_not_ready';
+        // THE SKIPPED LINE (team-claim-skip.ts): the tick says so on each due head, once. A press does not
+        // (the SPA shows its own line, and the next tick posts).
+        if (!press) {
+            sweeping = true;
+            try {
+                await noteSkippedWhileHeld(ctx, nowMs, candidatesOf, 'not_ready');
+            }
+            catch (err) {
+                ctx.log.warn(`auto review skipped lines: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            finally {
+                sweeping = false;
+            }
+        }
         return result;
     }
     sweeping = true;
+    // Due heads this pass did not start, and why (the daily cap; the spend budget) — said on the PR once
+    // each, at the end of the pass (team-claim-skip.ts).
+    const skipped = [];
     try {
         const dayStartMs = utcDayStartMs(nowMs);
         const liveHeads = new Set();
@@ -224,8 +241,11 @@ export async function runAutoReviewSweep(ctx, nowMs = Date.now(), press = null)
                 result.overBudget = true;
         }
         for (const ws of roster) {
-            if (budgetOk.get(ws.accountId) === false)
+            if (budgetOk.get(ws.accountId) === false) {
+                // Over the spend budget: nothing is queued; the due heads are said on the PR (read-only pass).
+                skipped.push(...(await dueHeadsHeld(ctx, nowMs, candidatesOf, ws, 'budget')));
                 continue;
+            }
             if (autoLaneRoom() === 0) {
                 result.stopped = 'lane_full';
                 break;
@@ -273,7 +293,9 @@ export async function runAutoReviewSweep(ctx, nowMs = Date.now(), press = null)
                     continue;
                 if (budget <= 0) {
                     result.capped = true;
-                    break;
+                    // Said on the PR (team-claim-skip.ts); the rest of the list is noted the same way.
+                    skipped.push({ accountId: ws.accountId, prId, headSha: null, reason: 'daily_cap' });
+                    continue;
                 }
                 const k = `${ws.accountId}:${prId}`;
                 livePrs.add(k);
@@ -523,6 +545,9 @@ export async function runAutoReviewSweep(ctx, nowMs = Date.now(), press = null)
                     continue;
                 if (budget <= 0) {
                     result.capped = true;
+                    // A MOVED HEAD is a head never reviewed: said on the PR. A same-head comment burst is not.
+                    if (commentsAtMs == null)
+                        skipped.push({ accountId: ws.accountId, prId, headSha, reason: 'daily_cap' });
                     continue;
                 }
                 const r = enqueueAutoReview(ctx, ws.accountId, prId, ws.workspaceId, commentsAtMs ?? null, { pressed });
@@ -563,6 +588,7 @@ export async function runAutoReviewSweep(ctx, nowMs = Date.now(), press = null)
         }
         if (result.queued > 0)
             ctx.log.info(`auto claude review: queued ${result.queued} PR(s)`);
+        await postSkippedHeads(ctx, skipped);
         return result;
     }
     catch (err) {
@@ -573,6 +599,96 @@ export async function runAutoReviewSweep(ctx, nowMs = Date.now(), press = null)
         sweeping = false;
     }
 }
+/** At most this many PRs are said on GitHub per tick (each once per head and reason, recorded). */
+export const AUTO_SKIP_LINES_PER_TICK = 25;
+/**
+ * The heads this workspace's tick WOULD have started — first reviews, and moved heads whose start rule
+ * says go — without starting anything or touching a clock. Read-only: the spend budget and AI
+ * readiness hold the whole workspace, so these are said on the PR instead. Not a held PR (a teammate's
+ * claim, already visible), not one waiting in the lane, not a retry or a same-head comment burst.
+ */
+async function dueHeadsHeld(ctx, nowMs, candidatesOf, ws, reason) {
+    const waiting = autoPendingPrIds();
+    const res = await candidatesOf(ws.accountId, ws.workspaceId, {
+        openedSinceMs: ws.enabledAtMs,
+        dayStartMs: utcDayStartMs(nowMs),
+        limit: ws.dailyCap + waiting.size,
+    });
+    if (!res)
+        return [];
+    const retrying = new Set((res.retry ?? []).map((r) => r.prId));
+    const held = async (prId, headSha) => {
+        const h = teamClaimHeldHead(ws.accountId, prId, nowMs);
+        if (h == null)
+            return false;
+        return (headSha ?? (await syncedHeadOf(ctx, ws.accountId, prId))) === h;
+    };
+    const out = [];
+    for (const prId of res.prIds) {
+        if (waiting.has(prId) || (await held(prId, null)))
+            continue;
+        out.push({ accountId: ws.accountId, prId, headSha: null, reason });
+    }
+    for (const cand of res.reReview ?? []) {
+        const { prId, headSha, commentsAtMs, lastRunAtMs } = cand;
+        if (commentsAtMs != null || waiting.has(prId) || retrying.has(prId))
+            continue;
+        const seen = headSeen.get(`${ws.accountId}:${prId}`);
+        const due = autoReviewDue({
+            nowMs,
+            settle: {
+                quietSinceMs: seen && seen.key === `${headSha}|` ? seen.firstSeenMs : nowMs,
+                burstStartMs: seen ? seen.burstStartMs : nowMs,
+                reason: 'head',
+            },
+            lastRunAtMs: lastRunAtMs ?? null,
+        });
+        if (!due.due || (await held(prId, headSha)))
+            continue;
+        out.push({ accountId: ws.accountId, prId, headSha, reason });
+    }
+    return out;
+}
+/** AI not ready: every switched-on workspace's due heads, said on the PR. */
+async function noteSkippedWhileHeld(ctx, nowMs, candidatesOf, reason) {
+    const heads = [];
+    for (const ws of await listAutoReviewWorkspaces(ctx)) {
+        heads.push(...(await dueHeadsHeld(ctx, nowMs, candidatesOf, ws, reason)));
+        if (heads.length >= AUTO_SKIP_LINES_PER_TICK)
+            break;
+    }
+    await postSkippedHeads(ctx, heads);
+}
+/** Post the skipped lines (each provider's context, once per head and reason). Never throws. */
+async function postSkippedHeads(ctx, heads) {
+    if (heads.length === 0)
+        return;
+    try {
+        const m = await import('./team-claim-skip.js');
+        let notReady = null;
+        for (const h of heads.slice(0, AUTO_SKIP_LINES_PER_TICK)) {
+            let skips;
+            if (h.reason === 'not_ready') {
+                if (!notReady) {
+                    const [{ activeProviderId }, { activeRuntimeStatus }] = await Promise.all([
+                        import('../../ai/provider-setting.js'),
+                        import('../../ai/active-runtime.js'),
+                    ]);
+                    notReady = { provider: activeProviderId(), notSetUp: activeRuntimeStatus().runtime !== 'ready' };
+                }
+                skips = [{ provider: notReady.provider, reason: 'not_ready', notSetUp: notReady.notSetUp }];
+            }
+            else {
+                const providers = await m.autoProvidersForPr(ctx, h.accountId, h.prId);
+                skips = providers.map((provider) => ({ provider, reason: h.reason }));
+            }
+            await m.postAutoSkipLines(ctx, { accountId: h.accountId, prId: h.prId, headSha: h.headSha }, skips);
+        }
+    }
+    catch (err) {
+        ctx.log.warn(`auto review skipped lines: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 function isSettleWait(r) {
     return r === 'comments' || r === 'commits' || r === 'ci';
 }

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

@@ -5,7 +5,8 @@ import { getTicketSource } from '../../tracker/ticket-source.js';
 import { agenticRunReady } from './ai-ready.js';
 import { automaticRunAllowed } from '../budget-gate.js';
 import { detectWake, FORCE_RELEASE_MS, runsToInterrupt, WATCHDOG_TICK_MS } from './run-watchdog.js';
-import { automaticRunProviders, isLockedOut, LOCKOUT_MAX_MS, noteProviderFailure, restoreUsageLockouts } from '../../ai/usage-lockout.js';
+import { automaticRunProviders, isLockedOut, LOCKOUT_MAX_MS, noteProviderFailure, restoreUsageLockouts, usageLockout, } from '../../ai/usage-lockout.js';
+import { postAutoSkipLinesLater } from './team-claim-skip.js';
 import { decideReviewMode } from './routing.js';
 import { offeredSpecialists } from './specialists.js';
 import { buildUserPrompt, peerRef, pickReviewNonce, skipSummary, sonarHasContent, systemPromptForMode, untrustedTexts, } from './prompts.js';
@@ -339,11 +340,25 @@ async function startAutoItem(a) {
     let launched = false;
     // A claim posted before the row could be written is released ("free to claim") below.
     let teamClaim = null;
+    // THE SKIPPED LINE (team-claim-skip.ts): an item dropped here for the budget, a usage limit or AI not
+    // ready says so on the PR head, once — only a first review or a moved head (a retry's or a same-head
+    // comment burst's head already carries this Limn's own line). Posted in the background.
+    const sayOnPr = a.retryOfReviewId == null && a.commentsAtMs == null;
+    const sayNotReady = () => {
+        if (!sayOnPr)
+            return;
+        postAutoSkipLinesLater(ctx, { accountId, prId }, async () => {
+            const { activeRuntimeStatus } = await import('../../ai/active-runtime.js');
+            return [{ provider: activeProviderId(), reason: 'not_ready', notSetUp: activeRuntimeStatus().runtime !== 'ready' }];
+        });
+    };
     try {
         // AI went away since the sweep (runtime removed, signed out): drop the item BEFORE its row
         // exists, or the PR's one automatic review is spent on a failure (ai-ready.ts).
-        if (!agenticRunReady(ctx, 'review'))
+        if (!agenticRunReady(ctx, 'review')) {
+            sayNotReady();
             return;
+        }
         // An AUTOMATIC run goes to the DEFAULT provider (Settings → AI), read now — unless the workspace
         // asks for Claude + Codex (`auto_review_providers = 'both'`): then a PAIR when both can review,
         // else the one that can. ⚠ A provider LOCKED OUT by its usage limit (ai/usage-lockout.ts) never
@@ -368,6 +383,18 @@ async function startAutoItem(a) {
             providers = pick(true);
         if (providers.length === 0) {
             ctx.log.info(`auto claude review pr ${prId}: skipped — no provider outside its usage limit`);
+            // Each provider that would have run: over its usage limit (with its end), else not signed in.
+            if (sayOnPr) {
+                const wanted = wantsPair ? [...PAIR_ORDER] : [activeProviderId()];
+                const skips = wanted.flatMap((p) => {
+                    if (isLockedOut(p, nowMs))
+                        return [{ provider: p, reason: 'usage_limit', untilMs: usageLockout(p, nowMs)?.untilMs ?? null }];
+                    // A pair half that is simply not signed in is not a skip of a review it would run.
+                    return wantsPair ? [] : [{ provider: p, reason: 'not_ready' }];
+                });
+                if (skips.length > 0)
+                    postAutoSkipLinesLater(ctx, { accountId, prId }, skips);
+            }
             return;
         }
         let provider = providers[0];
@@ -377,8 +404,11 @@ async function startAutoItem(a) {
         // THE CLAUDE SPEND BUDGET (ai/budget.ts): over it, drop the item before its row exists — the
         // sweeper re-derives it once the budget is under its limit again.
         // A READER'S PRESS is not asked again: they chose it (the SPA's over-budget confirm ran).
-        if (!a.pressed && !(await automaticRunAllowed(ctx, accountId, 'auto review', provider)))
+        if (!a.pressed && !(await automaticRunAllowed(ctx, accountId, 'auto review', provider))) {
+            if (sayOnPr)
+                postAutoSkipLinesLater(ctx, { accountId, prId }, providers.map((p) => ({ provider: p, reason: 'budget' })));
             return;
+        }
         const prCtx = await getReviewPrContext(ctx, prId, accountId);
         if (!prCtx?.headSha)
             return;

package/dist/review/claude-review/team-claim-skip.js

@@ -0,0 +1,209 @@
+import { and, eq, isNull } from 'drizzle-orm';
+import { claimErrorKind, defaultTeamClaimGithub, isFreeTeamClaimLine, newestLine, skippedLine, teamClaimContext, teamClaimsOnForPr, } from './team-claim.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const s = (ctx) => ctx.schema;
+const errText = (err) => (err instanceof Error ? err.message : String(err));
+// The GitHub adapter (a test pins its own). Read at call time, never at import.
+let githubOverride = null;
+const gh = () => githubOverride ?? defaultTeamClaimGithub;
+/** Test hook. */
+export function _setSkipLineGithubForTest(g) {
+    githubOverride = g;
+}
+// Posts started without awaiting (the manager's drop paths): a test awaits them.
+const inFlight = new Set();
+/** Test hook: wait for every skipped line being written. */
+export async function _skipLinesSettledForTest() {
+    while (inFlight.size > 0)
+        await Promise.allSettled([...inFlight]);
+}
+/** Post in the background (the manager must release its seat at once). Never throws. */
+export function postAutoSkipLinesLater(ctx, a, skips) {
+    const p = (async () => postAutoSkipLines(ctx, a, typeof skips === 'function' ? await skips() : skips))()
+        .catch((err) => ctx.log.warn(`skipped line pr ${a.prId}: ${errText(err)}`))
+        .finally(() => inFlight.delete(p));
+    inFlight.add(p);
+}
+async function prFacts(ctx, accountId, prId) {
+    const { pullRequests: prs, repos } = s(ctx);
+    const rows = (await ctx.db
+        .select({
+        owner: repos.owner,
+        name: repos.name,
+        number: prs.number,
+        headSha: prs.headSha,
+        state: prs.state,
+        draft: prs.isDraft,
+        authorId: prs.authorId,
+    })
+        .from(prs)
+        .innerJoin(repos, and(eq(repos.id, prs.repoId), eq(repos.accountId, accountId)))
+        .where(and(eq(prs.id, prId), eq(prs.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const r = rows[0];
+    if (!r)
+        return null;
+    return {
+        owner: r.owner,
+        name: r.name,
+        number: r.number,
+        headSha: r.headSha,
+        open: (r.state ?? '').toLowerCase() === 'open',
+        draft: r.draft === true,
+        authorId: r.authorId,
+    };
+}
+/** Any review row (not a replies pass) of this PR at this head: this account's own line may be there. */
+async function reviewRowAtHead(ctx, accountId, prId, headSha) {
+    const cr = s(ctx).claudeReviews;
+    const rows = (await ctx.db
+        .select({ id: cr.id })
+        .from(cr)
+        .where(and(eq(cr.prId, prId), eq(cr.accountId, accountId), eq(cr.headSha, headSha), isNull(cr.kind)))
+        .limit(1)
+        .execute());
+    return rows.length > 0;
+}
+async function isBotAuthor(authorId) {
+    if (authorId == null)
+        return false;
+    try {
+        const { globalAutomationUserIds } = await import('../../db/automation-ids.js');
+        return (await globalAutomationUserIds()).has(authorId);
+    }
+    catch {
+        return true; // unknown ⇒ the safe side: post nothing
+    }
+}
+/**
+ * Post the skipped lines for ONE PR head (each provider, each reason, at most once). `headSha`: the
+ * head the decision was about; absent ⇒ the synced head. Never throws.
+ */
+export async function postAutoSkipLines(ctx, a, skips, nowMs = Date.now()) {
+    const t = s(ctx).teamClaimSkipLines;
+    if (!t || skips.length === 0)
+        return [];
+    const { accountId, prId } = a;
+    const all = (o) => skips.map(() => o);
+    try {
+        if (!(await teamClaimsOnForPr(ctx, accountId, prId)))
+            return all('off');
+        const pr = await prFacts(ctx, accountId, prId);
+        const headSha = a.headSha ?? pr?.headSha ?? null;
+        if (!pr || !headSha || pr.headSha !== headSha || !pr.open || pr.draft)
+            return all('not_eligible');
+        if (await reviewRowAtHead(ctx, accountId, prId, headSha))
+            return all('not_eligible');
+        if (await isBotAuthor(pr.authorId))
+            return all('not_eligible');
+        const out = [];
+        let login;
+        for (const sk of skips) {
+            const key = and(eq(t.accountId, accountId), eq(t.prId, prId), eq(t.headSha, headSha), eq(t.provider, sk.provider), eq(t.reason, sk.reason));
+            const seen = (await ctx.db.select({ id: t.id }).from(t).where(key).limit(1).execute());
+            if (seen.length > 0) {
+                out.push('already');
+                continue;
+            }
+            if (login === undefined)
+                login = await gh().login(accountId).catch(() => null);
+            if (!login) {
+                out.push('no_login');
+                continue;
+            }
+            out.push(await postOne(ctx, { accountId, prId, headSha, pr, login, skip: sk, nowMs }));
+        }
+        return out;
+    }
+    catch (err) {
+        ctx.log.warn(`skipped line pr ${prId}: ${errText(err)}`);
+        return all('failed');
+    }
+}
+async function postOne(ctx, a) {
+    const t = s(ctx).teamClaimSkipLines;
+    const { accountId, prId, headSha, pr, login, skip } = a;
+    const context = teamClaimContext(skip.provider);
+    const description = skippedLine(login, skip.reason, skip.provider, {
+        untilMs: skip.untilMs ?? null,
+        notSetUp: skip.notSetUp === true,
+        nowMs: a.nowMs,
+    });
+    // READ FIRST (a read is not a write): a line that means something stays the newest one.
+    let needed = true;
+    let readError = null;
+    try {
+        const newest = newestLine(await gh().listLines(accountId, pr.owner, pr.name, headSha, context));
+        needed = newest == null || (newest.state === 'success' && isFreeTeamClaimLine(newest));
+    }
+    catch (err) {
+        claimErrorKind(err, accountId); // tells the rate budget about a limit
+        readError = errText(err);
+    }
+    // THE CLAIM, before any GitHub write: the unique key makes it once per (PR, head, provider, reason).
+    const claimed = (await ctx.db
+        .insert(t)
+        .values({
+        accountId,
+        prId,
+        headSha,
+        provider: skip.provider,
+        reason: skip.reason,
+        state: readError != null ? 'failed' : needed ? 'posting' : 'not_needed',
+        description,
+        lastError: readError,
+    })
+        .onConflictDoNothing()
+        .returning({ id: t.id })
+        .execute());
+    const id = claimed[0]?.id;
+    if (id == null)
+        return 'already';
+    if (readError != null)
+        return 'failed';
+    if (!needed)
+        return 'not_needed';
+    const settle = (state, lastError) => ctx.db.update(t).set({ state, lastError, updatedAt: new Date() }).where(eq(t.id, id)).execute();
+    try {
+        await gh().postLine(accountId, pr.owner, pr.name, headSha, context, { state: 'success', description });
+    }
+    catch (err) {
+        const kind = claimErrorKind(err, accountId);
+        await settle('failed', kind === 'error' ? errText(err) : kind).catch(() => { });
+        ctx.log.warn(`skipped line pr ${prId}: not written (${errText(err)}); not retried`);
+        return 'failed';
+    }
+    await settle('posted', null).catch(() => { });
+    return 'posted';
+}
+/**
+ * The providers an auto review of this PR would run with right now (the workspace's pair, else the
+ * default provider), ignoring usage limits — whose context a skipped line goes on. Never empty: the
+ * default provider when none can review. Never throws.
+ */
+export async function autoProvidersForPr(ctx, accountId, prId) {
+    const [{ readAutoReviewProvidersForPr, PAIR_ORDER }, { automaticRunProviders }, { activeProviderId }, { preflightFor }] = await Promise.all([
+        import('./pair.js'),
+        import('../../ai/usage-lockout.js'),
+        import('../../ai/provider-setting.js'),
+        import('../../ai/run-choice.js'),
+    ]);
+    const fallback = activeProviderId();
+    try {
+        const detect = preflightFor(ctx);
+        const pair = (await readAutoReviewProvidersForPr(ctx, accountId, prId)) === 'both';
+        const out = automaticRunProviders({
+            defaultProvider: fallback,
+            pair,
+            order: PAIR_ORDER,
+            ready: (p) => detect(p, 'review').status === 'ok',
+            locked: () => false,
+        });
+        return out.length > 0 ? out : [fallback];
+    }
+    catch {
+        return [fallback];
+    }
+}
+//# sourceMappingURL=team-claim-skip.js.map