limn-review 0.1.123

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

@@ -0,0 +1,996 @@
+import { createHash } from 'node:crypto';
+import { and, asc, desc, eq, gte, inArray, isNull, lt, ne, or, sql } from 'drizzle-orm';
+import { CLAUDE_FINDING_LENSES, threadAssessmentCounts } from '../../shared/index.js';
+import { storedList, stripStoredStoryLead } from '../../shared/index.js';
+import { ticketEntriesOf } from './ticket.js';
+import { isFollowUpEligible, resolveFindingBody, } from './follow-up.js';
+// The Claude Review persistence layer. It reads + writes the claudeReviews /
+// claudeReviewFindings tables via ctx.db + ctx.schema (review/agent-context.ts). Only the
+// FEATURE-only reads live here; the cross-surface reads (getClaudeReviewFeedItems /
+// getUnactionedClaudeReviews / listClaudeReviewsByRepo) live in db/queries.ts.
+// ctx.schema is typed loosely (Record<string, any>) — this module addresses tables by name and
+// casts result rows, so it compiles identically against either dialect's schema.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function tables(ctx) {
+    const s = ctx.schema;
+    return { cr: s.claudeReviews, crf: s.claudeReviewFindings, prs: s.pullRequests, repos: s.repos };
+}
+const iso = (d) => d instanceof Date ? d.toISOString() : d == null ? null : new Date(d).toISOString();
+const isoReq = (d) => d instanceof Date ? d.toISOString() : new Date(d).toISOString();
+// GitHub anchors a file in the PR "Files changed" diff by the SHA-256 of its path.
+function diffAnchorId(path) {
+    return createHash('sha256').update(path, 'utf8').digest('hex');
+}
+// A story finding's origin off its row; null unless BOTH columns hold a value.
+export function storyOf(r) {
+    return r.storyIndex != null && Number.isInteger(r.storyIndex) && r.storyIndex >= 0 && r.storyRef
+        ? { index: r.storyIndex, ref: r.storyRef }
+        : null;
+}
+// A stored CI record, or null for an older row / anything malformed (never a guessed shape).
+export function ciRecordOf(v) {
+    if (v == null || typeof v !== 'object')
+        return null;
+    const r = v;
+    if (!Array.isArray(r.failures) || typeof r.state !== 'string')
+        return null;
+    return {
+        state: r.state,
+        checkCount: typeof r.checkCount === 'number' ? r.checkCount : 0,
+        failures: r.failures,
+    };
+}
+function mapFinding(r) {
+    return {
+        id: r.id,
+        reviewId: r.reviewId,
+        path: r.path,
+        line: r.line,
+        side: r.side,
+        diffAnchorId: diffAnchorId(r.path),
+        severity: r.severity,
+        title: r.title,
+        // A story finding stored before its lead moved to post time began with that lead, which only
+        // repeated the title on screen (shared `stripStoredStoryLead`).
+        body: stripStoredStoryLead(r.body, storyOf(r)),
+        editedBody: r.editedBody,
+        suggestion: r.suggestion,
+        diffHunk: r.diffHunk,
+        anchored: r.anchored,
+        fileInDiff: r.fileInDiff,
+        included: r.included,
+        postedAt: iso(r.postedAt),
+        githubCommentId: r.githubCommentId,
+        postedCommentKind: r.postedCommentKind,
+        createdAt: isoReq(r.createdAt),
+        priorFindingId: r.priorFindingId ?? null,
+        lens: asLens(r.lens),
+        story: storyOf(r),
+    };
+}
+// A stored lens outside today's list reads as a general finding, never a made-up label.
+function asLens(v) {
+    return v != null && CLAUDE_FINDING_LENSES.includes(v)
+        ? v
+        : null;
+}
+// The stored follow-up + each item's DERIVED `reraisedFindingId` (the first of this run's
+// findings whose priorFindingId points at the item's earlier finding).
+function mapFollowUp(fu, findings) {
+    if (!fu)
+        return null;
+    const firstByPrior = new Map();
+    for (const f of findings) {
+        if (f.priorFindingId != null && !firstByPrior.has(f.priorFindingId)) {
+            firstByPrior.set(f.priorFindingId, f.id);
+        }
+    }
+    return {
+        ...fu,
+        items: (fu.items ?? []).map((it) => ({
+            ...it,
+            reraisedFindingId: firstByPrior.get(it.priorFindingId) ?? null,
+        })),
+    };
+}
+function mapReview(r, findings, head = null) {
+    const tickets = ticketEntriesOf(r.ticket, r.ticketAssessment);
+    return {
+        id: r.id,
+        prId: r.prId,
+        headSha: r.headSha,
+        status: r.status,
+        model: r.model,
+        scope: r.scope,
+        reviewMode: r.reviewMode,
+        routeReason: r.routeReason,
+        summary: r.summary,
+        verdict: r.verdict,
+        userBody: r.userBody,
+        userVerdict: r.userVerdict,
+        costUsd: r.costUsd,
+        inputTokens: r.inputTokens,
+        outputTokens: r.outputTokens,
+        cacheReadTokens: r.cacheReadTokens,
+        cacheCreationTokens: r.cacheCreationTokens,
+        numTurns: r.numTurns,
+        diffBytes: r.diffBytes,
+        diffCapped: r.diffCapped,
+        error: r.error,
+        excludedFiles: r.excludedFiles ?? [],
+        postedReviewId: r.postedReviewId,
+        postedAt: iso(r.postedAt),
+        createdAt: isoReq(r.createdAt),
+        finishedAt: iso(r.finishedAt),
+        findings: findings.map(mapFinding),
+        tickets,
+        ticket: tickets[0]?.ticket ?? null,
+        ticketAssessment: tickets[0]?.assessment ?? null,
+        head,
+        followUp: mapFollowUp(r.followUp, findings),
+        trigger: r.trigger === 'auto' ? 'auto' : 'manual',
+        // null = this run did not assess threads (older row, skip, not succeeded) — never [].
+        threadAssessments: Array.isArray(r.threadAssessments) ? r.threadAssessments : null,
+        threadAssessmentCounts: Array.isArray(r.threadAssessments)
+            ? threadAssessmentCounts(r.threadAssessments)
+            : null,
+        // null = this run did not look at CI (older row, skip, not succeeded, checks unreadable).
+        ...ciWireOf(r.ciFailures),
+    };
+}
+function ciWireOf(v) {
+    const rec = ciRecordOf(v);
+    return rec
+        ? { ciFailures: rec.failures, ciState: { state: rec.state, checkCount: rec.checkCount } }
+        : { ciFailures: null, ciState: null };
+}
+const summaryOf = (r) => ({
+    id: r.id,
+    headSha: r.headSha,
+    status: r.status,
+    model: r.model,
+    scope: r.scope,
+    reviewMode: r.reviewMode,
+    verdict: r.verdict,
+    userVerdict: r.userVerdict,
+    costUsd: r.costUsd,
+    postedAt: iso(r.postedAt),
+    createdAt: isoReq(r.createdAt),
+    finishedAt: iso(r.finishedAt),
+    trigger: r.trigger === 'auto' ? 'auto' : 'manual',
+});
+// ---- Reads (account-scoped via the join up to repos.accountId — IDOR guard) ----
+export async function getClaudeReviewById(ctx, reviewId, accountId) {
+    const { cr, crf, prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({ review: cr, prHeadSha: prs.headSha })
+        .from(cr)
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(cr.id, reviewId), eq(repos.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const row = rows[0]?.review ?? null;
+    if (!row)
+        return null;
+    const findings = (await ctx.db
+        .select()
+        .from(crf)
+        .where(eq(crf.reviewId, reviewId))
+        .orderBy(asc(crf.id))
+        .execute());
+    const head = await reviewHeadState(ctx, row.prId, row.headSha, rows[0].prHeadSha);
+    return mapReview(row, findings, head);
+}
+export async function getLatestClaudeReview(ctx, prId, accountId) {
+    const { cr, prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({ id: cr.id })
+        .from(cr)
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(cr.prId, prId), eq(repos.accountId, accountId)))
+        .orderBy(desc(cr.id))
+        .limit(1)
+        .execute());
+    const row = rows[0] ?? null;
+    if (!row)
+        return null;
+    return getClaudeReviewById(ctx, row.id, accountId);
+}
+export async function listClaudeReviewHistory(ctx, prId, accountId) {
+    const { cr, prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({ review: cr })
+        .from(cr)
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(cr.prId, prId), eq(repos.accountId, accountId)))
+        .orderBy(desc(cr.id))
+        .execute());
+    return rows.map(({ review }) => summaryOf(review));
+}
+// The window that scopes the cross-PR list (mirrors the core backfill default of 90d).
+const LIST_WINDOW_DAYS = Number.parseInt(process.env.PRO_REVIEW_LIST_WINDOW_DAYS ?? '', 10) || 90;
+export async function listAllClaudeReviews(ctx, accountId) {
+    const { cr, prs, repos } = tables(ctx);
+    const cutoff = new Date(Date.now() - LIST_WINDOW_DAYS * 24 * 60 * 60 * 1000);
+    // sqlite timestamps are unix SECONDS; pg is a Date. Bind the dialect-appropriate value.
+    const tsBound = ctx.isPg ? cutoff : Math.floor(cutoff.getTime() / 1000);
+    const rows = (await ctx.db
+        .select({
+        reviewId: cr.id,
+        prId: cr.prId,
+        owner: repos.owner,
+        name: repos.name,
+        prNumber: prs.number,
+        prTitle: prs.title,
+        prState: prs.state,
+        summary: cr.summary,
+        verdict: cr.verdict,
+        headSha: cr.headSha,
+        status: cr.status,
+        createdAt: cr.createdAt,
+        finishedAt: cr.finishedAt,
+    })
+        .from(cr)
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(repos.accountId, accountId), eq(cr.status, 'succeeded'), or(eq(prs.state, 'open'), gte(sql `coalesce(${prs.mergedAt}, ${prs.closedAt}, ${prs.openedAt})`, tsBound))))
+        .orderBy(desc(cr.finishedAt), desc(cr.createdAt))
+        .execute());
+    const seen = new Set();
+    const items = [];
+    for (const r of rows) {
+        if (seen.has(r.prId))
+            continue;
+        seen.add(r.prId);
+        items.push({
+            reviewId: r.reviewId,
+            prId: r.prId,
+            repoFullName: `${r.owner}/${r.name}`,
+            prNumber: r.prNumber,
+            prTitle: r.prTitle,
+            prState: r.prState,
+            summary: r.summary,
+            verdict: r.verdict,
+            headSha: r.headSha,
+            status: r.status,
+            createdAt: isoReq(r.createdAt),
+            finishedAt: iso(r.finishedAt),
+        });
+    }
+    return items;
+}
+/**
+ * The LATEST run per PR for a batch of PR ids — the Open PRs table's "Claude review" column, ONE
+ * query for the whole list. Account-scoped through `repos.accountId` (a foreign or unknown id is
+ * simply absent). `headMoved` compares the run's head with the PR's SYNCED head; an unknown synced
+ * head is never "moved". DB-only: no GitHub call, no model.
+ */
+export async function getLatestReviewStates(ctx, prIds, accountId, 
+// TRAILING: the AI Fix manager's in-memory claim (`isFixRunning`). When given, each state also
+// carries `fix` ('running' / 'ready') from ONE batched ai_fixes read. Absent ⇒ no `fix` field.
+fixRunning) {
+    if (prIds.length === 0)
+        return [];
+    const { cr, prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({
+        reviewId: cr.id,
+        prId: cr.prId,
+        status: cr.status,
+        verdict: cr.verdict,
+        headSha: cr.headSha,
+        finishedAt: cr.finishedAt,
+        ticket: cr.ticket,
+        prHeadSha: prs.headSha,
+        trigger: cr.trigger,
+    })
+        .from(cr)
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(inArray(cr.prId, [...prIds]), eq(repos.accountId, accountId)))
+        .orderBy(desc(cr.id))
+        .execute());
+    const out = [];
+    const latestByPr = new Map();
+    for (const r of rows) {
+        if (latestByPr.has(r.prId))
+            continue; // newest first — the first row per PR is its latest run
+        latestByPr.set(r.prId, r);
+        out.push({
+            prId: r.prId,
+            reviewId: r.reviewId,
+            status: r.status,
+            verdict: r.verdict,
+            reviewedHeadSha: r.headSha,
+            finishedAt: iso(r.finishedAt),
+            ticket: storedList(r.ticket)[0] ?? null,
+            tickets: storedList(r.ticket),
+            headMoved: r.prHeadSha != null && r.prHeadSha !== r.headSha,
+            currentHeadSha: r.prHeadSha ?? null,
+            trigger: r.trigger === 'auto' ? 'auto' : 'manual',
+        });
+    }
+    await foldStateSummaries(ctx, out, latestByPr);
+    if (fixRunning)
+        await foldFixStates(ctx, out, latestByPr, accountId, fixRunning);
+    return out;
+}
+/**
+ * The Open PRs strip's AI Fix pill, for the listed PRs in ONE read of `ai_fixes`: `'running'` while
+ * the fixer holds a queued / running fix for the PR (the manager's claim is the authority — a row
+ * left `running` by a crash is not), else `'ready'` when a SUCCEEDED fix with a non-empty patch,
+ * never pushed, was built on the PR's CURRENT synced head. Mutates `states` in place.
+ */
+async function foldFixStates(ctx, states, latestByPr, accountId, fixRunning) {
+    if (states.length === 0)
+        return;
+    const af = ctx.schema.aiFixes;
+    const rows = (await ctx.db
+        .select({ prId: af.prId, status: af.status, baseSha: af.baseSha, patch: af.patch, pushedAt: af.pushedAt })
+        .from(af)
+        .where(and(eq(af.accountId, accountId), inArray(af.prId, states.map((s) => s.prId))))
+        .execute());
+    const running = new Set();
+    const ready = new Set();
+    for (const r of rows) {
+        if ((r.status === 'queued' || r.status === 'running') && fixRunning(r.prId))
+            running.add(r.prId);
+        const head = latestByPr.get(r.prId)?.prHeadSha ?? null;
+        if (r.status === 'succeeded' &&
+            r.pushedAt == null &&
+            (r.patch ?? '').trim() !== '' &&
+            head != null &&
+            r.baseSha === head)
+            ready.add(r.prId);
+    }
+    for (const s of states) {
+        if (running.has(s.prId))
+            s.fix = 'running';
+        else if (ready.has(s.prId))
+            s.fix = 'ready';
+    }
+}
+/**
+ * The Open PRs strip's figures for the latest runs: severity / lens / posted counts, story
+ * alignments, follow-up statuses and the outdated commit count. A FIXED number of batched reads
+ * (findings, the run's JSON columns, the moved PRs' commits) whatever the list length — never one
+ * per PR. Mutates `states` in place. A run that did not succeed gets no `summary`.
+ */
+async function foldStateSummaries(ctx, states, latestByPr) {
+    const { cr, crf } = tables(ctx);
+    const done = states.filter((s) => s.status === 'succeeded' && s.reviewId != null);
+    const doneIds = done.map((s) => s.reviewId);
+    // 1. Every finding of the finished runs — the columns the fold needs, nothing else.
+    const findings = doneIds.length
+        ? (await ctx.db
+            .select({ reviewId: crf.reviewId, severity: crf.severity, lens: crf.lens, postedAt: crf.postedAt })
+            .from(crf)
+            .where(inArray(crf.reviewId, doneIds))
+            .execute())
+        : [];
+    // 2. The finished runs' stored assessments (JSON) — read for the LATEST runs only, never history.
+    const extras = doneIds.length
+        ? (await ctx.db
+            .select({
+            id: cr.id,
+            ticketAssessment: cr.ticketAssessment,
+            followUp: cr.followUp,
+            postedAt: cr.postedAt,
+            threadAssessments: cr.threadAssessments,
+            ciFailures: cr.ciFailures,
+        })
+            .from(cr)
+            .where(inArray(cr.id, doneIds))
+            .execute())
+        : [];
+    const extrasById = new Map(extras.map((e) => [e.id, e]));
+    const findingsById = new Map();
+    for (const f of findings) {
+        const list = findingsById.get(f.reviewId) ?? [];
+        list.push(f);
+        findingsById.set(f.reviewId, list);
+    }
+    for (const s of done) {
+        const id = s.reviewId;
+        const counts = { blocker: 0, warning: 0, nit: 0, question: 0, praise: 0 };
+        const lenses = {};
+        let postedFindings = 0;
+        for (const f of findingsById.get(id) ?? []) {
+            if (f.severity in counts)
+                counts[f.severity] += 1;
+            const lens = CLAUDE_FINDING_LENSES.includes(f.lens ?? '') ? f.lens : null;
+            if (lens)
+                lenses[lens] = (lenses[lens] ?? 0) + 1;
+            if (f.postedAt != null)
+                postedFindings += 1;
+        }
+        const extra = extrasById.get(id);
+        const latest = latestByPr.get(s.prId);
+        const tickets = ticketEntriesOf((latest?.ticket ?? null), extra?.ticketAssessment ?? null).map((e) => ({
+            key: e.ticket.key ?? null,
+            title: e.ticket.title ?? null,
+            alignment: e.assessment?.alignment ?? null,
+        }));
+        let followUp = null;
+        const items = extra?.followUp?.items;
+        if (Array.isArray(items) && items.length > 0) {
+            followUp = { addressed: 0, partly_addressed: 0, not_addressed: 0, no_longer_applies: 0, not_checked: 0 };
+            for (const it of items)
+                if (it.status in followUp)
+                    followUp[it.status] += 1;
+        }
+        const summary = {
+            findings: counts,
+            lenses,
+            postedFindings,
+            reviewPosted: extra?.postedAt != null,
+            tickets,
+            followUp,
+        };
+        // null = the run did not assess threads (an older row): no figure, never zeros.
+        if (Array.isArray(extra?.threadAssessments)) {
+            summary.threadAssessments = threadAssessmentCounts(extra.threadAssessments);
+        }
+        // null = the run did not look at CI: no figure, never zeros.
+        const ci = ciRecordOf(extra?.ciFailures);
+        if (ci) {
+            summary.ci = {
+                failing: ci.failures.length,
+                diagnosed: ci.failures.filter((f) => f.status === 'diagnosed').length,
+            };
+        }
+        s.summary = summary;
+    }
+    // 3. The outdated count, for every moved PR — ONE commits read for all of them.
+    const moved = states.filter((s) => s.headMoved && s.reviewedHeadSha != null);
+    const c = ctx.schema.commits;
+    if (moved.length === 0 || !c)
+        return;
+    const commitRows = (await ctx.db
+        .select({ prId: c.prId, sha: c.sha, committedAt: c.committedAt, headline: c.messageHeadline })
+        .from(c)
+        .where(inArray(c.prId, moved.map((s) => s.prId)))
+        .execute());
+    const commitsByPr = new Map();
+    for (const r of commitRows) {
+        const list = commitsByPr.get(r.prId) ?? [];
+        list.push(r);
+        commitsByPr.set(r.prId, list);
+    }
+    for (const s of moved) {
+        const head = latestByPr.get(s.prId)?.prHeadSha;
+        if (!head)
+            continue;
+        s.commitsSince = countCommitsSince(commitsByPr.get(s.prId) ?? [], s.reviewedHeadSha, head);
+    }
+}
+export async function getReviewPostContext(ctx, reviewId, accountId) {
+    const { cr, prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({
+        headSha: cr.headSha,
+        userBody: cr.userBody,
+        owner: repos.owner,
+        name: repos.name,
+        prNumber: prs.number,
+    })
+        .from(cr)
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(cr.id, reviewId), eq(repos.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const row = rows[0];
+    if (!row)
+        return null;
+    return {
+        reviewHeadSha: row.headSha,
+        userBody: row.userBody,
+        owner: row.owner,
+        name: row.name,
+        prNumber: row.prNumber,
+    };
+}
+export async function getFindingPostContext(ctx, findingId, accountId) {
+    const { cr, crf, prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({
+        finding: crf,
+        reviewHeadSha: cr.headSha,
+        owner: repos.owner,
+        name: repos.name,
+        prNumber: prs.number,
+    })
+        .from(crf)
+        .innerJoin(cr, eq(cr.id, crf.reviewId))
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(crf.id, findingId), eq(repos.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const row = rows[0];
+    if (!row)
+        return null;
+    return { finding: row.finding, reviewHeadSha: row.reviewHeadSha, owner: row.owner, name: row.name, prNumber: row.prNumber };
+}
+export async function getReviewPrContext(ctx, prId, accountId) {
+    const { prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({
+        prId: prs.id,
+        owner: repos.owner,
+        name: repos.name,
+        number: prs.number,
+        title: prs.title,
+        body: prs.body,
+        baseRefName: prs.baseRefName,
+        headSha: prs.headSha,
+    })
+        .from(prs)
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(prs.id, prId), eq(repos.accountId, accountId)))
+        .limit(1)
+        .execute());
+    const row = rows[0];
+    if (!row)
+        return null;
+    return {
+        prId: row.prId,
+        owner: row.owner,
+        name: row.name,
+        repoFullName: `${row.owner}/${row.name}`,
+        number: row.number,
+        title: row.title,
+        body: row.body,
+        baseRefName: row.baseRefName,
+        headSha: row.headSha,
+    };
+}
+// ---- The previous review, for the follow-up ----
+/**
+ * The PREVIOUS review a new run follows up on, with its eligible findings — or null.
+ *
+ * The previous review is the newest SUCCEEDED run for the same PR (account-scoped through the
+ * repos join — the getLatestClaudeReview IDOR pattern) with an id below the current run's, that
+ * actually READ code: `review_mode IS NULL OR review_mode <> 'skip'`. ⚠ The NULL arm is
+ * load-bearing — pre-routing rows have no mode, and a bare `<>` drops NULL rows in SQL.
+ *
+ * Its findings are kept when eligible (`isFollowUpEligible`: POSTED to GitHub and not praise),
+ * with the body the user saw. A finding that was ignored, left unposted or only copied never enters
+ * the follow-up — not the prompt, not the stored record, not the counts. CARRY-FORWARD re-loads two kinds of OLDER finding named by
+ * that run's follow-up items — the ids come only from our own stored JSON and are re-scoped to this
+ * PR + account by the query — and marks them `carried`, so nothing drops out of the chain:
+ *   - every 'not_checked' item (never shown to the model, or not reported on), when eligible;
+ *   - every still-open item (not / partly addressed) that no ELIGIBLE (posted) finding of that
+ *     run raises again, when the earlier finding is itself eligible. That keeps a posted comment in
+ *     the chain when its re-raise was never posted — the re-raise follow-up.ts saved left out
+ *     because the comment was already on the same commit (`isAlreadyOnThisCommit`), or one the
+ *     reader simply did not post — so it is followed up against the comment that IS on the PR.
+ *
+ * Every finding carries the head of the review that RAISED it (`cr.headSha` via the join), because
+ * "has the code moved since?" is asked per finding, never against the previous review's head.
+ */
+export async function loadPriorReviewForFollowUp(ctx, prId, accountId, beforeReviewId) {
+    const { cr, crf, prs, repos } = tables(ctx);
+    const rows = (await ctx.db
+        .select({ id: cr.id, headSha: cr.headSha, followUp: cr.followUp })
+        .from(cr)
+        .innerJoin(prs, eq(prs.id, cr.prId))
+        .innerJoin(repos, eq(repos.id, prs.repoId))
+        .where(and(eq(cr.prId, prId), eq(repos.accountId, accountId), eq(cr.status, 'succeeded'), lt(cr.id, beforeReviewId), or(isNull(cr.reviewMode), ne(cr.reviewMode, 'skip'))))
+        .orderBy(desc(cr.id))
+        .limit(1)
+        .execute());
+    const row = rows[0];
+    if (!row)
+        return null;
+    const toPrior = (f, headSha, carried) => ({
+        id: f.id,
+        headSha,
+        path: f.path,
+        line: f.line,
+        side: f.side,
+        severity: f.severity,
+        title: f.title,
+        body: resolveFindingBody(f),
+        suggestion: f.suggestion,
+        diffHunk: f.diffHunk,
+        anchored: f.anchored,
+        fileInDiff: f.fileInDiff,
+        posted: f.postedAt != null,
+        carried,
+        story: storyOf(f),
+    });
+    const own = (await ctx.db
+        .select()
+        .from(crf)
+        .where(eq(crf.reviewId, row.id))
+        .orderBy(asc(crf.id))
+        .execute());
+    const eligibleOwn = own.filter(isFollowUpEligible);
+    const findings = eligibleOwn.map((f) => toPrior(f, row.headSha, false));
+    const seen = new Set(own.map((f) => f.id));
+    // An earlier finding an eligible finding of that run already raises again is followed up
+    // THROUGH that re-raise, never twice.
+    const reraisedByEligible = new Set(eligibleOwn.map((f) => f.priorFindingId).filter((id) => id != null));
+    const notChecked = new Set();
+    const openNotReraised = new Map();
+    for (const it of row.followUp?.items ?? []) {
+        if (!Number.isInteger(it.priorFindingId) || seen.has(it.priorFindingId))
+            continue;
+        if (it.status === 'not_checked')
+            notChecked.add(it.priorFindingId);
+        else if ((it.status === 'not_addressed' || it.status === 'partly_addressed') &&
+            !reraisedByEligible.has(it.priorFindingId)) {
+            // Kept with the answer that run gave: on a same-head re-run it stands (follow-up.ts).
+            openNotReraised.set(it.priorFindingId, { status: it.status, explanation: it.explanation ?? null });
+        }
+    }
+    const carriedIds = [...new Set([...notChecked, ...openNotReraised.keys()])];
+    if (carriedIds.length > 0) {
+        const carriedRows = (await ctx.db
+            .select({ finding: crf, headSha: cr.headSha })
+            .from(crf)
+            .innerJoin(cr, eq(cr.id, crf.reviewId))
+            .innerJoin(prs, eq(prs.id, cr.prId))
+            .innerJoin(repos, eq(repos.id, prs.repoId))
+            .where(and(inArray(crf.id, carriedIds), eq(cr.prId, prId), eq(repos.accountId, accountId)))
+            .orderBy(asc(crf.id))
+            .execute());
+        for (const { finding, headSha } of carriedRows) {
+            // The ONE rule (posted, not praise) applies to carried findings exactly as to own ones.
+            if (seen.has(finding.id) || !isFollowUpEligible(finding))
+                continue;
+            seen.add(finding.id);
+            findings.push({ ...toPrior(finding, headSha, true), priorStatus: openNotReraised.get(finding.id) ?? null });
+        }
+    }
+    return { reviewId: row.id, headSha: row.headSha, findings };
+}
+// ---- Writers ----
+// The tickets are stored at QUEUE time (not on success), so a failed or cancelled run still
+// prefills the SPA's panel for the re-run. Stored as an ARRAY (null when none).
+export async function insertQueuedReview(ctx, prId, headSha, model, accountId, tickets = [], 
+// TRAILING: who started it. 'auto' = the per-workspace sweeper (auto.ts). A label only: core's
+// My Turn read keeps an auto run exactly like a manual one, and the chip says "Auto review".
+trigger = 'manual') {
+    const { cr } = tables(ctx);
+    const rows = (await ctx.db
+        .insert(cr)
+        .values({
+        accountId,
+        prId,
+        headSha,
+        status: 'queued',
+        model,
+        ticket: tickets.length > 0 ? [...tickets] : null,
+        trigger,
+    })
+        .returning({ id: cr.id })
+        .execute());
+    return rows[0].id;
+}
+export async function markReviewRunning(ctx, id) {
+    const { cr } = tables(ctx);
+    await ctx.db.update(cr).set({ status: 'running' }).where(eq(cr.id, id)).execute();
+}
+export async function markReviewRouted(ctx, id, reviewMode, routeReason) {
+    const { cr } = tables(ctx);
+    await ctx.db.update(cr).set({ reviewMode, routeReason }).where(eq(cr.id, id)).execute();
+}
+export async function saveReviewSuccess(ctx, id, data) {
+    const { cr, crf } = tables(ctx);
+    await ctx.runTransaction(async (tx) => {
+        await tx
+            .update(cr)
+            .set({
+            status: 'succeeded',
+            scope: data.scope,
+            summary: data.summary,
+            verdict: data.verdict,
+            costUsd: data.costUsd,
+            inputTokens: data.inputTokens,
+            outputTokens: data.outputTokens,
+            cacheReadTokens: data.cacheReadTokens ?? null,
+            cacheCreationTokens: data.cacheCreationTokens ?? null,
+            numTurns: data.numTurns,
+            diffBytes: data.diffBytes ?? null,
+            diffCapped: data.diffCapped ?? null,
+            excludedFiles: data.excludedFiles,
+            followUp: data.followUp ?? null,
+            ticketAssessment: data.ticketAssessment ?? null,
+            threadAssessments: data.threadAssessments ?? null,
+            ciFailures: data.ciFailures ?? null,
+            finishedAt: new Date(),
+        })
+            .where(eq(cr.id, id))
+            .execute();
+        for (const f of data.findings) {
+            await tx
+                .insert(crf)
+                .values({
+                reviewId: id,
+                path: f.path,
+                line: f.line,
+                side: f.side,
+                severity: f.severity,
+                title: f.title,
+                body: f.body,
+                suggestion: f.suggestion,
+                diffHunk: f.diffHunk,
+                anchored: f.anchored,
+                fileInDiff: f.fileInDiff,
+                // Findings are INCLUDED by default (the UI is opt-OUT); the column default is
+                // false for back-compat, so set it here. The one exception arrives as `included:
+                // false`: a re-raise of a comment already posted on this same commit (follow-up.ts
+                // `isAlreadyOnThisCommit`), so Post review does not put it on GitHub twice.
+                included: f.included ?? true,
+                priorFindingId: f.priorFindingId ?? null,
+                lens: f.lens ?? null,
+                // Set only on a story finding (ticket.ts `storyFindingsFrom`, or a re-raise of one).
+                storyIndex: f.story?.index ?? null,
+                storyRef: f.story?.ref ?? null,
+            })
+                .execute();
+        }
+    });
+    await recordReviewUsage(ctx, id, data.costUsd, data.inputTokens, data.outputTokens).catch(() => { });
+}
+export async function markReviewFailed(ctx, id, error, telemetry = {}) {
+    const { cr } = tables(ctx);
+    await ctx.db
+        .update(cr)
+        .set({
+        status: 'failed',
+        error: error.slice(0, 4000),
+        costUsd: telemetry.costUsd ?? null,
+        inputTokens: telemetry.inputTokens ?? null,
+        outputTokens: telemetry.outputTokens ?? null,
+        cacheReadTokens: telemetry.cacheReadTokens ?? null,
+        cacheCreationTokens: telemetry.cacheCreationTokens ?? null,
+        numTurns: telemetry.numTurns ?? null,
+        diffBytes: telemetry.diffBytes ?? null,
+        diffCapped: telemetry.diffCapped ?? null,
+        scope: telemetry.scope ?? null,
+        excludedFiles: telemetry.excludedFiles ?? null,
+        finishedAt: new Date(),
+    })
+        .where(eq(cr.id, id))
+        .execute();
+    await recordReviewUsage(ctx, id, telemetry.costUsd, telemetry.inputTokens, telemetry.outputTokens).catch(() => { });
+}
+export async function markReviewCancelled(ctx, id) {
+    const { cr } = tables(ctx);
+    await ctx.db
+        .update(cr)
+        .set({ status: 'cancelled', finishedAt: new Date() })
+        .where(eq(cr.id, id))
+        .execute();
+}
+export async function updateReviewDraft(ctx, id, fields) {
+    const set = {
+        ...(fields.userBody !== undefined ? { userBody: fields.userBody } : {}),
+        ...(fields.userVerdict !== undefined ? { userVerdict: fields.userVerdict } : {}),
+    };
+    if (Object.keys(set).length === 0)
+        return true;
+    const { cr } = tables(ctx);
+    const changed = (await ctx.db
+        .update(cr)
+        .set(set)
+        .where(eq(cr.id, id))
+        .returning({ id: cr.id })
+        .execute());
+    return changed.length > 0;
+}
+export async function updateFinding(ctx, findingId, fields) {
+    const set = {
+        ...(fields.included !== undefined ? { included: fields.included } : {}),
+        ...(fields.editedBody !== undefined
+            ? { editedBody: fields.editedBody === '' ? null : fields.editedBody }
+            : {}),
+    };
+    if (Object.keys(set).length === 0)
+        return true;
+    const { crf } = tables(ctx);
+    const changed = (await ctx.db
+        .update(crf)
+        .set(set)
+        .where(eq(crf.id, findingId))
+        .returning({ id: crf.id })
+        .execute());
+    return changed.length > 0;
+}
+export async function markReviewPosted(ctx, id, postedReviewId, inlineFindingIds, prComments = []) {
+    const { cr, crf } = tables(ctx);
+    const now = new Date();
+    await ctx.runTransaction(async (tx) => {
+        await tx.update(cr).set({ postedReviewId, postedAt: now }).where(eq(cr.id, id)).execute();
+        if (inlineFindingIds.length > 0) {
+            await tx
+                .update(crf)
+                .set({ postedAt: now, postedCommentKind: 'inline' })
+                .where(inArray(crf.id, inlineFindingIds))
+                .execute();
+        }
+        for (const pc of prComments) {
+            await tx
+                .update(crf)
+                .set({ postedAt: now, githubCommentId: pc.commentId, postedCommentKind: 'pr_comment' })
+                .where(eq(crf.id, pc.findingId))
+                .execute();
+        }
+    });
+}
+export async function markFindingPosted(ctx, findingId, githubCommentId, kind = 'inline') {
+    const { crf } = tables(ctx);
+    await ctx.db
+        .update(crf)
+        .set({ postedAt: new Date(), githubCommentId, postedCommentKind: kind })
+        .where(eq(crf.id, findingId))
+        .execute();
+}
+// On startup, heal runs left mid-flight by a crash/restart.
+export async function reconcileOrphanedReviews(ctx) {
+    const { cr } = tables(ctx);
+    const changed = (await ctx.db
+        .update(cr)
+        .set({ status: 'failed', error: 'interrupted by restart', finishedAt: new Date() })
+        .where(inArray(cr.status, ['queued', 'running']))
+        .returning({ id: cr.id })
+        .execute());
+    return changed.length;
+}
+// Record a run's cost on the shared AI-usage ledger (agent seam). Reads accountId/model/prId
+// back off the row. Best-effort — a $0 / non-billing run records nothing.
+async function recordReviewUsage(ctx, id, costUsd, inputTokens, outputTokens) {
+    if (costUsd == null || !Number.isFinite(costUsd) || costUsd <= 0)
+        return;
+    const { cr } = tables(ctx);
+    const row = (await ctx.db
+        .select({ accountId: cr.accountId, model: cr.model, prId: cr.prId })
+        .from(cr)
+        .where(eq(cr.id, id))
+        .limit(1)
+        .execute())[0];
+    if (!row)
+        return;
+    await ctx.recordAiUsage({
+        accountId: row.accountId,
+        seam: 'agent',
+        feature: 'claude_review',
+        model: row.model,
+        costUsd,
+        inputTokens: inputTokens ?? null,
+        outputTokens: outputTokens ?? null,
+        prId: row.prId,
+    });
+}
+/**
+ * The pure half of `reviewHeadState` (also folded per PR by the batched Open PRs states read):
+ * how many of a PR's synced commits are newer than the reviewed one. null when either commit is
+ * not synced, or the history looks rewritten (a newer copy with the reviewed commit's headline).
+ */
+export function countCommitsSince(rows, reviewedSha, currentHeadSha) {
+    const ms = (v) => (v instanceof Date ? v.getTime() : Number(v));
+    const reviewed = rows.find((r) => r.sha === reviewedSha);
+    const head = rows.find((r) => r.sha === currentHeadSha);
+    if (!reviewed || !head)
+        return null;
+    const at = ms(reviewed.committedAt);
+    const newer = rows.filter((r) => r.sha !== reviewedSha && ms(r.committedAt) > at);
+    // Sync never prunes commits a force-push dropped, so a rebase or amend leaves the reviewed
+    // commit's own rewritten copy among the "newer" rows (same headline, later time). Counting
+    // those would call a rewrite "N newer commits"; say only that the branch changed (null).
+    const rewritten = reviewed.headline != null && newer.some((r) => r.headline === reviewed.headline);
+    return rewritten ? null : newer.length;
+}
+/**
+ * Is the review behind the PR's head? DB-only. `commitsSince` counts the PR's synced commits newer
+ * than the reviewed one (by commit time); null when the reviewed commit is not among them, or when
+ * it looks rewritten (a newer copy with its headline) — never a guess. null overall when the PR's head is unknown.
+ */
+export async function reviewHeadState(ctx, prId, reviewedSha, currentHeadSha) {
+    if (!currentHeadSha)
+        return null;
+    if (currentHeadSha === reviewedSha) {
+        return { currentHeadSha, outdated: false, commitsSince: 0 };
+    }
+    const c = ctx.schema.commits;
+    let commitsSince = null;
+    if (c) {
+        const rows = (await ctx.db
+            .select({ sha: c.sha, committedAt: c.committedAt, headline: c.messageHeadline })
+            .from(c)
+            .where(eq(c.prId, prId))
+            .execute());
+        commitsSince = countCommitsSince(rows, reviewedSha, currentHeadSha);
+    }
+    return { currentHeadSha, outdated: true, commitsSince };
+}
+// ---- Auto re-review helpers ----
+/** Is there ANY run (any status) of this PR at `headSha`? One run per head. */
+export async function hasReviewAtHead(ctx, prId, accountId, headSha) {
+    const { cr } = tables(ctx);
+    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)))
+        .limit(1)
+        .execute());
+    return rows.length > 0;
+}
+/**
+ * Is the auto re-review keyed (headSha, commentsAtMs) already SETTLED? Any run of this PR at the
+ * head settles a moved head (one run per head). For new comments on an unchanged head
+ * (`commentsAtMs` set) a run at the head settles it only when it covered that comment: its
+ * `comments_through` (else its start, `created_at`) is at or after it. The sweeper's candidate read
+ * (db/queries.ts `getAutoReviewCandidates`) applies the same rule; this is the re-check a waiting
+ * item makes before its row is written.
+ */
+export async function isAutoReReviewSettled(ctx, prId, accountId, headSha, commentsAtMs) {
+    const { cr } = tables(ctx);
+    const rows = (await ctx.db
+        .select({ createdAt: cr.createdAt, commentsThrough: cr.commentsThrough })
+        .from(cr)
+        .where(and(eq(cr.prId, prId), eq(cr.accountId, accountId), eq(cr.headSha, headSha)))
+        .execute());
+    if (rows.length === 0)
+        return false;
+    if (commentsAtMs == null)
+        return true;
+    return rows.some((r) => (r.commentsThrough ?? r.createdAt).getTime() >= commentsAtMs);
+}
+/** Record the newest qualifying review comment the run saw (the comment half of the re-review key). */
+export async function markReviewCommentsSeen(ctx, id, commentsThrough) {
+    if (!commentsThrough)
+        return;
+    const { cr } = tables(ctx);
+    await ctx.db.update(cr).set({ commentsThrough }).where(eq(cr.id, id)).execute();
+}
+/**
+ * The previous SUCCEEDED run (non-skip, id below this one) — what a same-head run carries forward:
+ * its head, its stories + their assessments, and its thread assessments. null when none.
+ */
+export async function loadPriorRunForCarry(ctx, prId, accountId, beforeReviewId) {
+    const { cr } = tables(ctx);
+    const rows = (await ctx.db
+        .select({
+        headSha: cr.headSha,
+        ticket: cr.ticket,
+        ticketAssessment: cr.ticketAssessment,
+        threadAssessments: cr.threadAssessments,
+        ciFailures: cr.ciFailures,
+    })
+        .from(cr)
+        .where(and(eq(cr.prId, prId), eq(cr.accountId, accountId), eq(cr.status, 'succeeded'), lt(cr.id, beforeReviewId), or(isNull(cr.reviewMode), ne(cr.reviewMode, 'skip'))))
+        .orderBy(desc(cr.id))
+        .limit(1)
+        .execute());
+    const r = rows[0];
+    if (!r)
+        return null;
+    return {
+        headSha: r.headSha,
+        tickets: storedList(r.ticket),
+        ticketAssessments: storedList(r.ticketAssessment),
+        threadAssessments: Array.isArray(r.threadAssessments) ? r.threadAssessments : null,
+        ciFailures: ciRecordOf(r.ciFailures)?.failures ?? null,
+    };
+}
+/** The stories stored on the PR's latest run ([] when none) — what a re-review carries forward. */
+export async function getLatestStoredTickets(ctx, prId, accountId) {
+    const { cr } = tables(ctx);
+    const rows = (await ctx.db
+        .select({ ticket: cr.ticket })
+        .from(cr)
+        .where(and(eq(cr.prId, prId), eq(cr.accountId, accountId)))
+        .orderBy(desc(cr.id))
+        .limit(1)
+        .execute());
+    return storedList(rows[0]?.ticket ?? null);
+}
+//# sourceMappingURL=persist.js.map