limn-review 0.1.182 → 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/db/teammate-reviews.js

@@ -1,6 +1,7 @@
 // TEAMMATES' POSTED REVIEWS — THE READ SIDE (docs/CLAUDE-REVIEW.md § Teammates' reviews). The import
 // is db/teammate-reviews-import.ts. ⚠ This module opens NO database at import (every reader takes an
 // executor): review modules and their fake-context tests import it.
+import { createHash } from 'node:crypto';
 import { and, asc, desc, eq, inArray, isNull, ne, or, sql } from 'drizzle-orm';
 import * as schema from './schema.sqlite.js';
 const { users, reviewComments, commits, pullRequests, repos } = schema;
@@ -67,6 +68,9 @@ export async function listTeammateReviews(exec, accountId, prId) {
         kind: crf.postedCommentKind,
         githubCommentId: crf.githubCommentId,
         nodeId: crf.sourceCommentNodeId,
+        postedAt: crf.postedAt,
+        side: crf.side,
+        reminder: crf.reminder,
     })
         .from(crf)
         .where(inArray(crf.reviewId, rows.map((r) => r.id)))
@@ -114,6 +118,13 @@ export async function listTeammateReviews(exec, accountId, prId) {
                 threadId: kind === 'inline' && f.nodeId != null ? (threadOf.get(f.nodeId) ?? null) : null,
                 ...providersOf(f.nodeId),
                 githubCommentId: f.githubCommentId ?? null,
+                postedAt: f.postedAt != null ? f.postedAt.toISOString() : null,
+                side: f.side === 'LEFT' ? 'LEFT' : 'RIGHT',
+                diffAnchorId: createHash('sha256').update(f.path, 'utf8').digest('hex'),
+                // The reader's reminder (stored beside the finding, never its own post); wire shape only.
+                reminder: f.reminder == null
+                    ? null
+                    : { githubCommentId: f.reminder.githubCommentId, postedCommentKind: f.reminder.postedCommentKind, postedAt: f.reminder.postedAt },
             };
         });
         const at = r.postedAt ?? r.createdAt;

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

@@ -586,6 +586,22 @@ export function registerClaudeReviewRoutes(app, ctx) {
         const accountId = ctx.accountIdOf(req);
         const fctx = await getFindingPostContext(ctx, findingId, accountId);
         if (!fctx) {
+            // A TEAMMATE'S finding takes ONE action here, "Post reminder" (teammate-reminder.ts): posted as
+            // the reader, linking the teammate's comment. A plain Post of it stays 404 (it is theirs).
+            if (req.body?.reminder === true) {
+                const { postTeammateReminder } = await import('./teammate-reminder.js');
+                const out = await postTeammateReminder(ctx, accountId, findingId);
+                if (out.kind === 'posted')
+                    return out.result;
+                if (out.kind === 'conflict') {
+                    reply.status(409);
+                    return { error: out.code, message: out.message };
+                }
+                if (out.kind === 'github_error') {
+                    reply.status(502);
+                    return { error: 'GitHubError', message: out.message };
+                }
+            }
             reply.status(404);
             return { error: 'NotFound', message: `Finding ${findingId} not found` };
         }