limn-review 0.1.174 → 0.1.176

package/dist/api/routes/dependency-merge.js

@@ -126,6 +126,7 @@ export async function dependencyMergeRoutes(app) {
                     autoMerge: { type: 'boolean' },
                     autoApprove: { type: 'boolean' },
                     autoResolveConflicts: { type: 'boolean' },
+                    autoFix: { type: 'boolean' },
                     maxLevel: { type: 'string', enum: [...DEPENDENCY_UPDATE_LEVELS] },
                     securityOnly: { type: 'boolean' },
                     ecosystems: {
@@ -141,7 +142,7 @@ export async function dependencyMergeRoutes(app) {
         // Fastify's validator COERCES types, so `"true"` or 1 would read as a switch. Raw check.
         preValidation: async (req, reply) => {
             const raw = (req.body ?? {});
-            for (const k of ['autoMerge', 'autoApprove', 'autoResolveConflicts', 'securityOnly']) {
+            for (const k of ['autoMerge', 'autoApprove', 'autoResolveConflicts', 'autoFix', 'securityOnly']) {
                 if (k in raw && typeof raw[k] !== 'boolean') {
                     reply.status(400);
                     return reply.send({ error: 'BadRequest', message: `\`${k}\` must be true or false.` });

package/dist/db/ai-usage-report.js

@@ -1,6 +1,7 @@
 import { and, eq, gte, inArray, lt } from 'drizzle-orm';
 import { AI_USAGE_FEATURE_GROUPS, aiModelName, aiUsageFeatureGroup, claudeModelRole, emptyAiUsageFigures, formatTokens, isSpecialistFeature, trackerTicketIdent, AI_MODEL_FOR_ROLE, } from '../shared/index.js';
 import { db, schema } from './client.js';
+import { ownRunsOnly } from './teammate-reviews.js';
 import { measuredTo, reportingWindowInfo } from './reporting-window.js';
 // REPORTS → AI USAGE — the fold behind GET /api/ai/usage-report (docs/API.md; types in packages/shared
 // ai-usage-report.ts). DB only: no model, no GitHub, no tracker.
@@ -488,13 +489,15 @@ export async function getAiUsageReport(accountId, scope, window, nowMs, rate) {
         })
             .from(cr)
             .innerJoin(pr, and(eq(pr.id, cr.prId), eq(pr.accountId, accountId)))
-            .where(and(eq(cr.accountId, accountId), inArray(pr.repoId, scope.repoIds), gte(cr.createdAt, new Date(fromMs)), lt(cr.createdAt, new Date(toMs))))
+            .where(and(eq(cr.accountId, accountId), inArray(pr.repoId, scope.repoIds), gte(cr.createdAt, new Date(fromMs)), lt(cr.createdAt, new Date(toMs)), 
+        // This machine's runs only: a teammate's imported review cost the reader nothing.
+        ownRunsOnly(cr.kind)))
             .execute();
     const reviews = reviewRaw.map((r) => ({
         prId: r.prId,
         status: r.status,
         trigger: r.trigger,
-        kind: r.kind ?? null,
+        kind: r.kind === 'replies' ? 'replies' : null, // 'teammate' rows are filtered out above
         provider: r.provider,
         model: r.model,
         cost: toCost(r.provider, r.costUsd),

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

@@ -13,6 +13,7 @@
 // comment builders make, so the chip always says what GitHub says. Praise is never posted: no chip.
 import { and, eq, inArray, isNotNull } from 'drizzle-orm';
 import { severityForPostedFinding, } from '../shared/index.js';
+import { TEAMMATE_KIND } from './teammate-reviews.js';
 import { db, schema } from './client.js';
 import { findFindingThread } from '../review/claude-review/finding-thread.js';
 import { accountGithubLogin } from './review-threads-for-review.js';
@@ -69,6 +70,12 @@ export function limnSeverityTargets(input) {
 }
 // Who posted a comment: the poster of a Limn finding, else its author.
 const posterOf = (c) => c.limnPostedByUserId ?? c.authorId;
+/** A teammate's imported finding whose comment carried no severity lead (`teammate.unlabelled`). */
+export function isUnlabelledTeammateFinding(f) {
+    if (f.runKind !== TEAMMATE_KIND || f.sourceNodeId == null)
+        return false;
+    return (f.teammate?.unlabelled ?? []).includes(f.sourceNodeId);
+}
 /**
  * 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
@@ -87,11 +94,18 @@ export async function loadLimnSeverityTargets(accountId, prId, rows) {
         githubCommentId: crf.githubCommentId,
         postedCommentKind: crf.postedCommentKind,
         reminder: crf.reminder,
+        runKind: cr.kind,
+        teammate: cr.teammate,
+        sourceNodeId: crf.sourceCommentNodeId,
     })
         .from(crf)
         .innerJoin(cr, eq(cr.id, crf.reviewId))
         .where(and(eq(cr.accountId, accountId), eq(cr.prId, prId), isNotNull(crf.postedAt)))
-        .execute());
+        .execute())
+        // A teammate's UNLABELLED post (a legacy comment with no severity lead) is stored as 'warning'
+        // only because the column is NOT NULL: GitHub shows no label, so neither does the chip.
+        .filter((f) => !isUnlabelledTeammateFinding(f))
+        .map(({ runKind: _k, teammate: _t, sourceNodeId: _n, ...f }) => f);
     if (findings.length === 0)
         return { byThreadId: new Map(), byPrCommentId: new Map() };
     const needsMatcher = findings.some((f) => f.githubCommentId == null && f.postedCommentKind !== 'pr_comment');

package/dist/db/migrations/0160_teammate_reviews.sql

@@ -0,0 +1,21 @@
+-- TEAMMATES' POSTED REVIEWS (docs/CLAUDE-REVIEW.md § Teammates' reviews). A review a teammate's Limn
+-- POSTED to GitHub (summary + finding comments) is imported as a read-only `claude_reviews` row with
+-- `kind = 'teammate'` (plain text, no CHECK — the column already exists), so every reader that means
+-- "the reader's own runs" (`kind IS NULL`, or db/teammate-reviews.ts `ownRunsOnly`) leaves it out.
+--   source_user_id         the teammate who posted it (users.id, the TRUE poster)
+--   source_review_node_id  the GitHub review's node id — the import's idempotency key
+--   teammate               JSON: what the hidden summary marker said (run kind, pair, runs, Limn
+--                          version), the GitHub review's numeric id, and whether the head was inferred
+-- Each finding is keyed on its GitHub comment's node id. Additive and nullable: no backfill (the next
+-- walk of a PR imports what is there).
+ALTER TABLE `claude_reviews` ADD `source_user_id` integer REFERENCES users(id);
+--> statement-breakpoint
+ALTER TABLE `claude_reviews` ADD `source_review_node_id` text;
+--> statement-breakpoint
+ALTER TABLE `claude_reviews` ADD `teammate` text;
+--> statement-breakpoint
+CREATE UNIQUE INDEX `cr_account_pr_source_review` ON `claude_reviews` (`account_id`,`pr_id`,`source_review_node_id`) WHERE `source_review_node_id` IS NOT NULL;
+--> statement-breakpoint
+ALTER TABLE `claude_review_findings` ADD `source_comment_node_id` text;
+--> statement-breakpoint
+CREATE UNIQUE INDEX `crf_review_source_comment` ON `claude_review_findings` (`review_id`,`source_comment_node_id`) WHERE `source_comment_node_id` IS NOT NULL;

package/dist/db/migrations/0161_review_post_on_finish.sql

@@ -0,0 +1,7 @@
+-- "REVIEW AND POST" (docs/CLAUDE-REVIEW.md § Auto-posting, "A manual Review and post"). A MANUAL run
+-- the reader started with the split button's "Review and post" posts itself when it succeeds (a pair:
+-- when both halves have ended), under the auto-post rules. Stored on the run so the post happens at
+-- its end, and so a pair a restart interrupted still posts when the boot ends it.
+--   claude_reviews.post_on_finish   1 = post when the run ends; NULL = keep it in Limn (every other run).
+-- Additive and nullable: no backfill.
+ALTER TABLE `claude_reviews` ADD `post_on_finish` integer;

package/dist/db/migrations/0162_dependency_ai_fix.sql

@@ -0,0 +1,12 @@
+-- DEPENDENCY AUTOMATION FOR TEAMS (docs/MERGE-CI-TRUNK.md § Dependency automation). Additive; no data to move.
+--
+--   workspaces.dependency_auto_fix                     "Fix dependency PRs with AI"; NULL/false = off (the default).
+--   dependency_automation_actions.teammate_login       a 'skipped' row's teammate (their `limn/deps` line holds the head).
+--   dependency_automation_actions.teammate_handled     1 = their line said they finished an action here; else handling now.
+--   The `action` ('ai_fix', 'arm_merge', 'merge_landed') and `state` ('skipped') columns are plain
+--   text with no CHECK, so their new values need no DDL.
+ALTER TABLE `workspaces` ADD `dependency_auto_fix` integer;
+--> statement-breakpoint
+ALTER TABLE `dependency_automation_actions` ADD `teammate_login` text;
+--> statement-breakpoint
+ALTER TABLE `dependency_automation_actions` ADD `teammate_handled` integer;

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

@@ -1121,6 +1121,27 @@
       "when": 1792224062016,
       "tag": "0159_team_claims_default_on",
       "breakpoints": true
+    },
+    {
+      "idx": 160,
+      "version": "6",
+      "when": 1792224066016,
+      "tag": "0160_teammate_reviews",
+      "breakpoints": true
+    },
+    {
+      "idx": 161,
+      "version": "6",
+      "when": 1792224067016,
+      "tag": "0161_review_post_on_finish",
+      "breakpoints": true
+    },
+    {
+      "idx": 162,
+      "version": "6",
+      "when": 1792224068016,
+      "tag": "0162_dependency_ai_fix",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/pending-first-landing.js

@@ -27,6 +27,7 @@
 import { PENDING_OWN_PRS_SHOWN, PENDING_SUMMARY_DAYS, } from '../shared/index.js';
 import { and, count, desc, eq, inArray, isNotNull, min, sql } from 'drizzle-orm';
 import { db, schema } from './client.js';
+import { ownRunsOnly } from './teammate-reviews.js';
 import { config } from '../config.js';
 import { getAccountUserId } from '../auth/account.js';
 import { docsOffersFor } from '../reference-docs/repo-offers-store.js';
@@ -125,7 +126,8 @@ async function reviewSuggestion(accountId, userId, repoIds) {
     const ran = await db
         .select({ id: schema.claudeReviews.id })
         .from(schema.claudeReviews)
-        .where(eq(schema.claudeReviews.accountId, accountId))
+        // The reader's own run: a teammate's imported review is not "a review ran here".
+        .where(and(eq(schema.claudeReviews.accountId, accountId), ownRunsOnly(schema.claudeReviews.kind)))
         .limit(1)
         .execute();
     if (!reviewSuggestionAllowed({

package/dist/db/queries.js

@@ -51,6 +51,7 @@ import { dormantBotUserIds } from './bot-dormancy.js';
 import { newestReviewCommentTimes } from './review-threads-for-review.js';
 import { loadLimnSeverityTargets } from './limn-finding-severity.js';
 import { limnBotUserIdForUser, limnBotUserIds } from './limn-bots.js';
+import { ownRunsOnly } from './teammate-reviews.js';
 import { automationVendorUserIds, exactAutomationVendorUsers, githubTypeBotUserIds, globalAutomationUserIds, } from './automation-ids.js';
 import { forwardKindOf, isConflicting, isRedCiStatus, RED_CI_STATUSES, } from './pending-classify.js';
 import { authorAutomationFor, dependencyPrState, dependencyStateDetail, MERGE_QUEUE_CARD_DETAIL, securityFixDetail, unionAdvisoryIds, } from './dependency-cards.js';
@@ -8018,7 +8019,8 @@ export async function listClaudeReviewsByRepo(repoId, accountId) {
     })
         .from(claudeReviews)
         .innerJoin(pullRequests, eq(pullRequests.id, claudeReviews.prId))
-        .where(and(eq(claudeReviews.accountId, accountId), eq(pullRequests.repoId, repoId)))
+        // The reader's own runs: a teammate's posted review shows only on its PR's AI Review tab.
+        .where(and(eq(claudeReviews.accountId, accountId), eq(pullRequests.repoId, repoId), ownRunsOnly(claudeReviews.kind)))
         .orderBy(desc(claudeReviews.id))
         .execute();
     // Rows are globally id-desc (newest-first). The first row seen for each PR is its

package/dist/db/review-threads-for-review.js

@@ -40,6 +40,7 @@ import { and, eq, gt, inArray, isNotNull } from 'drizzle-orm';
 import { db, schema } from './client.js';
 import { globalAutomationUserIds } from './automation-ids.js';
 import { trueAuthorId } from './limn-bots.js';
+import { ownRunsOnly } from './teammate-reviews.js';
 const LIMN_MARKER = /<!--\s*pierre:claude-review/i;
 const norm = (s) => s.replace(/\r\n?/g, '\n').trim();
 /** The account's own GitHub login — the author half of `isLimnPostedComment`. */
@@ -85,7 +86,8 @@ export async function ownPostedCommentsForPrs(accountId, prIds) {
     })
         .from(crf)
         .innerJoin(cr, eq(cr.id, crf.reviewId))
-        .where(and(eq(cr.accountId, accountId), inArray(cr.prId, [...prIds]), isNotNull(crf.postedAt)))
+        // The reader's OWN posted findings (a teammate's imported ones are their posts, not ours).
+        .where(and(eq(cr.accountId, accountId), inArray(cr.prId, [...prIds]), isNotNull(crf.postedAt), ownRunsOnly(cr.kind)))
         .execute();
     for (const r of rows) {
         let o = out.get(r.prId);

package/dist/db/schema.sqlite.js

@@ -911,10 +911,19 @@ export const dependencyAutomationActions = sqliteTable('dependency_automation_ac
     // No single-column FK: the COMPOSITE declaration below (tenancy as a constraint).
     prId: integer('pr_id').notNull(),
     headSha: text('head_sha').notNull(),
-    action: text('action', { enum: ['approve', 'rebase_request', 'ai_resolve'] }).notNull(),
-    state: text('state', { enum: ['running', 'done', 'failed'] }).notNull(),
+    // 0162 added 'ai_fix', 'arm_merge', 'merge_landed' (plain text, no CHECK).
+    action: text('action', {
+        enum: ['approve', 'rebase_request', 'ai_resolve', 'ai_fix', 'arm_merge', 'merge_landed'],
+    }).notNull(),
+    // 0162 added 'skipped': a teammate's Limn holds the head (`limn/deps`). Not an attempt — a later
+    // claim at the same head TAKES the row over (`claimAction`).
+    state: text('state', { enum: ['running', 'done', 'failed', 'skipped'] }).notNull(),
     detail: text('detail'),
     resultSha: text('result_sha'),
+    // 'skipped' rows (migration 0162): the teammate's GitHub login, and whether their line said they
+    // HANDLED this head (a finished action) rather than are handling it now.
+    teammateLogin: text('teammate_login'),
+    teammateHandled: integer('teammate_handled', { mode: 'boolean' }),
     createdAt: integer('created_at', { mode: 'timestamp' })
         .notNull()
         .default(sql `(unixepoch())`),
@@ -1183,6 +1192,10 @@ export const claudeReviews = sqliteTable('claude_reviews', {
     // A FROM-SCRATCH run (`GenerateReviewBody.fresh`): it read no earlier review — no follow-up, no
     // settled list, no carried thread judgements. true on such a run; NULL otherwise (migration 0133).
     fresh: integer('fresh', { mode: 'boolean' }),
+    // "REVIEW AND POST" (migration 0161): a MANUAL run the reader started with "Review and post" —
+    // posted under the auto-post rules when it (a pair: both halves) ends. true on such a run (both
+    // halves of a pair); NULL otherwise ("Review only", every auto run).
+    postOnFinish: integer('post_on_finish', { mode: 'boolean' }),
     // WHAT THE TEAM CLAIM DID FOR THIS RUN (migration 0134; review/claude-review/team-claim.ts): the
     // GitHub status line it posted ("Marked on GitHub"), or why it ran without one. NULL = no claim
     // was attempted (a manual run, or "Mark auto reviews on GitHub" off).
@@ -1202,12 +1215,21 @@ export const claudeReviews = sqliteTable('claude_reviews', {
     // A REPLIES PASS (review/claude-review/replies-check.ts): 'replies' on a run that judged only
     // people's replies on Limn's own posted findings; NULL on every full review (migration 0136).
     // ⚠ Every "the latest review" / "a run at this head" reader filters `kind IS NULL`.
-    kind: text('kind', { enum: ['replies'] }),
+    // 'teammate' (migration 0160; db/teammate-reviews.ts): a review a TEAMMATE'S Limn posted to GitHub,
+    // imported read-only. Never a run of the reader's: every own-runs reader excludes it.
+    kind: text('kind', { enum: ['replies', 'teammate'] }),
     // A REPLIES PASS's not-approved reason (migration 0145; review/claude-review/replies-outcome.ts):
     // `{heldReason, text}`, written when the pass ends while the workspace's auto verdict is on and
     // the outcome is not an approval. NULL on every full review (its reason rides `auto_post`, or is
     // computed on read).
     verdictReason: text('verdict_reason', { mode: 'json' }).$type(),
+    // A TEAMMATE'S POSTED REVIEW (`kind = 'teammate'`, migration 0160; db/teammate-reviews.ts): the
+    // teammate who posted it, the GitHub review's node id (the import's key; a partial unique index on
+    // (account_id, pr_id, source_review_node_id) in the .sql), and what its hidden marker said. NULL on
+    // every run of the reader's own.
+    sourceUserId: integer('source_user_id').references(() => users.id),
+    sourceReviewNodeId: text('source_review_node_id'),
+    teammate: text('teammate', { mode: 'json' }).$type(),
 }, (t) => ({
     prIdx: index('cr_pr_idx').on(t.prId),
     prShaIdx: index('cr_pr_sha_idx').on(t.prId, t.headSha),
@@ -1304,6 +1326,9 @@ export const claudeReviewFindings = sqliteTable('claude_review_findings', {
     // but is NEVER shown, posted, counted in a verdict or sent to AI Fix; the next follow-up of its
     // provider follows up the kept one instead. NULL on every other finding.
     mergedInto: integer('merged_into'),
+    // A TEAMMATE'S POSTED FINDING (migration 0160): the GitHub comment's node id it was rebuilt from —
+    // the import's key (partial unique (review_id, source_comment_node_id) in the .sql). NULL otherwise.
+    sourceCommentNodeId: text('source_comment_node_id'),
 }, (t) => ({ reviewIdx: index('crf_review_idx').on(t.reviewId) }));
 // ---- Claude Review chat (CORE table, written by the Pro plugin) ----
 // One row per chat MESSAGE about one succeeded review: a general thread (`finding_id` NULL) and
@@ -1919,6 +1944,10 @@ export const workspaces = sqliteTable('workspaces', {
     // every ecosystem. The ONE writer is `setDependencyAutomation` (merge/dependency-automation.ts).
     dependencyAutoApprove: integer('dependency_auto_approve', { mode: 'boolean' }),
     dependencyAutoResolve: integer('dependency_auto_resolve', { mode: 'boolean' }),
+    // "Fix dependency PRs with AI" (migration 0162), NULL/false = OFF: an unattended AI Fix on a
+    // TRUSTED bot's PR whose CI failed (proven live), pushed to its branch; also runs the conflict
+    // steps of `dependencyAutoResolve`. merge/dependency-automation.ts.
+    dependencyAutoFix: integer('dependency_auto_fix', { mode: 'boolean' }),
     dependencyMaxLevel: text('dependency_max_level'),
     dependencySecurityOnly: integer('dependency_security_only', { mode: 'boolean' }),
     dependencyEcosystems: text('dependency_ecosystems', { mode: 'json' }).$type(),

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

@@ -0,0 +1,279 @@
+// TEAMMATES' POSTED REVIEWS — THE IMPORT (docs/CLAUDE-REVIEW.md § Teammates' reviews). The read side
+// (listing, the own-runs filter, the follow-up anchor) is db/teammate-reviews.ts, which opens no
+// database at import.
+//
+// The reader and a teammate both run Limn on the same repos. When the TEAMMATE'S Limn posts a review
+// to GitHub — a review whose body ends in the hidden summary marker (shared `parseLimnReviewMarker`),
+// plus that teammate's Limn finding comments — the reader's Limn imports it as a READ-ONLY run:
+//
+//   claude_reviews          kind 'teammate', status 'succeeded', trigger 'manual' (never 'auto': it
+//                           is nobody's auto run here), cost/tokens NULL, posted_review_id NULL
+//                           (the provenance readers key on it and this is not the reader's post),
+//                           posted_at = when GitHub got it, source_user_id = the teammate,
+//                           source_review_node_id = the GitHub review (the import's key),
+//                           teammate = what the marker said (TeammateReviewRecord).
+//   claude_review_findings  one per finding comment, keyed on the comment's node id, included false,
+//                           posted_at / github_comment_id / posted_comment_kind from the comment.
+//
+// ONLY WHAT REACHED GITHUB: a review a teammate kept in their own Limn is never seen. The reader's own
+// posts are never imported (the TRUE poster is compared with the account's own login). A replies-pass
+// outcome (`k=replies`) is not a review and is skipped.
+//
+// ⚠ EVERY READER THAT MEANS "THE READER'S OWN RUNS" EXCLUDES THESE ROWS — `kind IS NULL` already
+// does; a reader with no kind filter uses `ownRunsOnly` below. The full list of decisions is in
+// docs/CLAUDE-REVIEW.md § Teammates' reviews.
+//
+// WHICH COMMENTS BELONG TO WHICH REVIEW. A synced comment does not record its GitHub review, so a
+// finding comment is given to the teammate's Limn review submitted at or just before it (GitHub
+// stamps a review's inline comments with the review's own time; PR-level comments follow within
+// seconds). A finding that teammate posted later on its own joins their latest review before it.
+//
+// THE HEAD. The marker's `h=`; on a legacy post (no metadata) the PR's newest synced commit at the
+// post time, flagged `headInferred`.
+//
+// DB-only. Idempotent: a second run over the same rows writes the same values.
+import { and, asc, desc, eq, inArray, sql } from 'drizzle-orm';
+import { isLimnBotLogin, limnFindingPost, parseLimnReviewMarker, parsePostedLimnFinding, stripLimnReviewMarker, } from '../shared/index.js';
+import { db, runTransaction, schema } from './client.js';
+import { TEAMMATE_KIND } from './teammate-reviews.js';
+const { accounts, users, reviews, reviewComments, reviewThreads, prComments, commits, pullRequests } = schema;
+const cr = schema.claudeReviews;
+const crf = schema.claudeReviewFindings;
+// A comment is given to a review submitted no later than this after it (clock jitter between a
+// review and its inline comments).
+const GRACE_MS = 60_000;
+const STATE_VERDICT = {
+    approved: 'APPROVE',
+    changes_requested: 'REQUEST_CHANGES',
+    commented: 'COMMENT',
+};
+/**
+ * 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.
+ */
+export async function importTeammateReviews(accountId, prId) {
+    const none = { reviews: 0, findings: 0, removedFindings: 0 };
+    const pr = (await db
+        .select({ id: pullRequests.id, headSha: pullRequests.headSha })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.id, prId), eq(pullRequests.accountId, accountId)))
+        .limit(1)
+        .execute())[0];
+    if (!pr)
+        return none;
+    const readerLogin = (await db.select({ login: accounts.githubLogin }).from(accounts).where(eq(accounts.id, accountId)).limit(1).execute())[0]?.login?.toLowerCase();
+    if (!readerLogin)
+        return none;
+    // Limn review summaries on this PR, by anyone but the reader.
+    const posted = (await db
+        .select({
+        nodeId: reviews.githubNodeId,
+        databaseId: reviews.databaseId,
+        authorId: reviews.authorId,
+        login: users.githubLogin,
+        state: reviews.state,
+        body: reviews.body,
+        submittedAt: reviews.submittedAt,
+    })
+        .from(reviews)
+        .innerJoin(users, eq(users.id, reviews.authorId))
+        .where(and(eq(reviews.prId, prId), sql `${reviews.body} like '%pierre:claude-review%'`))
+        .orderBy(asc(reviews.submittedAt), asc(reviews.id))
+        .execute())
+        .map((r) => ({ ...r, meta: parseLimnReviewMarker(r.body) }))
+        .filter((r) => r.meta != null &&
+        r.meta.run !== 'replies' &&
+        r.state !== 'pending' &&
+        r.authorId != null &&
+        !isLimnBotLogin(r.login) &&
+        r.login.toLowerCase() !== readerLogin);
+    if (posted.length === 0)
+        return none;
+    const posterIds = [...new Set(posted.map((r) => r.authorId))];
+    // Those posters' Limn FINDING comments on this PR (sync re-attributed them to their bot and kept
+    // the poster in `limn_posted_by_user_id`). Inline: thread roots only.
+    const inline = (await db
+        .select({
+        nodeId: reviewComments.githubNodeId,
+        databaseId: reviewComments.databaseId,
+        posterId: reviewComments.limnPostedByUserId,
+        createdAt: reviewComments.createdAt,
+        body: reviewComments.body,
+        path: reviewThreads.path,
+        line: reviewThreads.line,
+        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(reviewThreads, eq(reviewThreads.id, reviewComments.threadId))
+        .where(and(eq(reviewComments.prId, prId), inArray(reviewComments.limnPostedByUserId, posterIds)))
+        .execute());
+    const prLevel = (await db
+        .select({
+        nodeId: prComments.githubNodeId,
+        databaseId: prComments.databaseId,
+        posterId: prComments.limnPostedByUserId,
+        createdAt: prComments.createdAt,
+        body: prComments.body,
+    })
+        .from(prComments)
+        .where(and(eq(prComments.prId, prId), inArray(prComments.limnPostedByUserId, posterIds)))
+        .execute());
+    const candidates = [];
+    for (const c of inline) {
+        if (!c.isRoot)
+            continue;
+        const post = limnFindingPost(c.body, { threadRoot: true });
+        if (post == null || post.reminder)
+            continue;
+        candidates.push({ ...c, body: c.body ?? '', kind: 'inline' });
+    }
+    for (const c of prLevel) {
+        const post = limnFindingPost(c.body);
+        if (post == null || post.reminder)
+            continue;
+        candidates.push({ ...c, body: c.body ?? '', kind: 'pr_comment', path: null, line: null });
+    }
+    // Each comment → the poster's review submitted at or just before it.
+    const byPoster = new Map();
+    for (const r of posted) {
+        const list = byPoster.get(r.authorId) ?? [];
+        list.push(r);
+        byPoster.set(r.authorId, list);
+    }
+    const findingsOf = new Map();
+    for (const c of candidates) {
+        const list = byPoster.get(c.posterId) ?? [];
+        let owner = null;
+        for (const r of list)
+            if (r.submittedAt.getTime() <= c.createdAt.getTime() + GRACE_MS)
+                owner = r;
+        if (owner == null)
+            continue;
+        const got = findingsOf.get(owner.nodeId) ?? [];
+        got.push(c);
+        findingsOf.set(owner.nodeId, got);
+    }
+    // A legacy post's head: the newest synced commit at or before it.
+    const prCommits = await db
+        .select({ sha: commits.sha, committedAt: commits.committedAt })
+        .from(commits)
+        .where(eq(commits.prId, prId))
+        .orderBy(desc(commits.committedAt))
+        .execute();
+    const inferHead = (at) => prCommits.find((c) => c.committedAt.getTime() <= at.getTime())?.sha ?? pr.headSha ?? null;
+    return runTransaction(async (tx) => {
+        const out = { reviews: 0, findings: 0, removedFindings: 0 };
+        for (const r of posted) {
+            const meta = r.meta;
+            const head = meta.headSha ?? inferHead(r.submittedAt);
+            if (head == null)
+                continue;
+            const found = (findingsOf.get(r.nodeId) ?? []).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.nodeId.localeCompare(b.nodeId));
+            const summary = stripLimnReviewMarker(r.body);
+            // A legacy post with no text and no finding is nothing to show (an old replies-pass outcome).
+            if (meta.legacy && summary === '' && found.length === 0)
+                continue;
+            const parsed = found.map((f) => ({ c: f, p: parsePostedLimnFinding(f.body) }));
+            const record = {
+                githubReviewId: r.databaseId ?? null,
+                run: meta.run === 'auto' || meta.run === 'manual' ? meta.run : null,
+                pair: meta.pair,
+                runs: meta.runs,
+                limnVersion: meta.limnVersion,
+                headInferred: meta.headSha == null,
+                ...(parsed.some((x) => x.p.severity == null)
+                    ? { unlabelled: parsed.filter((x) => x.p.severity == null).map((x) => x.c.nodeId) }
+                    : {}),
+            };
+            const first = meta.runs[0];
+            const values = {
+                headSha: head,
+                status: 'succeeded',
+                model: first?.model ?? '',
+                provider: first?.provider ?? null,
+                effort: first?.effort ?? null,
+                summary,
+                verdict: meta.verdict ?? STATE_VERDICT[r.state] ?? null,
+                postedAt: r.submittedAt,
+                finishedAt: r.submittedAt,
+                sourceUserId: r.authorId,
+                teammate: record,
+            };
+            const existing = (await tx
+                .select({ id: cr.id })
+                .from(cr)
+                .where(and(eq(cr.accountId, accountId), eq(cr.prId, prId), eq(cr.sourceReviewNodeId, r.nodeId)))
+                .limit(1)
+                .execute())[0];
+            let reviewId;
+            if (existing) {
+                reviewId = existing.id;
+                await tx.update(cr).set(values).where(eq(cr.id, reviewId)).execute();
+            }
+            else {
+                reviewId = (await tx
+                    .insert(cr)
+                    .values({
+                    ...values,
+                    accountId,
+                    prId,
+                    kind: TEAMMATE_KIND,
+                    trigger: 'manual',
+                    sourceReviewNodeId: r.nodeId,
+                    createdAt: r.submittedAt,
+                })
+                    .returning({ id: cr.id })
+                    .execute())[0].id;
+            }
+            out.reviews += 1;
+            const have = await tx
+                .select({ id: crf.id, nodeId: crf.sourceCommentNodeId })
+                .from(crf)
+                .where(eq(crf.reviewId, reviewId))
+                .execute();
+            const haveByNode = new Map(have.map((h) => [h.nodeId, h.id]));
+            const keep = new Set();
+            for (const { c, p } of parsed) {
+                const fields = {
+                    path: c.kind === 'inline' ? (c.path ?? '') : (p.refPath ?? ''),
+                    line: c.kind === 'inline' ? c.line : p.refLine,
+                    side: 'RIGHT',
+                    // The severity column is NOT NULL: an unlabelled finding stores 'warning', named in
+                    // `teammate.unlabelled` and read back as null.
+                    severity: p.severity ?? 'warning',
+                    title: p.title || '(no text)',
+                    body: p.body,
+                    anchored: c.kind === 'inline',
+                    fileInDiff: c.kind === 'inline',
+                    included: false,
+                    postedAt: c.createdAt,
+                    githubCommentId: c.databaseId,
+                    postedCommentKind: c.kind,
+                };
+                const id = haveByNode.get(c.nodeId);
+                if (id != null) {
+                    keep.add(id);
+                    await tx.update(crf).set(fields).where(eq(crf.id, id)).execute();
+                }
+                else {
+                    const ins = await tx
+                        .insert(crf)
+                        .values({ ...fields, reviewId, sourceCommentNodeId: c.nodeId, createdAt: c.createdAt })
+                        .returning({ id: crf.id })
+                        .execute();
+                    keep.add(ins[0].id);
+                }
+                out.findings += 1;
+            }
+            // A comment no longer there (deleted on GitHub, or now another review's) leaves the review.
+            const gone = have.filter((h) => !keep.has(h.id)).map((h) => h.id);
+            if (gone.length > 0) {
+                await tx.delete(schema.claudeReviewChatMessages).where(inArray(schema.claudeReviewChatMessages.findingId, gone)).execute();
+                await tx.delete(crf).where(inArray(crf.id, gone)).execute();
+                out.removedFindings += gone.length;
+            }
+        }
+        return out;
+    });
+}
+//# sourceMappingURL=teammate-reviews-import.js.map