limn-review 0.1.123

package/dist/sync/upsert.js

@@ -0,0 +1,1190 @@
+import { and, desc, eq, sql } from 'drizzle-orm';
+import { db, schema, runTransaction } from '../db/client.js';
+import { searchText } from '../db/search.js';
+// The single owner of "which workspace is this account's Default" — concurrent-safe (INSERT …
+// ON CONFLICT DO NOTHING then re-SELECT) and carrying the name-collision ladder. Duplicating a
+// bare `SELECT … WHERE is_default` here would be a second answer to the same question.
+import { ensureDefaultWorkspace } from '../db/queries.js';
+import { config } from '../config.js';
+import { isLikelyBot } from './bot-detection.js';
+import { notePrChanged } from './pr-change-signal.js';
+import { classifyPrSecurity, } from './security-detect.js';
+import { deriveThreadState, } from './derive-thread-state.js';
+const { repos, users, pullRequests, reviews, reviewThreads, reviewComments, prComments, commits, events, reviewRequests, reviewRequestEvents, ciStatusEvents, searchIndex, workspaceRepos, } = schema;
+function toDate(iso) {
+    return iso ? new Date(iso) : null;
+}
+function maxDate(dates) {
+    let max = null;
+    for (const d of dates) {
+        if (d && (!max || d > max))
+            max = d;
+    }
+    return max;
+}
+function minDate(dates) {
+    let min = null;
+    for (const d of dates) {
+        if (d && (!min || d < min))
+            min = d;
+    }
+    return min;
+}
+// Short single-line preview of a comment body. Stored even in lean mode (where the
+// full body is dropped) so the triage path (getMyTurn/getThreadsAwaiting) and
+// graceful UI degradation work without hydrating from GitHub.
+function excerptOf(body) {
+    if (!body)
+        return null;
+    const oneLine = body.replace(/\s+/g, ' ').trim();
+    if (!oneLine)
+        return null;
+    return oneLine.length > 160 ? `${oneLine.slice(0, 159)}…` : oneLine;
+}
+/** Resolves GraphQL actors to local user ids, caching by login within a run. */
+export function createUserResolver() {
+    const cache = new Map();
+    return {
+        async resolve(exec, actor) {
+            const login = actor?.login;
+            if (!login)
+                return null;
+            const cached = cache.get(login);
+            if (cached !== undefined)
+                return cached;
+            const nodeId = actor?.id ?? null;
+            // The GitHub node id is the STABLE identity; the login is NOT. The same
+            // account can surface under two different logins — even inside one sync
+            // payload: a bot's Bot-typed author field reads `dependabot[bot]` while its
+            // commit-author field reads the bare `dependabot`, both carrying the same
+            // node id; and humans get renamed. Because BOTH `github_login` AND
+            // `github_node_id` are UNIQUE, the login-keyed upsert below is unsafe when a
+            // DIFFERENT row already owns this node id: matching the login (or inserting a
+            // new one) while `coalesce`-stamping the node raises "UNIQUE constraint
+            // failed: users.github_node_id". So when we have a node id, resolve on it
+            // FIRST and reuse the row that owns it — the colliding insert/update is never
+            // issued. Only a brand-new (or absent) node id falls through to the
+            // login-keyed upsert, where stamping the node can't collide.
+            if (nodeId) {
+                const owner = (await exec
+                    .select({
+                    id: users.id,
+                    isBot: users.isBot,
+                    isBotOverridden: users.isBotOverridden,
+                })
+                    .from(users)
+                    .where(eq(users.githubNodeId, nodeId))
+                    .limit(1)
+                    .execute())[0];
+                if (owner) {
+                    // Refresh volatile metadata but NEVER rewrite the login: the row already
+                    // holds a canonical login for this node id, and rewriting it would risk the
+                    // github_login UNIQUE (when the incoming login belongs to another live row)
+                    // and thrash a bot that alternates login forms across a single sync. Only
+                    // set fields the actor actually carries (a commit-author resolve has no
+                    // name/avatar/typename) so we never clobber a known value with null — the
+                    // same "coalesce" intent as the upsert below, via plain portable value
+                    // binds (a raw `sql` boolean can't bind on sqlite; a bare null param can
+                    // confuse pg type inference). isBot honours a manual override.
+                    const set = { isBot: owner.isBotOverridden ? owner.isBot : isLikelyBot(login) };
+                    if (actor?.name != null)
+                        set.displayName = actor.name;
+                    if (actor?.avatarUrl != null)
+                        set.avatarUrl = actor.avatarUrl;
+                    if (actor?.__typename != null)
+                        set.githubType = actor.__typename;
+                    await exec.update(users).set(set).where(eq(users.id, owner.id)).execute();
+                    cache.set(login, owner.id);
+                    return owner.id;
+                }
+            }
+            const row = (await exec
+                .insert(users)
+                .values({
+                githubLogin: login,
+                githubNodeId: nodeId,
+                displayName: actor?.name ?? null,
+                avatarUrl: actor?.avatarUrl ?? null,
+                // GraphQL __typename ('User'|'Bot'|…) when the actor carried it (the fat
+                // activity query selects it on every author); null for locally-synthesized
+                // actors (commit authors / review requests). Feeds the bot-triage classifier.
+                githubType: actor?.__typename ?? null,
+                isBot: isLikelyBot(login),
+            })
+                .onConflictDoUpdate({
+                target: users.githubLogin,
+                set: {
+                    githubNodeId: sql `coalesce(excluded.github_node_id, ${users.githubNodeId})`,
+                    displayName: sql `coalesce(excluded.display_name, ${users.displayName})`,
+                    avatarUrl: sql `coalesce(excluded.avatar_url, ${users.avatarUrl})`,
+                    // Never overwrite a known github_type with null (a later {login,id}-only
+                    // resolve of the same actor must not wipe the type captured from GraphQL).
+                    githubType: sql `coalesce(excluded.github_type, ${users.githubType})`,
+                    // Never clobber a manual is_bot override.
+                    isBot: sql `case when ${users.isBotOverridden} = true then ${users.isBot} else excluded.is_bot end`,
+                },
+            })
+                .returning({ id: users.id })
+                .execute())[0];
+            cache.set(login, row.id);
+            return row.id;
+        },
+    };
+}
+/**
+ * Upsert a repo by its GitHub node id; returns the local repo id.
+ *
+ * ── IT ALSO WRITES THE WORKSPACE MEMBERSHIP ROW, IN THE SAME TRANSACTION ─────────────────────
+ * A repo with NO `workspace_repos` row is INVISIBLE to every workspace-scoped read — no PRs, no
+ * feed rows, no bots, and silently. This is the WRITE side of closing that gap (the READ side is
+ * `ensureRepoMemberships`, which repairs stragglers on essentially every GET). Doing it here, in
+ * the same `runTransaction` as the repo row, means a repo is never committed without a home.
+ *
+ * ⚠ `ON CONFLICT (account_id, repo_id) DO NOTHING` IS LOAD-BEARING. That unique is "one workspace
+ * per repo", so an upsert on it would be a MOVE: a re-sync of an existing repo would silently drag
+ * it back out of the workspace a human deliberately put it in, on every sync tick.
+ *
+ * The membership row IS the whole of a repo's visibility now — there is no second "watched" axis
+ * to also set (`repos.inbox_watch` and its start stamp are dropped). A repo in a workspace is
+ * fully live: Feed, Activity, My Turn and Bots all cover it.
+ *
+ * The Default workspace is resolved BEFORE the transaction opens, deliberately:
+ * `ensureDefaultWorkspace` runs on `db`, and on Postgres `db` is a Pool — i.e. a DIFFERENT
+ * connection from the transaction's executor — so calling it inside would run outside the
+ * transaction on one dialect and inside it on the other.
+ *
+ * Safe against `runTransaction`'s bare `BEGIN`: `upsertRepo` has no caller already inside a
+ * transaction (`api/routes/repos.ts`, `sync/sync-repo.ts`).
+ */
+export async function upsertRepo(owner, name, githubNodeId, defaultBranch, accountId, viewerPermission, description) {
+    // default_branch: only overwrite when known (a branch is never revoked, and the
+    // lightweight add-repo path omits it) so we never null a synced value.
+    // viewer_permission: the activity sync ALWAYS fetches it (passing null when
+    // GitHub reports no permission, i.e. access was revoked), so `undefined` means
+    // "not fetched" (add path → preserve) while `null`/string is authoritative and
+    // overwrites — otherwise a revoked-to-null permission would stay stale-elevated.
+    // description: the three-state partial-response policy (sync/branch-status.ts is the
+    // reference) — `undefined` ⇒ the selection wasn't received (add path, a tolerant
+    // partial) ⇒ OMIT so the stored value survives; `null` ⇒ GitHub positively said the
+    // repo has no description ⇒ clear; a string overwrites.
+    const set = { owner, name };
+    if (defaultBranch != null)
+        set.defaultBranch = defaultBranch;
+    if (viewerPermission !== undefined)
+        set.viewerPermission = viewerPermission;
+    if (description !== undefined)
+        set.description = description;
+    const workspaceId = await ensureDefaultWorkspace(accountId);
+    return runTransaction(async (tx) => {
+        const row = (await tx
+            .insert(repos)
+            .values({
+            accountId,
+            owner,
+            name,
+            githubNodeId,
+            defaultBranch: defaultBranch ?? null,
+            viewerPermission: viewerPermission ?? null,
+            description: description ?? null,
+        })
+            .onConflictDoUpdate({
+            target: [repos.accountId, repos.githubNodeId],
+            set,
+        })
+            .returning({ id: repos.id })
+            .execute())[0];
+        await tx
+            .insert(workspaceRepos)
+            .values({ accountId, workspaceId, repoId: row.id })
+            .onConflictDoNothing({ target: [workspaceRepos.accountId, workspaceRepos.repoId] })
+            .execute();
+        return row.id;
+    });
+}
+function prState(s) {
+    if (s === 'MERGED')
+        return 'merged';
+    if (s === 'CLOSED')
+        return 'closed';
+    return 'open';
+}
+// Exported because the default-branch snapshot (sync/branch-status.ts) maps the SAME GitHub
+// `StatusState` enum off a Commit's rollup. Two copies would drift silently.
+export function ciStatusFrom(state) {
+    switch ((state ?? '').toUpperCase()) {
+        case 'SUCCESS':
+            return 'success';
+        case 'FAILURE':
+            return 'failure';
+        case 'PENDING':
+            return 'pending';
+        case 'ERROR':
+            return 'error';
+        case 'EXPECTED':
+            return 'expected';
+        default:
+            return 'unknown';
+    }
+}
+function mergeableFrom(state) {
+    switch ((state ?? '').toUpperCase()) {
+        case 'MERGEABLE':
+            return 'mergeable';
+        case 'CONFLICTING':
+            return 'conflicting';
+        default:
+            return 'unknown';
+    }
+}
+const MERGE_STATE_STATUSES = new Set([
+    'clean',
+    'dirty',
+    'unstable',
+    'blocked',
+    'behind',
+    'has_hooks',
+    'unknown',
+]);
+// GitHub's MergeStateStatus enum also has DRAFT — "the merge is blocked due to the pull
+// request being a draft". We deliberately do NOT model it: `isDraft` is already stored as
+// its own boolean, and every merge surface resolves draft-ness from that (lib/ui.ts
+// `mergeVerdict` checks `isDraft` before it looks at the status). Folding DRAFT into the
+// enum would mean a draft PR permanently reports mergeStateStatus='draft' and the moment it
+// is marked ready we'd have no idea whether it is clean or blocked until the next sync.
+// It lands in 'unknown' below, which is exactly what it is: not yet computed FOR A MERGE.
+const DRAFT_MERGE_STATE = 'draft';
+// GraphQL PullRequestReviewDecision → the stored lowercase enum. Null (the repo requires no
+// review at all) is preserved as null — distinct from 'approved'.
+/**
+ * GitHub's PullRequestReviewDecision → the stored enum. Exported because
+ * GET /api/prs/:id/merge-options surfaces the LIVE decision from its merge-queue probe and must
+ * map it exactly as the sync walk does — two spellings of one enum is how the merge control and
+ * the PR row start disagreeing about the same PR.
+ *
+ * ⚠ It cannot distinguish "GitHub said null" from "we were handed nothing": both return null.
+ * The caller owns that distinction (omit the key vs. write null) — see the partial-response rule
+ * in CLAUDE.md and sync/branch-status.ts.
+ */
+export function reviewDecisionFrom(decision) {
+    switch ((decision ?? '').toUpperCase()) {
+        case 'APPROVED':
+            return 'approved';
+        case 'CHANGES_REQUESTED':
+            return 'changes_requested';
+        case 'REVIEW_REQUIRED':
+            return 'review_required';
+        default:
+            return null;
+    }
+}
+function mergeStateStatusFrom(state) {
+    const lower = (state ?? '').toLowerCase();
+    // DRAFT is a known value we intentionally map to 'unknown' (see DRAFT_MERGE_STATE above);
+    // naming it here keeps that a decision rather than an accident of the fallback.
+    if (lower === DRAFT_MERGE_STATE)
+        return 'unknown';
+    return (MERGE_STATE_STATUSES.has(lower) ? lower : 'unknown');
+}
+// GitHub's MergeQueueEntryState → the stored lowercase enum. Exported for the same reason
+// `reviewDecisionFrom` is: the two merge-queue WRITE routes in api/routes/prs.ts stamp this
+// column from a mutation response, and a second spelling of one enum is how the merge control
+// and the PR row start disagreeing about the same PR.
+//
+// ⚠ Returns null for anything unrecognised, INCLUDING a state GitHub adds later. That is the
+// safe direction here — an unknown string stored raw would leak straight onto the wire as a
+// display value nobody wrote copy for — but it does mean "no entry" and "an entry in a state we
+// do not model" are both null. The caller must therefore never infer membership from this
+// column; `inMergeQueue` is the membership fact.
+export function mergeQueueEntryStateFrom(state) {
+    switch ((state ?? '').toUpperCase()) {
+        case 'AWAITING_CHECKS':
+            return 'awaiting_checks';
+        case 'LOCKED':
+            return 'locked';
+        case 'MERGEABLE':
+            return 'mergeable';
+        case 'QUEUED':
+            return 'queued';
+        case 'UNMERGEABLE':
+            return 'unmergeable';
+        default:
+            return null;
+    }
+}
+// Exported because sync/branch-status.ts maps the SAME contexts union for default-branch
+// commits. The CheckRun status/conclusion → CheckRunState table must not exist twice: if trunk
+// and PR surfaces disagreed about what "failing" means, the same check would render differently
+// depending on where you looked at it.
+export function checkContextState(c) {
+    if (c.__typename === 'StatusContext') {
+        switch ((c.state ?? '').toUpperCase()) {
+            case 'SUCCESS':
+                return 'success';
+            case 'FAILURE':
+                return 'failure';
+            case 'ERROR':
+                return 'error';
+            case 'PENDING':
+            case 'EXPECTED':
+                return 'pending';
+            default:
+                return 'unknown';
+        }
+    }
+    // CheckRun: outcome is meaningful only once completed.
+    if ((c.status ?? '').toUpperCase() !== 'COMPLETED')
+        return 'pending';
+    switch ((c.conclusion ?? '').toUpperCase()) {
+        case 'SUCCESS':
+            return 'success';
+        case 'FAILURE':
+        case 'TIMED_OUT':
+        case 'STARTUP_FAILURE':
+        case 'ACTION_REQUIRED':
+            return 'failure';
+        case 'CANCELLED':
+        case 'STALE':
+        case 'NEUTRAL':
+            return 'neutral';
+        case 'SKIPPED':
+            return 'skipped';
+        default:
+            return 'unknown';
+    }
+}
+// A GitHub Actions check's detailsUrl is .../actions/runs/<runId>/job/<jobId> — parse
+// the two ids so the frontend can fetch that job's logs on demand. Third-party CI
+// (StatusContext / external CheckRuns) has a detailsUrl pointing elsewhere; no match →
+// null, and the UI keeps it as a plain external link (logs aren't retrievable).
+const ACTIONS_JOB_RE = /\/actions\/runs\/(\d+)\/job\/(\d+)/;
+// Exported for the default-branch commit checks, which parse the same detailsUrl shape.
+export function parseActionsIds(url) {
+    const m = url ? ACTIONS_JOB_RE.exec(url) : null;
+    if (!m)
+        return { runId: null, jobId: null };
+    return { runId: Number(m[1]), jobId: Number(m[2]) };
+}
+export function checkRunsFrom(head) {
+    const nodes = head?.statusCheckRollup?.contexts?.nodes ?? [];
+    const mapped = nodes.map((c) => {
+        const url = c.__typename === 'CheckRun' ? c.detailsUrl : c.targetUrl;
+        const { runId, jobId } = c.__typename === 'CheckRun' ? parseActionsIds(url) : { runId: null, jobId: null };
+        return {
+            name: c.__typename === 'CheckRun' ? c.name : c.context,
+            state: checkContextState(c),
+            url,
+            runId,
+            jobId,
+        };
+    });
+    // GitHub's `statusCheckRollup.contexts` returns EVERY check attached to the head
+    // commit's check suites — it does NOT collapse to "latest per check name" the way the
+    // PR UI does. When a head commit is covered by more than one workflow RUN (a re-run,
+    // or a workflow fired by both the `push` and `pull_request` events — classic for
+    // Dependabot), each run contributes its own same-named CheckRun, so the same check
+    // appears two+ times. Dedupe by display name, keeping the NEWEST run (Actions run ids
+    // increase monotonically, so the highest runId is the most recent — matching the PR
+    // UI); a real CheckRun (has a runId) beats a same-named StatusContext (runId null).
+    // Map preserves first-insertion order, so distinct checks keep their order.
+    const byName = new Map();
+    for (const c of mapped) {
+        const prev = byName.get(c.name);
+        if (!prev || (c.runId ?? -1) > (prev.runId ?? -1))
+            byName.set(c.name, c);
+    }
+    return [...byName.values()];
+}
+const REVIEW_STATES = new Set([
+    'approved',
+    'changes_requested',
+    'commented',
+    'dismissed',
+    'pending',
+]);
+function reviewState(s) {
+    const lower = s.toLowerCase();
+    return (REVIEW_STATES.has(lower) ? lower : 'commented');
+}
+// A review warrants its own timeline marker only when it's substantive: a
+// decision (approved/changes_requested/dismissed) or one carrying a summary
+// body. An empty "commented" review is just GitHub's wrapper around inline
+// comments — those already show as review_comment markers, so the wrapper would
+// duplicate them. See db/cleanup.ts for backfilling existing rows.
+export function isSubstantiveReview(state, body) {
+    return state !== 'commented' || !!body?.trim();
+}
+// Lifecycle transitions GitHub exposes no discrete event for, detected by comparing the
+// PR's prior persisted row (`prev`) against the incoming sync (`next`). Returns the
+// event types to emit: draft→ready (`pr_ready_for_review`) and closed→open
+// (`pr_reopened`). `prev` is null on a PR's first sight, so nothing is emitted then —
+// we never observed it as draft/closed, so there's no transition to report.
+export function lifecycleTransitions(prev, next) {
+    const out = [];
+    if (prev?.isDraft === true && next.isDraft === false)
+        out.push('pr_ready_for_review');
+    if (prev?.state === 'closed' && next.state === 'open')
+        out.push('pr_reopened');
+    return out;
+}
+async function upsertEvent(exec, row) {
+    await exec
+        .insert(events)
+        .values(row)
+        .onConflictDoUpdate({
+        target: [events.accountId, events.dedupeKey],
+        set: {
+            actorId: row.actorId,
+            occurredAt: row.occurredAt,
+            refTable: row.refTable,
+            refId: row.refId,
+        },
+    })
+        .execute();
+}
+/**
+ * Persist a single PR and all its nested entities idempotently, derive thread
+ * states, and emit timeline events. `commitFilesBySha` must already be
+ * populated for any commits relevant to unresolved-thread derivation.
+ */
+// Decide a review thread's resolvedAt on this sync. We can't read GitHub's true resolution time,
+// so we approximate it by the sync that FIRST observes the thread flip unresolved→resolved:
+//  • a prior stamp is preserved (idempotent — never moves once set),
+//  • a witnessed unresolved→resolved transition stamps `observedAt`,
+//  • a thread already resolved the first time we see it (no prior row, or prior already resolved
+//    with a null stamp) stays null — its true resolution time is unknowable, so it's excluded
+//    from the resolution-latency metric rather than counted with a bogus (deploy-time) latency.
+export function nextResolvedAt(prior, isResolved, observedAt) {
+    if (prior?.resolvedAt != null)
+        return prior.resolvedAt;
+    if (isResolved && prior != null && !prior.isResolved)
+        return observedAt;
+    return null;
+}
+/**
+ * Persist a PR's review-request HISTORY (`review_request_events`) and stamp that we received it.
+ * Shared by persistPr and the one-time backfill so the two write one shape.
+ *
+ * ⚠ `nodes === undefined | null` IS "NOT RECEIVED" AND WRITES NOTHING — not the events, not the
+ * stamp. A fixture without the selection and a token GitHub nulled it for both land here, and
+ * stamping them would tell Chronology "never requested" about PRs we simply could not see. An
+ * EMPTY array is a positive statement (no request ever made) and IS stamped.
+ *
+ * Events are immutable on GitHub, so each is inserted DO NOTHING on (pr_id, node id).
+ */
+export async function persistReviewRequestHistory(exec, prId, nodes, resolver) {
+    if (nodes == null)
+        return;
+    for (const n of nodes) {
+        if (n == null || !n.id || !n.createdAt)
+            continue;
+        const kind = n.__typename === 'ReviewRequestedEvent'
+            ? 'requested'
+            : n.__typename === 'ReviewRequestRemovedEvent'
+                ? 'removed'
+                : null;
+        if (kind == null)
+            continue;
+        const r = n.requestedReviewer;
+        let reviewerKind = 'unknown';
+        let reviewerUserId = null;
+        let teamSlug = null;
+        if (r && (r.__typename === 'User' || r.__typename === 'Bot') && r.login) {
+            reviewerKind = 'user';
+            reviewerUserId = await resolver.resolve(exec, {
+                login: r.login,
+                id: r.id,
+                __typename: r.__typename,
+            });
+        }
+        else if (r && r.__typename === 'Team') {
+            reviewerKind = 'team';
+            teamSlug = r.slug ?? null;
+        }
+        await exec
+            .insert(reviewRequestEvents)
+            .values({
+            prId,
+            githubNodeId: n.id,
+            kind,
+            occurredAt: new Date(n.createdAt),
+            reviewerKind,
+            reviewerUserId,
+            teamSlug,
+        })
+            .onConflictDoNothing({ target: [reviewRequestEvents.prId, reviewRequestEvents.githubNodeId] })
+            .execute();
+    }
+    await exec
+        .update(pullRequests)
+        .set({ reviewRequestsSyncedAt: new Date() })
+        .where(eq(pullRequests.id, prId))
+        .execute();
+}
+/** One classification → the four columns, for BOTH writers (`persistPr` and the one-shot backfill
+ *  in sync/backfill-pr-security.ts), so a walk and a backfill can never store the same PR two ways.
+ *  An empty id list is stored as NULL. The caller owns the "only on a received `bodyText`" gate. */
+export function securityColumnsFor(input) {
+    const s = classifyPrSecurity(input);
+    return {
+        dependencyVendor: s.dependencyVendor,
+        securityFix: s.securityFix,
+        advisoryIds: s.advisoryIds.length > 0 ? s.advisoryIds : null,
+        securityCheckedAt: new Date(),
+    };
+}
+export async function persistPr(pr, repoId, resolver, commitFilesBySha, accountId) {
+    // DEPENDENCY + SECURITY SIGNALS — the three-state write (the `queueObserved` pattern below).
+    // GitHub types `bodyText` String!, so a null can only be a partial response and `undefined` a
+    // response that never carried the selection: both LEARN NOTHING and write nothing. A string —
+    // even '' — is a positive statement, and the classification is written whole, NULLs included.
+    // ⚠ The FULL bodyText, never `searchRows`/`search_index`: that copy is capped at 4,000
+    // characters and Dependabot's security footer is the last line of a body that runs to 65 KB.
+    // ⚠ Classified BEFORE the transaction: it is pure CPU over text the PR's author wrote, and no
+    // regex over that text should run while the write lock is held.
+    const securityObserved = typeof pr.bodyText === 'string'
+        ? securityColumnsFor({
+            title: pr.title,
+            headRefName: pr.headRefName ?? null,
+            labels: (pr.labels?.nodes ?? []).map((l) => l.name),
+            bodyText: pr.bodyText,
+        })
+        : {};
+    // Set inside the transaction from the `prev` read; the SPA change signal is raised only AFTER
+    // the commit, so it can never announce a row a reader cannot see yet.
+    let boardMoved = false;
+    await runTransaction(async (tx) => {
+        const authorId = await resolver.resolve(tx, pr.author);
+        // The actual merger (null for non-merged PRs / when GitHub omits the actor).
+        const mergedById = await resolver.resolve(tx, pr.mergedBy);
+        const openedAt = new Date(pr.createdAt);
+        const mergedAt = toDate(pr.mergedAt);
+        const closedAt = toDate(pr.closedAt);
+        const commitDates = pr.commits.nodes.map((c) => new Date(c.commit.committedDate));
+        const lastCommitAt = maxDate(commitDates);
+        const firstReviewAt = minDate(pr.reviews.nodes.map((r) => toDate(r.submittedAt)));
+        // Earliest review request (timeline first:1 is chronological; min guards any ordering surprise).
+        const firstReviewRequestedAt = minDate((pr.firstReviewRequest?.nodes ?? []).map((n) => toDate(n.createdAt ?? null)));
+        const head = pr.headCommit?.nodes[0]?.commit;
+        const headSha = head?.oid ?? null;
+        const ciStatus = ciStatusFrom(head?.statusCheckRollup?.state);
+        const mergeable = mergeableFrom(pr.mergeable);
+        const mergeStateStatus = mergeStateStatusFrom(pr.mergeStateStatus);
+        const reviewDecision = reviewDecisionFrom(pr.reviewDecision);
+        // ---- merge queue: the THREE-STATE partial-response write --------------------------------
+        //
+        // `graphqlTolerant` hands back GitHub's partial data with a forbidden field NULLED — the key
+        // is PRESENT, not absent — so "GitHub says this PR is not queued" and "we never received the
+        // selection" look identical at the JSON level, and they demand opposite writes. Writing
+        // unconditionally would clear a real queue entry on every tick for a partially-forbidden
+        // token; writing only on non-null would leave a dequeued PR reading "queued" forever.
+        //
+        // The discriminator is free here and needs no `pagePartial` flag threaded down from
+        // sync-repo.ts (which is how `repos.description` resolves the same problem): GitHub types
+        // `isInMergeQueue` as `Boolean!`, so a real answer is only ever true or false. A null can
+        // ONLY be a nulled-by-partial-error field, and `undefined` can only be a response (or a
+        // hand-built fixture) that never carried the selection. Both mean "learn nothing".
+        //
+        // `false` IS a positive statement and MUST clear both columns — a repo with the merge queue
+        // switched off answers false with a null entry every walk, and so does a PR that just landed
+        // or was ejected. That is the case this whole column exists to make visible.
+        const queueObserved = pr.isInMergeQueue == null
+            ? {}
+            : {
+                inMergeQueue: pr.isInMergeQueue,
+                // Not queued ⇒ no entry, whatever the (absent) object says. Queued ⇒ the entry's
+                // state, or null when GitHub gave us the membership but not a state we model — see
+                // mergeQueueEntryStateFrom on why an unmodelled state is not stored raw.
+                mergeQueueEntryState: pr.isInMergeQueue
+                    ? mergeQueueEntryStateFrom(pr.mergeQueueEntry?.state)
+                    : null,
+            };
+        const labels = (pr.labels?.nodes ?? []).map((l) => ({
+            name: l.name,
+            color: l.color,
+        }));
+        const checkRuns = checkRunsFrom(head);
+        // Diff size — always stored (small metadata, not bulky text), so the PR-detail
+        // LOC label + "Changes" tab work in every mode straight from the DB. The files
+        // list is capped at 100 by the query; changedFiles keeps the true total.
+        const additions = pr.additions ?? 0;
+        const deletions = pr.deletions ?? 0;
+        const changedFiles = pr.changedFiles ?? 0;
+        const files = (pr.files?.nodes ?? []).map((f) => ({
+            path: f.path,
+            additions: f.additions ?? 0,
+            deletions: f.deletions ?? 0,
+        }));
+        // The PR's prior draft/state, read BEFORE the upsert below, so we can emit the
+        // lifecycle transitions GitHub doesn't expose as discrete events (draft → ready,
+        // reopened). null on first sight of a PR → no transition event.
+        //
+        // The board-visible columns ride the same read so the SPA's change signal
+        // (sync/pr-change-signal.ts) fires only when one of them actually MOVED — a walk that
+        // restates what is stored must not cascade a refetch over every screen.
+        const prev = (await tx
+            .select({
+            isDraft: pullRequests.isDraft,
+            state: pullRequests.state,
+            headSha: pullRequests.headSha,
+            ciStatus: pullRequests.ciStatus,
+            mergeable: pullRequests.mergeable,
+            mergeStateStatus: pullRequests.mergeStateStatus,
+            reviewDecision: pullRequests.reviewDecision,
+            inMergeQueue: pullRequests.inMergeQueue,
+            mergeQueueEntryState: pullRequests.mergeQueueEntryState,
+            updatedAt: pullRequests.updatedAt,
+        })
+            .from(pullRequests)
+            .where(and(eq(pullRequests.accountId, accountId), eq(pullRequests.githubNodeId, pr.id)))
+            .execute())[0] ?? null;
+        boardMoved = boardVisibleMoved(prev, {
+            state: prState(pr.state),
+            isDraft: pr.isDraft,
+            headSha,
+            ciStatus,
+            mergeable,
+            mergeStateStatus,
+            reviewDecision,
+            updatedAt: new Date(pr.updatedAt),
+            ...queueObserved,
+        });
+        const prRow = (await tx
+            .insert(pullRequests)
+            .values({
+            accountId,
+            githubNodeId: pr.id,
+            repoId,
+            number: pr.number,
+            title: pr.title,
+            // Lean mode (cloud): the PR description and the per-job checkRuns JSON are
+            // not stored — hydrated on demand. ciStatus (the summary enum) is kept.
+            body: config.persistBodies ? (pr.body ?? null) : null,
+            authorId,
+            mergedById,
+            baseRefName: pr.baseRefName ?? null,
+            headRefName: pr.headRefName ?? null,
+            state: prState(pr.state),
+            isDraft: pr.isDraft,
+            openedAt,
+            firstReviewAt,
+            firstReviewRequestedAt,
+            lastCommitAt,
+            mergedAt,
+            closedAt,
+            updatedAt: new Date(pr.updatedAt),
+            headSha,
+            ciStatus,
+            mergeable,
+            mergeStateStatus,
+            reviewDecision,
+            // Spread, never assigned: an omitted key leaves the column at its NULL default on
+            // INSERT and untouched on UPDATE, which is exactly what "we did not receive that
+            // selection" means. Same shape as branch-status.ts's `observed`.
+            ...queueObserved,
+            labels,
+            ...securityObserved,
+            checkRuns: config.persistBodies ? checkRuns : null,
+            additions,
+            deletions,
+            changedFiles,
+            files,
+        })
+            .onConflictDoUpdate({
+            target: [pullRequests.accountId, pullRequests.githubNodeId],
+            set: {
+                title: pr.title,
+                body: config.persistBodies ? (pr.body ?? null) : null,
+                authorId,
+                mergedById,
+                baseRefName: pr.baseRefName ?? null,
+                headRefName: pr.headRefName ?? null,
+                state: prState(pr.state),
+                isDraft: pr.isDraft,
+                firstReviewAt,
+                firstReviewRequestedAt,
+                lastCommitAt,
+                mergedAt,
+                closedAt,
+                updatedAt: new Date(pr.updatedAt),
+                headSha,
+                ciStatus,
+                mergeable,
+                mergeStateStatus,
+                reviewDecision,
+                ...queueObserved,
+                labels,
+                ...securityObserved,
+                checkRuns: config.persistBodies ? checkRuns : null,
+                additions,
+                deletions,
+                changedFiles,
+                files,
+            },
+        })
+            .returning({ id: pullRequests.id })
+            .execute())[0];
+        const prId = prRow.id;
+        // ---- cross-team search index rows (accumulated, written once at the end) ----
+        // `bodyText` (plain-text description) is fetched unconditionally, so the PR row indexes the
+        // description even under lean storage where pullRequests.body is null. Review / comment rows are
+        // pushed at their insert sites below. The whole set is rebuilt per-PR (delete + insert) so an
+        // edited/removed comment never leaves a stale hit.
+        const searchRows = [];
+        searchRows.push({
+            kind: 'pr',
+            refId: prId,
+            threadId: null,
+            authorId,
+            body: searchText(pr.title, pr.bodyText),
+            createdAt: openedAt,
+        });
+        // ---- CI status transition log (DORA-ish CI metrics) ----
+        // Record a row whenever this PR head's CI rollup / failing-check set / head SHA
+        // differs from the last snapshot — an append-only transition log (not a per-tick
+        // dump). Uses the fresh GraphQL checkRuns (populated even in lean mode, unlike the
+        // stored column), so the failing check NAMES are the stage-level failure reasons.
+        if (headSha != null && ciStatus !== 'unknown') {
+            const failing = [
+                ...new Set(checkRuns
+                    .filter((c) => c.state === 'failure' || c.state === 'error')
+                    .map((c) => c.name)),
+            ].sort();
+            const lastCi = (await tx
+                .select({
+                status: ciStatusEvents.status,
+                headSha: ciStatusEvents.headSha,
+                failingChecks: ciStatusEvents.failingChecks,
+            })
+                .from(ciStatusEvents)
+                .where(and(eq(ciStatusEvents.accountId, accountId), eq(ciStatusEvents.prId, prId)))
+                .orderBy(desc(ciStatusEvents.observedAt))
+                .limit(1)
+                .execute())[0];
+            const changed = lastCi == null ||
+                lastCi.status !== ciStatus ||
+                lastCi.headSha !== headSha ||
+                JSON.stringify([...(lastCi.failingChecks ?? [])].sort()) !== JSON.stringify(failing);
+            if (changed) {
+                await tx
+                    .insert(ciStatusEvents)
+                    .values({
+                    accountId,
+                    repoId,
+                    prId,
+                    headSha,
+                    status: ciStatus,
+                    failingChecks: failing,
+                    observedAt: new Date(),
+                })
+                    .execute();
+            }
+        }
+        // ---- review requests (outstanding) — reconcile by delete + reinsert ----
+        await tx.delete(reviewRequests).where(eq(reviewRequests.prId, prId)).execute();
+        for (const rr of pr.reviewRequests?.nodes ?? []) {
+            const reviewer = rr.requestedReviewer;
+            if (!reviewer)
+                continue;
+            if (reviewer.__typename === 'User') {
+                const userId = await resolver.resolve(tx, {
+                    login: reviewer.login,
+                    id: reviewer.id,
+                });
+                await tx.insert(reviewRequests).values({ prId, userId, teamName: null }).execute();
+            }
+            else if (reviewer.__typename === 'Team') {
+                await tx
+                    .insert(reviewRequests)
+                    .values({ prId, userId: null, teamName: reviewer.name })
+                    .execute();
+            }
+        }
+        // ---- review-request HISTORY (Chronology's "asked to first look") ----
+        await persistReviewRequestHistory(tx, prId, pr.reviewRequestHistory?.nodes, resolver);
+        // ---- lifecycle events ----
+        await upsertEvent(tx, {
+            accountId,
+            repoId,
+            actorId: authorId,
+            prId,
+            type: 'pr_opened',
+            occurredAt: openedAt,
+            refTable: 'pull_requests',
+            refId: prId,
+            dedupeKey: `pr_opened:${pr.id}`,
+        });
+        if (pr.state === 'MERGED' && mergedAt) {
+            await upsertEvent(tx, {
+                accountId,
+                repoId,
+                actorId: authorId,
+                prId,
+                type: 'pr_merged',
+                occurredAt: mergedAt,
+                refTable: 'pull_requests',
+                refId: prId,
+                dedupeKey: `pr_merged:${pr.id}`,
+            });
+        }
+        else if (pr.state === 'CLOSED' && closedAt) {
+            await upsertEvent(tx, {
+                accountId,
+                repoId,
+                actorId: authorId,
+                prId,
+                type: 'pr_closed',
+                occurredAt: closedAt,
+                refTable: 'pull_requests',
+                refId: prId,
+                dedupeKey: `pr_closed:${pr.id}`,
+            });
+        }
+        // Transitions GitHub gives no discrete event for (draft→ready, reopened): emitted
+        // only when THIS sync observed the flip (`prev` is the pre-upsert row), so a PR
+        // first seen already ready/open emits nothing. dedupeKey is keyed on the PR (one
+        // ready / one reopened per PR) — re-toggling re-emits at most once. occurredAt =
+        // updatedAt is the closest available signal (GitHub gives no ready-at/reopened-at).
+        for (const type of lifecycleTransitions(prev, {
+            isDraft: pr.isDraft,
+            state: prState(pr.state),
+        })) {
+            await upsertEvent(tx, {
+                accountId,
+                repoId,
+                actorId: authorId,
+                prId,
+                type,
+                occurredAt: new Date(pr.updatedAt),
+                refTable: 'pull_requests',
+                refId: prId,
+                dedupeKey: `${type}:${pr.id}`,
+            });
+        }
+        // ---- reviews ----
+        for (const r of pr.reviews.nodes) {
+            const reviewerId = await resolver.resolve(tx, r.author);
+            const submittedAt = toDate(r.submittedAt);
+            if (!submittedAt)
+                continue; // pending reviews have no timestamp
+            const reviewRow = (await tx
+                .insert(reviews)
+                .values({
+                githubNodeId: r.id,
+                prId,
+                authorId: reviewerId,
+                state: reviewState(r.state),
+                // Review bodies are always persisted (Feed renders them; also drives
+                // substantive-review detection) regardless of lean storage.
+                body: r.body ?? null,
+                databaseId: r.fullDatabaseId ?? null,
+                submittedAt,
+            })
+                .onConflictDoUpdate({
+                target: [reviews.prId, reviews.githubNodeId],
+                set: {
+                    state: reviewState(r.state),
+                    body: r.body ?? null,
+                    databaseId: r.fullDatabaseId ?? null,
+                    submittedAt,
+                },
+            })
+                .returning({ id: reviews.id })
+                .execute())[0];
+            const reviewBody = searchText(r.body);
+            if (reviewBody)
+                searchRows.push({
+                    kind: 'review',
+                    refId: reviewRow.id,
+                    threadId: null,
+                    authorId: reviewerId,
+                    body: reviewBody,
+                    createdAt: submittedAt,
+                });
+            if (isSubstantiveReview(reviewState(r.state), r.body)) {
+                await upsertEvent(tx, {
+                    accountId,
+                    repoId,
+                    actorId: reviewerId,
+                    prId,
+                    type: 'review_submitted',
+                    occurredAt: submittedAt,
+                    refTable: 'reviews',
+                    refId: reviewRow.id,
+                    dedupeKey: `review_submitted:${r.id}`,
+                });
+            }
+        }
+        // ---- review threads + comments ----
+        const commitInputs = pr.commits.nodes.map((c) => ({
+            oid: c.commit.oid,
+            committedDate: c.commit.committedDate,
+        }));
+        // Prior resolved-state per thread (this PR) so we can stamp resolvedAt on a WITNESSED
+        // unresolved→resolved flip only. A thread already resolved the first time we see it keeps a
+        // null resolvedAt (its true resolution time is unknown). Read once, before the upserts.
+        const priorThreads = new Map();
+        for (const row of await tx
+            .select({
+            nodeId: reviewThreads.githubNodeId,
+            isResolved: reviewThreads.isResolved,
+            resolvedAt: reviewThreads.resolvedAt,
+        })
+            .from(reviewThreads)
+            .where(eq(reviewThreads.prId, prId))
+            .execute())
+            priorThreads.set(row.nodeId, { isResolved: row.isResolved, resolvedAt: row.resolvedAt });
+        const observedAt = new Date();
+        for (const t of pr.reviewThreads.nodes) {
+            const commentNodes = t.comments.nodes;
+            const originalCommenterId = await resolver.resolve(tx, commentNodes[0]?.author);
+            const resolvedByLogin = t.resolvedBy?.login ?? null;
+            // Preserve a prior stamp; set it fresh only when we observe unresolved→resolved this sync.
+            const resolvedAt = nextResolvedAt(priorThreads.get(t.id), t.isResolved, observedAt);
+            const { state: derivedState, addressedConfidence, addressedReason } = deriveThreadState({
+                isResolved: t.isResolved,
+                path: t.path,
+                isOutdated: t.isOutdated,
+                resolvedByLogin,
+                comments: commentNodes.map((c) => ({
+                    author: c.author ? { login: c.author.login } : null,
+                    createdAt: c.createdAt,
+                    body: c.body ?? null,
+                })),
+            }, commitInputs, commitFilesBySha);
+            const threadRow = (await tx
+                .insert(reviewThreads)
+                .values({
+                githubNodeId: t.id,
+                prId,
+                path: t.path,
+                line: t.line,
+                isResolved: t.isResolved,
+                isOutdated: t.isOutdated,
+                derivedState,
+                addressedConfidence,
+                addressedReason,
+                resolvedByLogin,
+                resolvedAt,
+                originalCommenterId,
+                createdAt: commentNodes[0]
+                    ? new Date(commentNodes[0].createdAt)
+                    : new Date(pr.createdAt),
+            })
+                .onConflictDoUpdate({
+                target: [reviewThreads.prId, reviewThreads.githubNodeId],
+                set: {
+                    isResolved: t.isResolved,
+                    isOutdated: t.isOutdated,
+                    derivedState,
+                    addressedConfidence,
+                    addressedReason,
+                    resolvedByLogin,
+                    resolvedAt,
+                    line: t.line,
+                },
+            })
+                .returning({ id: reviewThreads.id })
+                .execute())[0];
+            for (const c of commentNodes) {
+                const commenterId = await resolver.resolve(tx, c.author);
+                const createdAt = new Date(c.createdAt);
+                const rcRow = (await tx
+                    .insert(reviewComments)
+                    .values({
+                    githubNodeId: c.id,
+                    threadId: threadRow.id,
+                    prId,
+                    authorId: commenterId,
+                    // Review-comment bodies are always persisted (Feed renders them); only
+                    // the large diff hunk stays lean-gated. Excerpt kept for triage.
+                    body: c.body,
+                    excerpt: excerptOf(c.body),
+                    diffHunk: config.persistBodies ? (c.diffHunk ?? null) : null,
+                    databaseId: c.fullDatabaseId ?? null,
+                    createdAt,
+                })
+                    .onConflictDoUpdate({
+                    target: [reviewComments.prId, reviewComments.githubNodeId],
+                    set: {
+                        body: c.body,
+                        excerpt: excerptOf(c.body),
+                        diffHunk: config.persistBodies ? (c.diffHunk ?? null) : null,
+                        databaseId: c.fullDatabaseId ?? null,
+                    },
+                })
+                    .returning({ id: reviewComments.id })
+                    .execute())[0];
+                const rcBody = searchText(c.body);
+                if (rcBody)
+                    searchRows.push({
+                        kind: 'review_comment',
+                        refId: rcRow.id,
+                        // Deep-link target: a review-comment hit opens the PR's Threads tab on this thread.
+                        threadId: threadRow.id,
+                        authorId: commenterId,
+                        body: rcBody,
+                        createdAt,
+                    });
+                await upsertEvent(tx, {
+                    accountId,
+                    repoId,
+                    actorId: commenterId,
+                    prId,
+                    type: 'review_comment',
+                    occurredAt: createdAt,
+                    // Point at the thread for in-app navigation.
+                    refTable: 'review_threads',
+                    refId: threadRow.id,
+                    dedupeKey: `review_comment:${c.id}`,
+                });
+            }
+        }
+        // ---- general PR comments ----
+        for (const c of pr.comments.nodes) {
+            const commenterId = await resolver.resolve(tx, c.author);
+            const createdAt = new Date(c.createdAt);
+            const commentRow = (await tx
+                .insert(prComments)
+                .values({
+                githubNodeId: c.id,
+                prId,
+                authorId: commenterId,
+                // PR-comment bodies are always persisted (Feed renders them).
+                body: c.body ?? null,
+                databaseId: c.fullDatabaseId ?? null,
+                createdAt,
+            })
+                .onConflictDoUpdate({
+                target: [prComments.prId, prComments.githubNodeId],
+                set: {
+                    body: c.body ?? null,
+                    databaseId: c.fullDatabaseId ?? null,
+                },
+            })
+                .returning({ id: prComments.id })
+                .execute())[0];
+            const pcBody = searchText(c.body);
+            if (pcBody)
+                searchRows.push({
+                    kind: 'pr_comment',
+                    refId: commentRow.id,
+                    threadId: null,
+                    authorId: commenterId,
+                    body: pcBody,
+                    createdAt,
+                });
+            await upsertEvent(tx, {
+                accountId,
+                repoId,
+                actorId: commenterId,
+                prId,
+                type: 'pr_comment',
+                occurredAt: createdAt,
+                refTable: 'pr_comments',
+                refId: commentRow.id,
+                dedupeKey: `pr_comment:${c.id}`,
+            });
+        }
+        // ---- commits ----
+        for (const node of pr.commits.nodes) {
+            const c = node.commit;
+            const commitAuthorId = await resolver.resolve(tx, c.author?.user
+                ? { login: c.author.user.login, id: c.author.user.id }
+                : null);
+            const committerId = await resolver.resolve(tx, c.committer?.user
+                ? { login: c.committer.user.login, id: c.committer.user.id }
+                : null);
+            const committedAt = new Date(c.committedDate);
+            // The subject line, written ONLY when GitHub sent the key (a tolerant partial or an old
+            // fixture omits it) — spreading `{}` leaves a stored headline alone instead of clearing it.
+            const headline = c.messageHeadline === undefined
+                ? {}
+                : { messageHeadline: c.messageHeadline == null ? null : c.messageHeadline.slice(0, 200) };
+            // Upsert (not DoNothing) so we always get the row id back to point the
+            // timeline event at — the marker modal resolves the commit via ref_id.
+            const commitRow = (await tx
+                .insert(commits)
+                .values({
+                sha: c.oid,
+                prId,
+                authorId: commitAuthorId,
+                committerId,
+                message: config.persistBodies ? c.message : null,
+                ...headline,
+                committedAt,
+            })
+                .onConflictDoUpdate({
+                target: [commits.sha, commits.prId],
+                set: { message: config.persistBodies ? c.message : null, ...headline, committedAt },
+            })
+                .returning({ id: commits.id })
+                .execute())[0];
+            await upsertEvent(tx, {
+                accountId,
+                repoId,
+                actorId: commitAuthorId ?? committerId,
+                prId,
+                type: 'commit_pushed',
+                occurredAt: committedAt,
+                refTable: 'commits',
+                refId: commitRow.id,
+                dedupeKey: `commit_pushed:${pr.id}:${c.oid}`,
+            });
+        }
+        // ---- rebuild this PR's search-index rows ----
+        // Delete-then-insert (inside the same tx) so an edited/removed comment leaves no stale hit and
+        // re-sync is idempotent. Chunked so a comment-heavy PR stays under SQLite's bound variable limit
+        // (999): ~7 columns × 100 rows = 700 < 999.
+        await tx.delete(searchIndex).where(eq(searchIndex.prId, prId)).execute();
+        for (let i = 0; i < searchRows.length; i += 100) {
+            await tx
+                .insert(searchIndex)
+                .values(searchRows.slice(i, i + 100).map((r) => ({ accountId, repoId, prId, ...r })))
+                .execute();
+        }
+    });
+    if (boardMoved)
+        notePrChanged(accountId, repoId);
+}
+/**
+ * Did this write move anything a reader can see?
+ *
+ * • A first sighting (`prev === null`) counts ONLY for an OPEN PR — a new card. A merged or
+ *   closed PR first seen by the 90-day deep backfill (hundreds of them, minutes apart) changes no
+ *   board, and counting it cascaded a whole-app refetch on every SPA poll of a backfill; the
+ *   walk's own completion stamp covers the history it brings in.
+ * • `updatedAt` MOVING counts. GitHub bumps it for every new review, comment, reply and commit —
+ *   the rows the My turn / Unanswered threads / Waiting on review tabs fold — and a webhook or
+ *   settle sync that stored them otherwise raised nothing. It stays DIFF-GATED: a walk restating
+ *   an unchanged PR (the overlap window) carries the same `updatedAt`. What it cannot see is an
+ *   updatedAt-SILENT change (a thread resolve, CI finishing, mergeability computed) — the explicit
+ *   columns cover the last two.
+ * • The merge-queue pair is compared ONLY when this response observed it (the three-state
+ *   `queueObserved` rule: an absent key wrote nothing, so it cannot have moved).
+ * Exported for its unit test.
+ */
+export function boardVisibleMoved(prev, next) {
+    if (prev == null)
+        return next.state === 'open';
+    if (next.updatedAt !== undefined &&
+        (prev.updatedAt == null || prev.updatedAt.getTime() !== next.updatedAt.getTime())) {
+        return true;
+    }
+    if (prev.state !== next.state ||
+        prev.isDraft !== next.isDraft ||
+        prev.headSha !== next.headSha ||
+        prev.ciStatus !== next.ciStatus ||
+        prev.mergeable !== next.mergeable ||
+        prev.mergeStateStatus !== next.mergeStateStatus ||
+        prev.reviewDecision !== next.reviewDecision) {
+        return true;
+    }
+    if (next.inMergeQueue !== undefined) {
+        if (prev.inMergeQueue !== next.inMergeQueue)
+            return true;
+        if (prev.mergeQueueEntryState !== (next.mergeQueueEntryState ?? null))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=upsert.js.map