limn-review 0.1.164 → 0.1.166

package/dist/api/routes/bot-triage.js

@@ -266,8 +266,8 @@ const analyticsSchema = {
     },
 };
 // GET /api/bot-analytics/vendor/:key/prs?window= — per-REVIEWER PR drill-down. `key` is the
-// analytics-row identity: `u<userId>` (a single reviewer) or the 'pierre' sentinel; the handler
-// parses it (anything else → 400). The window/workspace/repoIds resolution is identical to
+// analytics-row identity: `u<userId>`, a single reviewer; the handler parses it (anything else →
+// 400). The window/workspace/repoIds resolution is identical to
 // /api/bot-analytics, because this list must reproduce ONE of that panel's rows.
 const vendorPrsSchema = {
     params: {
@@ -696,17 +696,13 @@ export async function botTriageRoutes(app) {
     });
     // The per-REVIEWER PR drill-down behind one Bot-ROI row: the PRs that one automated reviewer
     // touched in the window (threads/comments/acted-on/untouched/bot-only), newest-activity first.
-    // `key` is the analytics row identity — `u<userId>` (a single reviewer) or the 'pierre' sentinel;
-    // anything else is a client bug → 400.
+    // `key` is the analytics row identity — `u<userId>`, one reviewer (a Limn bot included); anything
+    // else, the retired 'pierre' sentinel among them, is a client bug → 400.
     app.get('/api/bot-analytics/vendor/:key/prs', { schema: vendorPrsSchema }, async (req, reply) => {
         const { key } = req.params;
         const { window, workspace, repoIds } = req.query;
         const m = /^u(\d+)$/.exec(key);
-        const target = m
-            ? { userId: Number(m[1]) }
-            : key === 'pierre'
-                ? { kind: 'pierre' }
-                : null;
+        const target = m ? { userId: Number(m[1]) } : null;
         if (!target) {
             reply.status(400);
             return { error: 'BadRequest', message: `Invalid vendor key: ${key}` };
@@ -722,19 +718,14 @@ export async function botTriageRoutes(app) {
     // The per-REVIEWER COMMENTS drill-down behind the same Bot-ROI row: everything the reviewer
     // said in the window (inline review comments, PR comments, review bodies), each row with its
     // stored ML label INLINE — one response, never the per-PR label index per row. Same key parse
-    // and the same scope resolution as the /prs sibling, so the list reproduces the same ROI row;
-    // the 'pierre' sentinel answers empty (verbatim reviews are human-posted — no per-comment
-    // rows to attribute). ⚠ Rate tier `search`, pinned in rate-limit.test.ts — this ships up to
+    // and the same scope resolution as the /prs sibling, so the list reproduces the same ROI row.
+    // ⚠ Rate tier `search`, pinned in rate-limit.test.ts — this ships up to
     // 3000 comment BODIES per source plus a three-way label join per request.
     app.get('/api/bot-analytics/vendor/:key/comments', { schema: vendorCommentsSchema }, async (req, reply) => {
         const { key } = req.params;
         const { window, workspace, repoIds, fromMs, toMs } = req.query;
         const m = /^u(\d+)$/.exec(key);
-        const target = m
-            ? { userId: Number(m[1]) }
-            : key === 'pierre'
-                ? { kind: 'pierre' }
-                : null;
+        const target = m ? { userId: Number(m[1]) } : null;
         if (!target) {
             reply.status(400);
             return { error: 'BadRequest', message: `Invalid vendor key: ${key}` };

package/dist/db/bot-overlap.js

@@ -20,6 +20,7 @@
 // ml-labels.ts does not import, and adding it there would deepen the deliberate
 // queries ⇄ ml-labels module cycle. Nothing imports this file back, so no new cycle.
 import { and, eq, gte, inArray } from 'drizzle-orm';
+import { LIMN_LABEL_BACKEND } from '../shared/index.js';
 import { db, schema } from './client.js';
 import { botWindowMs } from './bot-window.js';
 import { clusterThreadsByLine } from './line-overlap.js';
@@ -413,8 +414,14 @@ scope, page) {
     // (the commentFacetCounts rule). ⚠ Its `total` is the count of LABELLED origin comments, NOT
     // the cluster `total` above: a cluster is not an ML row, and only a labelled comment can be
     // placed on either axis. `declared`/`undeclared` state the sparsity honestly.
+    // ⚠ A Limn finding's label is its own review's severity, never a model score, so it sits on
+    // neither axis: left out of the matrix AND of any cell/disagreement refine.
+    const matrixLabelForThread = (threadId) => {
+        const l = labelForThread(threadId);
+        return l && l.backend !== LIMN_LABEL_BACKEND ? l : undefined;
+    };
     const matrix = buildMatrix(capped.flatMap((c) => c.items
-        .map((t) => labelForThread(t.threadId))
+        .map((t) => matrixLabelForThread(t.threadId))
         .filter((l) => l !== undefined)));
     // ── 8. Refine → slice ─────────────────────────────────────────────────────────────────────
     // A cluster survives when ≥1 of its threads matches. (The wire member shape carries no
@@ -435,7 +442,7 @@ scope, page) {
             return false;
         if (!refine.cell && !refine.disagree)
             return true;
-        return labelMatchesRefine(labelForThread(t.threadId), refine);
+        return labelMatchesRefine(matrixLabelForThread(t.threadId), refine);
     };
     const narrowed = refine.cell || refine.disagree || refine.authorUserIds != null
         ? capped.filter((c) => c.items.some(memberMatches))

package/dist/db/limn-bots.js

@@ -0,0 +1,274 @@
+// LIMN FINDINGS ARE BOTS (docs/CLAUDE-REVIEW.md § Limn findings are bots).
+//
+// Limn posts a review finding as the READER (their own GitHub account). Such a comment is the
+// review's words, not the person's, so it is stored under a per-poster BOT user:
+//
+//   users                 login `limn:<poster>` ("Limn · alice"), is_bot = 1 and pinned
+//                         (is_bot_overridden = 1), no node id. ':' never occurs in a GitHub login,
+//                         so the row never collides with a real account. ⚠ Never send it to GitHub.
+//   review_comments /     author_id = the bot; limn_posted_by_user_id = the person who posted it.
+//   pr_comments
+//   workspace_reviewers   one row per workspace the bot appears in: automated, role 'review',
+//                         kind 'pierre', label "Limn · alice" (an 'auto' row the classifier's
+//                         step 0 re-derives identically; a reader's rename pins it as usual).
+//
+// ⚠ "IS THIS MY OWN POST" READS THE TRUE POSTER — `trueAuthorId(table)`, never `author_id`.
+//
+// Which comment is a finding is ONE predicate, shared `limnFindingPost` (marker + a severity or
+// reminder lead). Sync applies it on every walk (sync/upsert.ts `persistPr`), so a body edited to
+// drop the marker goes back to its person; `reconcileLimnFindingAuthors` applies the same rule to
+// rows already stored (boot, and the demo seed).
+import { and, eq, inArray, isNotNull, like, or, sql } from 'drizzle-orm';
+import { isLimnBotLogin, limnBotLabel, limnBotLogin, limnFindingPost, LIMN_BOT_LOGIN_PREFIX, } from '../shared/index.js';
+import { db, runTransaction, schema } from './client.js';
+import { syncLimnFindingLabels } from './limn-finding-labels.js';
+const { users, pullRequests, reviewComments, prComments, reviewThreads, events, searchIndex, workspaceRepos, workspaceReviewers, } = schema;
+/** The person who wrote a comment row: the poster of a Limn finding, else its author. */
+export function trueAuthorId(t) {
+    return sql `coalesce(${t.limnPostedByUserId}, ${t.authorId})`;
+}
+/** The SQL LIKE pattern every `limn:` login matches. */
+const LIMN_LOGIN_LIKE = `${LIMN_BOT_LOGIN_PREFIX}%`;
+/** The per-poster Limn bot user for `posterLogin`: created on first use, always is_bot. */
+export async function ensureLimnBotUser(exec, posterLogin) {
+    const row = (await exec
+        .insert(users)
+        .values({
+        githubLogin: limnBotLogin(posterLogin),
+        githubNodeId: null,
+        displayName: limnBotLabel(posterLogin),
+        avatarUrl: null,
+        githubType: null,
+        isBot: true,
+        isBotOverridden: true,
+    })
+        .onConflictDoUpdate({
+        target: users.githubLogin,
+        set: { isBot: true, isBotOverridden: true, displayName: limnBotLabel(posterLogin) },
+    })
+        .returning({ id: users.id })
+        .execute())[0];
+    return row.id;
+}
+/**
+ * The bot's row in one workspace — written once, never overwritten here (`DO NOTHING`), so a
+ * reader's rename or judgement stands. Names no price or trust column. The values are exactly what
+ * `classifyReviewer`'s step 0 derives, so a later classification pass changes nothing.
+ */
+export async function ensureLimnReviewerRow(exec, accountId, workspaceId, botUserId, posterLogin) {
+    await exec
+        .insert(workspaceReviewers)
+        .values({
+        accountId,
+        workspaceId,
+        authorUserId: botUserId,
+        automated: true,
+        role: 'review',
+        confidence: 'high',
+        source: 'fingerprint',
+        reasonsJson: [LIMN_BOT_REASON],
+        kind: 'pierre',
+        label: limnBotLabel(posterLogin),
+        updatedAt: new Date(),
+    })
+        .onConflictDoNothing({
+        target: [
+            workspaceReviewers.accountId,
+            workspaceReviewers.workspaceId,
+            workspaceReviewers.authorUserId,
+        ],
+    })
+        .execute();
+}
+export const LIMN_BOT_REASON = 'posts Limn review findings';
+/** Every `limn:` bot user id (global, like `users`). */
+export async function limnBotUserIds(exec = db) {
+    const rows = await exec
+        .select({ id: users.id })
+        .from(users)
+        .where(like(users.githubLogin, LIMN_LOGIN_LIKE))
+        .execute();
+    return rows.map((r) => r.id);
+}
+/** The reader's own Limn bot (`limn:<their login>`), or null while they have posted no finding. */
+export async function limnBotUserIdFor(posterLogin, exec = db) {
+    const row = (await exec
+        .select({ id: users.id })
+        .from(users)
+        .where(eq(users.githubLogin, limnBotLogin(posterLogin)))
+        .limit(1)
+        .execute())[0];
+    return row?.id ?? null;
+}
+/** The Limn bot of the person `userId` (by their login), or null when they have none. */
+export async function limnBotUserIdForUser(userId, exec = db) {
+    const row = (await exec
+        .select({ login: users.githubLogin })
+        .from(users)
+        .where(eq(users.id, userId))
+        .limit(1)
+        .execute())[0];
+    if (!row?.login || isLimnBotLogin(row.login))
+        return null;
+    return limnBotUserIdFor(row.login, exec);
+}
+/**
+ * Apply the sync's rule to every stored comment that is, or was, a Limn finding: re-attribute it to
+ * the poster's bot, or give it back to its person. Fixes the comment's event actor, its search-index
+ * author and its thread's root author with it, and ensures the bot's reviewer rows. Idempotent: a
+ * second run writes no comment, event, search or thread row. DB only, one transaction.
+ */
+export async function reconcileLimnFindingAuthors(accountId) {
+    const markerLike = '%pierre:claude-review-finding%';
+    const poster = sql `coalesce(${reviewComments.limnPostedByUserId}, ${reviewComments.authorId})`;
+    const rcRows = await db
+        .select({
+        id: reviewComments.id,
+        prId: reviewComments.prId,
+        nodeId: reviewComments.githubNodeId,
+        threadId: reviewComments.threadId,
+        repoId: pullRequests.repoId,
+        body: reviewComments.body,
+        authorId: reviewComments.authorId,
+        limnPostedBy: reviewComments.limnPostedByUserId,
+        posterId: poster,
+        // A finding is always its thread's ROOT (the earliest comment); a reply never is one.
+        isRoot: sql `not exists (select 1 from review_comments rc2 where rc2.thread_id = ${reviewComments.threadId} and (rc2.created_at < ${reviewComments.createdAt} or (rc2.created_at = ${reviewComments.createdAt} and rc2.id < ${reviewComments.id})))`,
+    })
+        .from(reviewComments)
+        .innerJoin(pullRequests, eq(pullRequests.id, reviewComments.prId))
+        .where(and(eq(pullRequests.accountId, accountId), or(like(reviewComments.body, markerLike), isNotNull(reviewComments.limnPostedByUserId))))
+        .execute();
+    const pcPoster = sql `coalesce(${prComments.limnPostedByUserId}, ${prComments.authorId})`;
+    const pcRows = await db
+        .select({
+        id: prComments.id,
+        prId: prComments.prId,
+        nodeId: prComments.githubNodeId,
+        repoId: pullRequests.repoId,
+        body: prComments.body,
+        authorId: prComments.authorId,
+        limnPostedBy: prComments.limnPostedByUserId,
+        posterId: pcPoster,
+    })
+        .from(prComments)
+        .innerJoin(pullRequests, eq(pullRequests.id, prComments.prId))
+        .where(and(eq(pullRequests.accountId, accountId), or(like(prComments.body, markerLike), isNotNull(prComments.limnPostedByUserId))))
+        .execute();
+    const posterIds = [
+        ...new Set([...rcRows, ...pcRows].map((r) => r.posterId).filter((id) => id != null)),
+    ];
+    const posterLogin = new Map();
+    if (posterIds.length > 0) {
+        for (const u of await db
+            .select({ id: users.id, login: users.githubLogin })
+            .from(users)
+            .where(inArray(users.id, posterIds))
+            .execute())
+            posterLogin.set(u.id, u.login);
+    }
+    const workspaceOfRepo = new Map();
+    for (const m of await db
+        .select({ repoId: workspaceRepos.repoId, workspaceId: workspaceRepos.workspaceId })
+        .from(workspaceRepos)
+        .where(eq(workspaceRepos.accountId, accountId))
+        .execute())
+        workspaceOfRepo.set(m.repoId, m.workspaceId);
+    return runTransaction(async (tx) => {
+        const botIdByLogin = new Map();
+        const botFor = async (login) => {
+            let id = botIdByLogin.get(login);
+            if (id === undefined) {
+                id = await ensureLimnBotUser(tx, login);
+                botIdByLogin.set(login, id);
+            }
+            return id;
+        };
+        // The rule, per row: { authorId, limnPostedBy } as sync would write it now.
+        const desired = async (r, threadRoot = false) => {
+            const login = r.posterId != null ? posterLogin.get(r.posterId) : undefined;
+            if (r.posterId == null || login == null || isLimnBotLogin(login) || limnFindingPost(r.body, { threadRoot }) == null) {
+                return { authorId: r.posterId, limnPostedBy: null };
+            }
+            const botId = await botFor(login);
+            const ws = workspaceOfRepo.get(r.repoId);
+            if (ws != null)
+                await ensureLimnReviewerRow(tx, accountId, ws, botId, login);
+            return { authorId: botId, limnPostedBy: r.posterId };
+        };
+        let comments = 0;
+        const touchedThreads = new Set();
+        for (const r of rcRows) {
+            const d = await desired(r.isRoot ? r : { ...r, body: null }, Boolean(r.isRoot));
+            if (d.authorId === r.authorId && d.limnPostedBy === r.limnPostedBy)
+                continue;
+            comments++;
+            touchedThreads.add(r.threadId);
+            await tx
+                .update(reviewComments)
+                .set({ authorId: d.authorId, limnPostedByUserId: d.limnPostedBy })
+                .where(eq(reviewComments.id, r.id))
+                .execute();
+            await retagActor(tx, accountId, 'review_comment', r.prId, r.id, r.nodeId, d.authorId);
+        }
+        for (const r of pcRows) {
+            const d = await desired(r);
+            if (d.authorId === r.authorId && d.limnPostedBy === r.limnPostedBy)
+                continue;
+            comments++;
+            await tx
+                .update(prComments)
+                .set({ authorId: d.authorId, limnPostedByUserId: d.limnPostedBy })
+                .where(eq(prComments.id, r.id))
+                .execute();
+            await retagActor(tx, accountId, 'pr_comment', r.prId, r.id, r.nodeId, d.authorId);
+        }
+        // A thread's root author follows its first comment (sync takes GitHub's first; the earliest
+        // stored comment is the same one).
+        let threads = 0;
+        for (const threadId of touchedThreads) {
+            const root = (await tx
+                .select({ authorId: reviewComments.authorId })
+                .from(reviewComments)
+                .where(eq(reviewComments.threadId, threadId))
+                .orderBy(reviewComments.createdAt, reviewComments.id)
+                .limit(1)
+                .execute())[0];
+            if (!root)
+                continue;
+            threads += (await tx
+                .update(reviewThreads)
+                .set({ originalCommenterId: root.authorId })
+                .where(and(eq(reviewThreads.id, threadId), sql `${reviewThreads.originalCommenterId} is not ${root.authorId}`))
+                .returning({ id: reviewThreads.id })
+                .execute()).length;
+        }
+        // REPAIR: an older classifier could class a PERSON as Limn (kind 'pierre') from the marker on
+        // their posts. Only the `limn:` bots are Limn. Rows nobody touched by hand (auto judgement,
+        // auto identity, no price, no trust) are deleted; the next Bots read re-derives them.
+        const repaired = await tx
+            .delete(workspaceReviewers)
+            .where(and(eq(workspaceReviewers.accountId, accountId), eq(workspaceReviewers.kind, 'pierre'), eq(workspaceReviewers.source, 'fingerprint'), eq(workspaceReviewers.identitySource, 'auto'), sql `${workspaceReviewers.monthlyCents} is null`, sql `${workspaceReviewers.dependencyTrusted} is null`, sql `${workspaceReviewers.authorUserId} not in (select ${users.id} from ${users} where ${users.githubLogin} like ${LIMN_LOGIN_LIKE})`))
+            .returning({ id: workspaceReviewers.id })
+            .execute();
+        // The severity badges follow the attribution (db/limn-finding-labels.ts).
+        await syncLimnFindingLabels(tx, accountId);
+        return { comments, threads, repairedReviewerRows: repaired.length };
+    });
+}
+// A comment's event actor and search-index author follow its author.
+async function retagActor(tx, accountId, kind, prId, rowId, nodeId, authorId) {
+    await tx
+        .update(events)
+        .set({ actorId: authorId })
+        .where(and(eq(events.accountId, accountId), eq(events.dedupeKey, `${kind}:${nodeId}`)))
+        .execute();
+    await tx
+        .update(searchIndex)
+        .set({ authorId })
+        .where(
+    // `pr_id` first: it is what the index covers (search_pr_idx).
+    and(eq(searchIndex.prId, prId), eq(searchIndex.accountId, accountId), eq(searchIndex.kind, kind), eq(searchIndex.refId, rowId)))
+        .execute();
+}
+//# sourceMappingURL=limn-bots.js.map

package/dist/db/limn-finding-labels.js

@@ -0,0 +1,173 @@
+// THE SEVERITY BADGE OF A LIMN FINDING (docs/ML-SEVERITY.md § Limn findings).
+//
+// A Limn finding comment is a bot comment (db/limn-bots.ts), so Bots Monitoring rolls up its
+// severity like any other bot's. That severity is the REVIEW'S OWN — the lead line Limn posted
+// ("**Warning**") — and NEVER the ML scorer's: a Limn finding is not an ML candidate
+// (ml-labels.ts `listMlCandidates` + `countBotText` leave out `limn_posted_by_user_id IS NOT
+// NULL`, in lockstep).
+//
+// This writer stores it in `ml_comment_labels` with its own backend (`LIMN_LABEL_BACKEND`), so
+// every badge and rollup reads it unchanged:
+//   severity      `LIMN_ML_SEVERITY[lead]` (blocker→critical, warning→major, nit→nit,
+//                 question→minor), probability 1
+//   categories    nit → ['nitpick'], else ['correctness_bug'] (a finding has no lens on GitHub)
+//   vendor claim  NULL — Limn is not a vendor, so the inflation index OMITS and NAMES it
+//   no severity   (a reminder without one) → no row
+//
+// ⚠ THE SCORER NEVER OVERWRITES THESE ROWS (`upsertMlLabels` guards its update on the backend),
+// and a deep re-sync / `ml:enrich --reset` keeps them (`deleteMlLabelsForRepo` and the script
+// skip the backend). The writer is idempotent and runs inside `persistPr`'s transaction (DB only),
+// at the end of the boot reconcile, and after a deep re-sync's label delete.
+import { createHash } from 'node:crypto';
+import { and, eq, inArray, isNotNull, sql } from 'drizzle-orm';
+import { LIMN_LABEL_BACKEND, LIMN_LABEL_MODEL_VERSION, LIMN_ML_SEVERITY, limnFindingPost, } from '../shared/index.js';
+import { db, schema } from './client.js';
+const { mlCommentLabels, pullRequests, reviewComments, prComments } = schema;
+const SEVERITY_ORD = { nit: 0, minor: 1, major: 2, critical: 3 };
+/** The label a Limn finding body carries, or null when it has none (reminder, not a finding). */
+export function limnFindingLabel(body) {
+    const post = limnFindingPost(body);
+    if (post?.severity == null)
+        return null;
+    const severity = LIMN_ML_SEVERITY[post.severity];
+    return {
+        severity,
+        severityOrd: SEVERITY_ORD[severity],
+        categories: severity === 'nit' ? ['nitpick'] : ['correctness_bug'],
+    };
+}
+/**
+ * Make the stored Limn labels match the stored Limn finding comments, for the whole account or
+ * for `prIds` only. Writes a row only when it differs (body, author or severity), and deletes a
+ * Limn-backend row whose comment is no longer a Limn finding with a severity. Idempotent.
+ */
+export async function syncLimnFindingLabels(exec, accountId, opts = {}) {
+    const prIds = opts.prIds;
+    if (prIds && prIds.length === 0)
+        return { written: 0, deleted: 0 };
+    const prFilter = (t) => prIds ? [inArray(t.prId, prIds)] : [];
+    const rc = await exec
+        .select({
+        id: reviewComments.id,
+        prId: reviewComments.prId,
+        repoId: pullRequests.repoId,
+        authorId: reviewComments.authorId,
+        body: reviewComments.body,
+        createdAt: reviewComments.createdAt,
+    })
+        .from(reviewComments)
+        .innerJoin(pullRequests, eq(pullRequests.id, reviewComments.prId))
+        .where(and(eq(pullRequests.accountId, accountId), isNotNull(reviewComments.limnPostedByUserId), ...prFilter(reviewComments)))
+        .execute();
+    const pc = await exec
+        .select({
+        id: prComments.id,
+        prId: prComments.prId,
+        repoId: pullRequests.repoId,
+        authorId: prComments.authorId,
+        body: prComments.body,
+        createdAt: prComments.createdAt,
+    })
+        .from(prComments)
+        .innerJoin(pullRequests, eq(pullRequests.id, prComments.prId))
+        .where(and(eq(pullRequests.accountId, accountId), isNotNull(prComments.limnPostedByUserId), ...prFilter(prComments)))
+        .execute();
+    // Every label on these targets that exists now: a Limn row to keep or drop, or (from before this
+    // writer) a scorer row to replace.
+    const existing = await exec
+        .select({
+        id: mlCommentLabels.id,
+        targetKind: mlCommentLabels.targetKind,
+        targetId: mlCommentLabels.targetId,
+        authorUserId: mlCommentLabels.authorUserId,
+        severity: mlCommentLabels.severity,
+        backend: mlCommentLabels.backend,
+        bodyHash: mlCommentLabels.bodyHash,
+    })
+        .from(mlCommentLabels)
+        .where(and(eq(mlCommentLabels.accountId, accountId), ...(prIds ? [inArray(mlCommentLabels.prId, prIds)] : []), 
+    // Subqueries, not id lists: an account's Limn findings can outgrow SQLite's bound-variable cap.
+    sql `(${mlCommentLabels.backend} = ${LIMN_LABEL_BACKEND}
+          or (${mlCommentLabels.targetKind} = 'review_comment' and ${mlCommentLabels.targetId} in
+            (select ${reviewComments.id} from ${reviewComments} where ${reviewComments.limnPostedByUserId} is not null))
+          or (${mlCommentLabels.targetKind} = 'pr_comment' and ${mlCommentLabels.targetId} in
+            (select ${prComments.id} from ${prComments} where ${prComments.limnPostedByUserId} is not null)))`))
+        .execute();
+    const key = (kind, id) => `${kind}:${id}`;
+    const existingByKey = new Map(existing.map((e) => [key(e.targetKind, e.targetId), e]));
+    let written = 0;
+    const keep = new Set();
+    const now = new Date();
+    const write = async (kind, r) => {
+        if (r.authorId == null)
+            return;
+        const label = limnFindingLabel(r.body);
+        if (!label)
+            return;
+        const k = key(kind, r.id);
+        keep.add(k);
+        const bodyHash = createHash('sha256').update(r.body ?? '').digest('hex');
+        const prior = existingByKey.get(k);
+        if (prior &&
+            prior.backend === LIMN_LABEL_BACKEND &&
+            prior.bodyHash === bodyHash &&
+            prior.authorUserId === r.authorId &&
+            prior.severity === label.severity)
+            return;
+        const values = {
+            accountId,
+            repoId: r.repoId,
+            prId: r.prId,
+            targetKind: kind,
+            targetId: r.id,
+            authorUserId: r.authorId,
+            severity: label.severity,
+            severityOrd: label.severityOrd,
+            severityProb: 1,
+            vendorSeverity: null,
+            vendorSeverityConfidence: null,
+            categories: label.categories,
+            categoryProbs: Object.fromEntries(label.categories.map((c) => [c, 1])),
+            isSummary: false,
+            backend: LIMN_LABEL_BACKEND,
+            modelVersion: LIMN_LABEL_MODEL_VERSION,
+            bodyHash,
+            targetCreatedAt: r.createdAt,
+            updatedAt: now,
+        };
+        // ⚠ Same conflict target as the scorer's upsert (`mcl_account_target`), and NO backend guard:
+        // a Limn finding's label is always Limn's.
+        const { accountId: _a, targetKind: _k, targetId: _t, ...set } = values;
+        written += (await exec
+            .insert(mlCommentLabels)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [mlCommentLabels.accountId, mlCommentLabels.targetKind, mlCommentLabels.targetId],
+            set,
+        })
+            .returning({ id: mlCommentLabels.id })
+            .execute()).length;
+    };
+    for (const r of rc)
+        await write('review_comment', r);
+    for (const r of pc)
+        await write('pr_comment', r);
+    // A Limn row whose comment is no longer a Limn finding with a severity (marker edited away, or
+    // a reminder) is removed; a scorer row on a Limn finding is removed too — never ML-graded.
+    // (Every `existing` row is one or the other, by its query.)
+    const stale = existing.filter((e) => !keep.has(key(e.targetKind, e.targetId))).map((e) => e.id);
+    let deleted = 0;
+    for (let i = 0; i < stale.length; i += 500) {
+        deleted += (await exec
+            .delete(mlCommentLabels)
+            .where(inArray(mlCommentLabels.id, stale.slice(i, i + 500)))
+            .returning({ id: mlCommentLabels.id })
+            .execute()).length;
+    }
+    return { written, deleted };
+}
+/** Run the writer outside any transaction (deep re-sync, scripts). */
+export function syncLimnFindingLabelsNow(accountId, prIds) {
+    return syncLimnFindingLabels(db, accountId, prIds ? { prIds } : {});
+}
+//# sourceMappingURL=limn-finding-labels.js.map

package/dist/db/limn-finding-severity.js

@@ -67,6 +67,8 @@ export function limnSeverityTargets(input) {
     }
     return { byThreadId, byPrCommentId };
 }
+// Who posted a comment: the poster of a Limn finding, else its author.
+const posterOf = (c) => c.limnPostedByUserId ?? c.authorId;
 /**
  * Load this PR's posted findings and fold them over the thread / comment rows getPrDetail already
  * read. One indexed query when nothing of Limn's is posted; the account login and the comment
@@ -97,7 +99,7 @@ export async function loadLimnSeverityTargets(accountId, prId, rows) {
     const loginById = new Map();
     if (needsMatcher) {
         accountLogin = await accountGithubLogin(accountId);
-        const authorIds = [...new Set(rows.threadComments.map((c) => c.authorId).filter((x) => x != null))];
+        const authorIds = [...new Set(rows.threadComments.map(posterOf).filter((x) => x != null))];
         if (authorIds.length > 0) {
             const us = await db
                 .select({ id: schema.users.id, login: schema.users.githubLogin })
@@ -116,7 +118,7 @@ export async function loadLimnSeverityTargets(accountId, prId, rows) {
             threadId: c.threadId,
             databaseId: c.databaseId,
             body: c.body,
-            authorLogin: c.authorId != null ? (loginById.get(c.authorId) ?? null) : null,
+            authorLogin: posterOf(c) != null ? (loginById.get(posterOf(c)) ?? null) : null,
             createdAt: c.createdAt.getTime(),
         })),
         prComments: rows.prComments,

package/dist/db/migrations/0151_limn_finding_bots.sql

@@ -0,0 +1,10 @@
+-- LIMN FINDINGS ARE BOTS (2026-11-01; docs/CLAUDE-REVIEW.md § Limn findings are bots). Additive.
+--   review_comments.limn_posted_by_user_id   the person who posted a Limn finding comment; the
+--   pr_comments.limn_posted_by_user_id       row's author_id then holds the per-poster bot user
+--                                            `limn:<login>`. NULL on every other comment.
+-- No backfill here: the boot reconcile (db/limn-bots.ts `reconcileLimnFindingAuthors`) re-attributes
+-- existing rows, idempotently, because the predicate (shared `limnFindingPost`) is code.
+ALTER TABLE `review_comments` ADD `limn_posted_by_user_id` integer REFERENCES users(id);--> statement-breakpoint
+ALTER TABLE `pr_comments` ADD `limn_posted_by_user_id` integer REFERENCES users(id);--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS `rc_limn_poster_idx` ON `review_comments` (`limn_posted_by_user_id`);--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS `prc_limn_poster_idx` ON `pr_comments` (`limn_posted_by_user_id`);

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

@@ -1058,6 +1058,13 @@
       "when": 1792224053016,
       "tag": "0150_review_coverage",
       "breakpoints": true
+    },
+    {
+      "idx": 151,
+      "version": "6",
+      "when": 1792224054016,
+      "tag": "0151_limn_finding_bots",
+      "breakpoints": true
     }
   ]
 }