limn-review 0.1.123

package/dist/sync/reviewer-classify.js

@@ -0,0 +1,503 @@
+// WS1c — the layered reviewer classifier (CORE). Resolution order (first HARD hit wins; soft
+// signals only accumulate into the MEDIUM band):
+//
+//   1. Known vendor login (reviewBotKind)               → vendor kind.        HIGH
+//   2. githubType==='Bot' OR opt-in app attribution     → fingerprint tool ?? in_house. HIGH
+//   3. Branded/marked fingerprint                       → fingerprint tool ?? in_house. HIGH
+//   4. Behavioral score (+ service-account login promotion) → in_house.       MEDIUM (never auto-badges)
+//   otherwise                                           → human (automated:false).
+//
+// ⚠ THERE IS NO LLM LEG IN HERE ANY MORE. A fifth step used to sit under the MEDIUM band — one
+// `cheapComplete` call over 3 sample comments — behind the plugin setting `bots.aiTiebreak`. It
+// was UNREACHABLE: the setting lived in the plugin's `pro_settings`, which CORE cannot read, and
+// not one of the four `classifyReviewer` call sites ever passed the flag. It went with the setting,
+// along with the per-account login allowlist (same story), which is why this module no longer
+// imports `review/llm.js`. The `ClassificationSource` union still carries 'ai_tiebreak' for rows
+// stored by an older build. Re-adding an LLM leg here means re-tiering three `read`-bucket routes
+// (see api/plugins/rate-limit.ts) in the SAME change.
+//
+// ── IT DERIVES ONCE PER ACTOR AND WRITES THAT VERDICT TO EVERY ONE OF THE NAMED WORKSPACE ROWS ─
+// A bot is a PER-WORKSPACE object, but the SIGNALS are not: a vendor login, `users.githubType`,
+// app attribution and the branded-marker fingerprint are all properties of the ACTOR and give the
+// same answer in every workspace. Deriving per workspace would multiply the work — and the BILLED
+// Haiku tie-break — for an identical result, and would weaken the behavioural score by computing
+// it on a thin slice. So `classifyReviewer` takes the actor's TARGET WORKSPACE LIST and `persist`
+// fans one verdict out across it.
+//
+// ── IT GATES ON TWO PROVENANCE FLAGS THAT NOW SHARE ONE ROW ───────────────────────────────────
+//   `workspace_reviewers.identity_source = 'manual'` ⇒ leave kind/label alone (a human named this
+//                                                      vendor; re-deriving reverts the correction)
+//   `workspace_reviewers.source          = 'manual'` ⇒ leave automated/role/confidence/reasons
+//                                                      alone FOR THAT WORKSPACE (a human judged
+//                                                      this row; the OTHER workspaces still update)
+//
+// ⚠ THEY USED TO LIVE ON TWO TABLES, AND THAT TABLE BOUNDARY WAS THE ENFORCEMENT. It is gone: both
+// facts are columns of one `workspace_reviewers` row now, so the separation is CODE DISCIPLINE —
+// a `set:` object narrowed per half, built fresh per workspace, honouring each flag independently.
+// The failure it prevents is unchanged: gate identity on the judgement flag and a "not a bot" here
+// blanks the vendor's brand colour; gate the judgement on the identity flag and naming a vendor
+// freezes auto-detection. See §4.6 / §9.9 of the workspace contract, and the paired tests.
+//
+// ⚠ THE SHARED-`values`-OBJECT PATTERN IS GONE ON PURPOSE. One object used as both the INSERT
+// values and the ON CONFLICT `set:` is correct only while a table holds ONE grain. With judgement,
+// identity and price in a single row it would overwrite a human's vendor correction on every auto
+// pass — the exact bug the two-table split was built to kill, reintroduced inside one row.
+//
+// ⚠ Shared is no longer `import type` only here: `GENERIC_REVIEWER_LABELS` is a VALUE import.
+// That is safe now — build-release.mjs compiles the package, vendors it at release/dist/shared
+// and rewrites the specifier to a relative path (CLAUDE.md § Packaging). The big login→kind
+// tables in sync/bot-detection.ts are still hand-copied, for the drift-test reason stated there.
+import { and, eq, inArray } from 'drizzle-orm';
+import { GENERIC_REVIEWER_LABELS } from '../shared/index.js';
+import { db, schema } from '../db/client.js';
+import { automationVendorFor, matchesAutomatedLoginPattern, reviewBotKind, roleForBotLogin, } from './bot-detection.js';
+const { workspaceReviewers } = schema;
+// Fallback display labels for the vendor kinds. The frontend's BOT_VENDOR_META is the
+// source of truth for rendering; this is what lands in the persisted `label` column.
+//
+// ⚠ TWO SIBLINGS, HAND-KEPT: `BOT_VENDOR_META` (apps/frontend/src/lib/ui.ts) and the Pro
+// plugin's Slack `BOT_LABELS` (packages/pro/src/slack/report.ts). Change one branded label,
+// change all three. The three UNBRANDED kinds are no longer restated here — `labelFor` reads
+// them from `GENERIC_REVIEWER_LABELS` in shared, because those were exactly the keys the three
+// copies had drifted apart on.
+//
+// ⚠ `Record<AutomatedReviewerKind, …>` minus the three generic kinds, so a vendor added to the
+// union without a label here is a COMPILE error rather than a card rendering the raw slug
+// (`deepsource_autofix`) at a user. `labelFor` handles the generics separately because they are
+// deliberately NOT branded — they render by login.
+const VENDOR_LABELS = {
+    coderabbit: 'CodeRabbit',
+    greptile: 'Greptile',
+    copilot: 'Copilot',
+    qodo: 'Qodo',
+    sourcery: 'Sourcery',
+    bito: 'Bito',
+    ellipsis: 'Ellipsis',
+    korbit: 'Korbit',
+    baz: 'Baz',
+    graphite: 'Graphite',
+    cursor: 'Cursor',
+    devin: 'Devin',
+    entelligence: 'Entelligence',
+    deepsource: 'DeepSource',
+    github_code_quality: 'GitHub Code Quality',
+    github_advanced_security: 'GitHub Advanced Security',
+    codex: 'Codex',
+    // Quality gates, scanners and CI
+    sonarqube: 'SonarQube',
+    codecov: 'Codecov',
+    codeclimate: 'Code Climate',
+    codefactor: 'CodeFactor',
+    hound: 'Hound',
+    coveralls: 'Coveralls',
+    codacy: 'Codacy',
+    github_actions: 'GitHub Actions',
+    jit: 'Jit',
+    socket: 'Socket',
+    gitguardian: 'GitGuardian',
+    semgrep: 'Semgrep',
+    trunk: 'Trunk',
+    endor: 'Endor Labs',
+    // Dependency & version bumps
+    dependabot: 'Dependabot',
+    renovate: 'Renovate',
+    snyk: 'Snyk',
+    pyup: 'PyUp',
+    greenkeeper: 'Greenkeeper',
+    depfu: 'Depfu',
+    aikido: 'Aikido',
+    mend: 'Mend',
+    frogbot: 'Frogbot',
+    checkmarx: 'Checkmarx',
+    // Code agents — automation that writes code
+    sweep: 'Sweep',
+    codegen: 'Codegen',
+    deepsource_autofix: 'DeepSource Autofix',
+    pre_commit_ci: 'pre-commit.ci',
+    restyled: 'Restyled',
+    imgbot: 'ImgBot',
+    transifex: 'Transifex',
+    crowdin: 'Crowdin',
+    mintlify: 'Mintlify',
+    allstar: 'Allstar',
+    step_security: 'StepSecurity',
+    orbisai: 'OrbisAI',
+    // Release & merge automation
+    mergify: 'Mergify',
+    kodiak: 'Kodiak',
+    bulldozer: 'Bulldozer',
+    release_please: 'Release Please',
+    semantic_release: 'semantic-release',
+    release_drafter: 'Release Drafter',
+    changesets: 'Changesets',
+    backport: 'Backport bot',
+    // Housekeeping — process, compliance, metadata
+    cla_assistant: 'CLA Assistant',
+    google_cla: 'Google CLA',
+    meta_cla: 'Meta CLA',
+    dco: 'DCO',
+    stale_bot: 'Stale bot',
+    welcome_bot: 'Welcome bot',
+    lock_bot: 'Lock bot',
+    allcontributors: 'All Contributors',
+    semantic_pr: 'Semantic PR',
+    sizebot: 'Size bot',
+    codesandbox: 'CodeSandbox',
+    netlify: 'Netlify',
+    vercel: 'Vercel',
+    gitpod: 'Gitpod',
+};
+// What to call each role in a human-readable `reasons` line. "…is a known Dependabot dependency
+// bot" reads as a classification; the old "…is a known Dependabot review bot" read as a mistake,
+// because it was one.
+const ROLE_NOUN = {
+    review: 'review bot',
+    quality_check: 'quality check',
+    dependency: 'dependency bot',
+    code_agent: 'code agent',
+    release: 'release automation',
+    housekeeping: 'housekeeping bot',
+};
+// Exported so the query layer (db/queries.ts) labels analytics/dedup groupings from the
+// same source of truth as the persisted classification `label`.
+export function labelFor(kind) {
+    // The three unbranded kinds come from shared: 'pierre' composes the product name, and
+    // 'in_house' is "In-house / custom" rather than "In-house AI" for a reason recorded there.
+    // Both spellings used to be restated here, in the SPA and in the Slack digest, and the three
+    // had drifted.
+    if (kind === 'pierre' || kind === 'in_house' || kind === 'vendor') {
+        return GENERIC_REVIEWER_LABELS[kind];
+    }
+    return VENDOR_LABELS[kind] ?? kind;
+}
+function describeMarkers(fp) {
+    if (fp.markers.length === 0)
+        return ['matched an automated-review fingerprint'];
+    const tool = fp.tool ?? 'in-house';
+    return [`matched ${tool} fingerprint: ${fp.markers.join(', ')}`];
+}
+function behavioralVerdict(sig, allowlistMatch) {
+    // Require account-level evidence (≥3 reviews) before the behavioral band engages.
+    if (!sig || sig.reviews < 3)
+        return { medium: false, reasons: [] };
+    const reasons = [];
+    let score = 0;
+    if (sig.medianPushToReviewMins != null && sig.medianPushToReviewMins < 2) {
+        score++;
+        reasons.push('reviews land within ~2 min of a push');
+    }
+    if (sig.reviewsPerPr != null && sig.reviewsPerPr <= 1.2) {
+        score++;
+        reasons.push('~1 review per PR');
+    }
+    if (sig.replyRate != null && sig.replyRate < 0.05) {
+        score++;
+        reasons.push('almost never replies in threads');
+    }
+    if (sig.commentsPerReview != null && sig.commentsPerReview >= 3) {
+        score++;
+        reasons.push('many inline comments per review');
+    }
+    if (allowlistMatch) {
+        score++;
+        reasons.push('login matches a service-account pattern');
+    }
+    return { medium: score >= 3, reasons };
+}
+// NOTE: the old `rowToClassification(row, login)` helper is GONE and is NOT to be reinstated now
+// that one row does hold both halves. It built a `ReviewerClassification` out of one row, which
+// reads as harmless again — and is exactly how a caller starts treating a row as a single
+// undifferentiated verdict, losing the two provenance flags that make the halves independent. A
+// caller that wants both facts reads both columns and states which flag governs the one it uses;
+// the query layer does exactly that.
+// The DEFAULT role for a login nobody has classified by hand: whichever of the five automation
+// vocabularies claims it, else 'review'.
+//
+// ⚠ THE `'review'` FALLBACK IS NOT A CLAIM THAT AN UNKNOWN BOT REVIEWS — it is the historical
+// default, kept so an unrecognised vendor keeps its row in the ROI table where a user can see and
+// reclassify it. Defaulting an unknown automation to a non-review role would make it VANISH from
+// the one panel that exists to correct it. (`resolveActorLanes` makes the opposite choice for the
+// same input, and the asymmetry is deliberate: it declines to CREDIT an unknown as a reviewer,
+// which costs nothing, whereas hiding it here would cost the user the fix.)
+//
+// This is DERIVED, never carried in from the caller, and that is deliberate — see the landmine
+// on persist() below.
+export function defaultRoleFor(login) {
+    return roleForBotLogin(login) ?? 'review';
+}
+// Write ONE derived verdict to each of `workspaceIds`' rows. Returns the classification as it now
+// applies (with the derived role).
+//
+// LANDMINE 1 — ONE STATEMENT PER WORKSPACE, WITH A `set:` NARROWED PER HALF. The loop is not an
+// oversight to be batched away: an account has few workspaces, and two workspaces may legitimately
+// hold DIFFERENT provenance flags for the same actor (manual "not a bot" in one, untouched auto in
+// the next). A single batched insert carries ONE `set:` object and physically cannot express that.
+//
+// LANDMINE 2 — the gate is a READ-THEN-NARROW, not an `onConflictDoUpdate … WHERE`. drizzle
+// spells the conditional-update clause differently per dialect, and `db` is typed as
+// node-postgres, so a `setWhere` here would compile and then behave differently (or not at all)
+// on SQLite. Reading the two provenance flags first and simply not naming the columns a human
+// owns is dialect-free.
+//
+// LANDMINE 3 — `role` is DERIVED from the local quality-check list rather than round-tripped
+// through the ReviewerClassification the caller built. Anything in the `set:` OVERWRITES the
+// stored column on every auto pass, so copying a stale in-memory role would re-write migration
+// 0045's role fold from a stale default and put SonarQube straight back into the review-bot
+// metrics. Deriving keeps the write idempotent AND self-healing for a login added to the list
+// later. (The parameter is role-LESS on purpose, so a future step in the resolution order
+// physically cannot hand one in.)
+//
+// LANDMINE 4 — THE PRICE COLUMN IS NAMED NOWHERE IN THIS FILE: not in a `set:`, not as a derived
+// INSERT value, not as a seed read off a sibling workspace. Price is PER WORKSPACE, so there is no
+// sibling that could be authoritative; a row this pass creates simply has no price until someone
+// sets one, and because the column is never in the `set:`, a conflict leaves a stored price
+// untouched. `ReviewerClassification` carries no cost field either, which makes the omission
+// structural rather than a rule to remember. `setReviewerCost` is the one writer.
+//
+// LANDMINE 5 — the conflict target is the 3-COLUMN tuple
+// `workspace_reviewers_account_workspace_author`. A stale target raises "no unique or exclusion
+// constraint matching the ON CONFLICT specification" at RUNTIME, in both dialects, only when a row
+// is actually written; it type-checks perfectly.
+async function persist(accountId, workspaceIds, c, opts = {}) {
+    const now = new Date();
+    const role = defaultRoleFor(c.login);
+    for (const workspaceId of workspaceIds) {
+        const existing = (await db
+            .select({
+            source: workspaceReviewers.source,
+            identitySource: workspaceReviewers.identitySource,
+        })
+            .from(workspaceReviewers)
+            .where(and(eq(workspaceReviewers.accountId, accountId), eq(workspaceReviewers.workspaceId, workspaceId), eq(workspaceReviewers.authorUserId, c.userId)))
+            .limit(1)
+            .execute())[0];
+        const set = { updatedAt: now };
+        if (opts.only !== 'identity' && existing?.source !== 'manual') {
+            set.automated = c.automated;
+            set.role = role;
+            set.confidence = c.confidence;
+            set.source = c.source;
+            set.reasonsJson = c.reasons;
+        }
+        if (opts.only !== 'judgement' && existing?.identitySource !== 'manual') {
+            set.kind = c.kind;
+            set.label = c.label;
+        }
+        // Nothing this pass is allowed to write — emit NO statement at all rather than an UPDATE that
+        // only bumps `updated_at`, which would make a skipped row look freshly re-derived.
+        if (Object.keys(set).length === 1)
+            continue;
+        await db
+            .insert(workspaceReviewers)
+            .values({
+            accountId,
+            workspaceId,
+            authorUserId: c.userId,
+            // The INSERT carries the FULL derived verdict regardless of `only`: `automated`,
+            // `confidence` and `source` are NOT NULL, so a brand-new row needs them, and a new row has
+            // no human opinion on either half to preserve. The price column is omitted ⇒ NULL.
+            // `identity_source` is omitted too, taking its 'auto' default — on the UPDATE path it can
+            // only be 'auto' already (a 'manual' identity never reaches the kind/label branch), so
+            // writing it would be noise that also reads as if this path may set provenance.
+            automated: c.automated,
+            role,
+            confidence: c.confidence,
+            source: c.source,
+            reasonsJson: c.reasons,
+            kind: c.kind,
+            label: c.label,
+            updatedAt: now,
+        })
+            .onConflictDoUpdate({
+            target: [
+                workspaceReviewers.accountId,
+                workspaceReviewers.workspaceId,
+                workspaceReviewers.authorUserId,
+            ],
+            set,
+        })
+            .execute();
+    }
+    return { ...c, role };
+}
+// Persist the "this is an ordinary human" judgement for an actor that only ever left issue
+// comments — the population `classifyReviewer` is deliberately not run for (there are no reviews
+// to score, so every signal it could read is absent).
+//
+// It exists because THE ROW IS THE BOT OBJECT: a (workspace, actor) pair with no row cannot be
+// listed, and therefore cannot be corrected by hand either. Writing a low-confidence non-manual
+// row makes the pair visible and leaves it fully re-derivable — the moment that person submits a
+// real review, the next classification pass overwrites this.
+//
+// ⚠ TWO PROPERTIES THAT WERE EMERGENT UNDER TWO TABLES AND ARE NOW REQUIREMENTS:
+//   (a) the values object contains NO `kind`/`label` AT ALL, so a human judgement can never rename
+//       the vendor as a side effect. Under the merged row that omission is the ONLY thing stopping
+//       it — there is no longer a table boundary doing the job. (A new row therefore comes up with
+//       kind/label NULL, which is correct: a human has no vendor kind, and stamping one is a
+//       claim.) The price column is likewise absent, so a price already recorded survives.
+//   (b) it still narrows to the workspaces no human owns (`source = 'manual'`) by READING them
+//       first, not by a `setWhere` — drizzle spells that clause differently per dialect while `db`
+//       is pg-typed.
+// Because the shared values object here names ONLY judgement columns and the manual rows are
+// already filtered out, one batched statement is safe: every writable row takes identical values.
+export async function persistHumanJudgement(accountId, workspaceIds, userId, login) {
+    if (workspaceIds.length === 0)
+        return;
+    const manualRows = await db
+        .select({ workspaceId: workspaceReviewers.workspaceId })
+        .from(workspaceReviewers)
+        .where(and(eq(workspaceReviewers.accountId, accountId), eq(workspaceReviewers.authorUserId, userId), eq(workspaceReviewers.source, 'manual'), inArray(workspaceReviewers.workspaceId, workspaceIds)))
+        .execute();
+    const manual = new Set(manualRows.map((r) => r.workspaceId));
+    const writable = workspaceIds.filter((id) => !manual.has(id));
+    if (writable.length === 0)
+        return;
+    const values = {
+        automated: false,
+        role: defaultRoleFor(login),
+        confidence: 'low',
+        source: 'fingerprint',
+        reasonsJson: ['commented on PRs but has not submitted a review'],
+        updatedAt: new Date(),
+    };
+    await db
+        .insert(workspaceReviewers)
+        .values(writable.map((workspaceId) => ({ accountId, workspaceId, authorUserId: userId, ...values })))
+        .onConflictDoUpdate({
+        target: [
+            workspaceReviewers.accountId,
+            workspaceReviewers.workspaceId,
+            workspaceReviewers.authorUserId,
+        ],
+        set: values,
+    })
+        .execute();
+}
+// `workspaceIds` is the set of WORKSPACE ROWS this verdict should be written to. It is REQUIRED
+// and positional so no caller can "just classify" without saying where the answer lands: the row
+// IS the bot object, and a verdict with no row is a verdict nobody can see or correct.
+//
+// ⚠ AN EMPTY LIST IS A NO-OP WITH NO CALLER, NOT A MECHANISM. It used to be the way to write the
+// identity half alone (two statements, two tables, only the judgement gated on the list being
+// non-empty). Under one row and one per-workspace loop it writes NOTHING, so the two reset paths
+// pass a real workspace id plus `opts.only` instead — see PersistOpts.
+//
+// THERE IS NO "MANUAL OVERRIDE WINS" EARLY RETURN, and its absence is the point. A manual flag is
+// per WORKSPACE and per HALF, so the derivation always runs and `persist` declines exactly the
+// columns a human owns — which is what lets a manual "not a bot" in one workspace coexist with a
+// fresh auto verdict in the next, and a manual vendor name coexist with a re-derived judgement in
+// the same row. The value this function RETURNS is therefore the DERIVED verdict, not necessarily
+// what is stored for any given workspace; read the row back if you need that.
+export async function classifyReviewer(accountId, user, evidence, workspaceIds, opts = {}) {
+    const login = user.githubLogin;
+    const fp = evidence.fingerprint;
+    // 1. Known vendor login — an AI REVIEWER.
+    const vendor = reviewBotKind(login);
+    if (vendor) {
+        return persist(accountId, workspaceIds, {
+            userId: user.id,
+            login,
+            automated: true,
+            kind: vendor,
+            label: labelFor(vendor),
+            confidence: 'high',
+            source: 'vendor_login',
+            reasons: [`login "${login}" is a known ${labelFor(vendor)} review bot`],
+        }, opts);
+    }
+    // 1b. Known vendor login — any OTHER automation family (quality gate, dependency bot, code
+    // agent, release or housekeeping automation).
+    //
+    // ⚠ THIS STEP MUST SIT ABOVE STEP 2, and its absence is why every non-reviewer integration used
+    // to render as "In-house AI". Step 2 fires on `githubType === 'Bot'`, which is true of all of
+    // these, and assigns `fp?.tool ?? 'in_house'` — so SonarQube, Dependabot, github-actions,
+    // GitGuardian, Socket, Google CLA and Jit all landed in the bucket literally labelled with
+    // another vendor's job description (25 of 37 such rows on the dev corpus). The user could not
+    // tell them apart on the one screen that exists to classify them.
+    //
+    // The `reasons` string says what the actor DOES rather than calling it a review bot — the
+    // difference between a classification a user trusts and one they immediately correct.
+    const automation = automationVendorFor(login);
+    if (automation) {
+        return persist(accountId, workspaceIds, {
+            userId: user.id,
+            login,
+            automated: true,
+            kind: automation.kind,
+            label: labelFor(automation.kind),
+            confidence: 'high',
+            source: 'vendor_login',
+            reasons: [
+                `login "${login}" is a known ${labelFor(automation.kind)} ` +
+                    `${ROLE_NOUN[automation.role]}`,
+            ],
+        }, opts);
+    }
+    // 2. GitHub App / Bot typename, or opt-in app attribution.
+    if (user.githubType === 'Bot' || evidence.appAttributed) {
+        const kind = fp?.tool ?? 'in_house';
+        const isBotType = user.githubType === 'Bot';
+        const source = isBotType ? 'github_type' : 'app_attribution';
+        const reasons = [
+            isBotType ? 'GitHub reports this account as a Bot' : 'posted via a GitHub App',
+        ];
+        if (fp?.marked)
+            reasons.push(...describeMarkers(fp));
+        return persist(accountId, workspaceIds, {
+            userId: user.id,
+            login,
+            automated: true,
+            kind,
+            label: kind === 'in_house' ? login : labelFor(kind),
+            confidence: 'high',
+            source,
+            reasons,
+        }, opts);
+    }
+    // 3. Branded/marked fingerprint.
+    if (fp?.marked) {
+        const kind = fp.tool ?? 'in_house';
+        return persist(accountId, workspaceIds, {
+            userId: user.id,
+            login,
+            automated: true,
+            kind,
+            label: labelFor(kind),
+            confidence: 'high',
+            source: 'fingerprint',
+            reasons: describeMarkers(fp),
+        }, opts);
+    }
+    // 4. Behavioral band (MEDIUM — never auto-badges; the UI asks "confirm?"). This is the LAST
+    //    step: the opt-in Haiku tie-break that used to follow it is gone (see the file header).
+    const allowlistMatch = matchesAutomatedLoginPattern(login);
+    const beh = behavioralVerdict(evidence.behavioral, allowlistMatch);
+    if (beh.medium) {
+        return persist(accountId, workspaceIds, {
+            userId: user.id,
+            login,
+            automated: true,
+            kind: 'in_house',
+            label: allowlistMatch ? login : 'In-house / custom',
+            confidence: 'medium',
+            source: 'behavioral',
+            reasons: beh.reasons,
+        }, opts);
+    }
+    // Otherwise → human. Strong (HIGH) when we had enough behavioral evidence to look and
+    // it didn't trip; LOW when there was nothing to go on.
+    const hadEvidence = (evidence.behavioral?.reviews ?? 0) >= 3;
+    return persist(accountId, workspaceIds, {
+        userId: user.id,
+        login,
+        automated: false,
+        kind: null,
+        label: login,
+        confidence: hadEvidence ? 'high' : 'low',
+        source: evidence.behavioral ? 'behavioral' : 'fingerprint',
+        reasons: hadEvidence
+            ? ['no automation markers; reviewing behaviour looks human']
+            : ['no automated-reviewer signals'],
+    }, opts);
+}
+//# sourceMappingURL=reviewer-classify.js.map

package/dist/sync/routing-files.js

@@ -0,0 +1,97 @@
+import { and, eq, inArray, isNull } from 'drizzle-orm';
+import { getAccessToken } from '../auth/account.js';
+import { db, schema } from '../db/client.js';
+import { fetchPrFilesWithPatch } from '../github/mutations.js';
+const { pullRequests, repos } = schema;
+// Best-effort, BOUNDED backfill of `pull_requests.files` for reviewer-routing
+// candidates that predate the files column (old open PRs never re-synced). Only PRs
+// whose `files` IS NULL are fetched; the result — even `[]` on failure — is persisted
+// so the same PR isn't refetched on every insights refresh (an [] sentinel means "we
+// tried"). The sprint window's PRs already carry files from sync, so this only ever
+// touches a handful of stale orphans. Returns the resolved paths by prId.
+export async function ensureRoutingPrFiles(accountId, prIds) {
+    const out = new Map();
+    if (prIds.length === 0)
+        return out;
+    const rows = await db
+        .select({
+        id: pullRequests.id,
+        number: pullRequests.number,
+        owner: repos.owner,
+        name: repos.name,
+    })
+        .from(pullRequests)
+        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
+        .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.id, prIds), isNull(pullRequests.files)))
+        .execute();
+    if (rows.length === 0)
+        return out;
+    let token;
+    try {
+        token = await getAccessToken(accountId);
+    }
+    catch {
+        return out; // no token (e.g. offline) → leave the fallback rationale in place
+    }
+    for (const r of rows) {
+        let stored = [];
+        try {
+            const { files } = await fetchPrFilesWithPatch(token, r.owner, r.name, r.number, 100);
+            stored = files.map((f) => ({
+                path: f.filename,
+                additions: f.additions,
+                deletions: f.deletions,
+            }));
+        }
+        catch {
+            stored = []; // sentinel — persist [] so we don't refetch this PR every refresh
+        }
+        await db
+            .update(pullRequests)
+            .set({ files: stored })
+            .where(and(eq(pullRequests.id, r.id), eq(pullRequests.accountId, accountId)))
+            .execute();
+        out.set(r.id, stored.map((s) => s.path));
+    }
+    return out;
+}
+/** How many missing file lists one repo may backfill in a single sync. */
+const FILES_BACKFILL_PER_RUN = 25;
+/**
+ * Backfill `pull_requests.files` for this repo's OPEN pull requests that have none.
+ *
+ * ---- WHY THIS EXISTS SEPARATELY FROM THE SYNC ITSELF ------------------------
+ *
+ * The walk stores `files` for the pull requests it touches, but a repo carries older open ones it
+ * never revisits — and a pull request with no stored file list has NO BLAST RADIUS AT ALL:
+ * `codeLocFor` returns null, `blastSignalsFor` returns null, and every surface correctly renders
+ * nothing. Measured on a real corpus: **154 of 1,564 open pull requests, 9.8%**, showed no chip
+ * for this reason alone.
+ *
+ * ⚠ THIS IS A DIFFERENT FETCH FROM THE CHANGE-SHAPE READ, AND IT IS THE CHEAPER, MORE VALUABLE
+ * ONE. `sync/classify-change-shape.ts` reads a DIFF to refine a level that already exists; this
+ * fetches the FILE LIST so a level can exist at all. Fetching the diff for these pull requests
+ * would not help — with no `files` there is nothing for the diff to refine.
+ *
+ * Bounded exactly like its sibling: capped per run, once per pull request (the `[]`-on-failure
+ * sentinel `ensureRoutingPrFiles` already writes means a pull request GitHub will not serve is
+ * never retried), and strictly non-fatal.
+ */
+export async function backfillMissingPrFiles(accountId, repoId, log) {
+    const rows = await db
+        .select({ id: pullRequests.id })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.accountId, accountId), eq(pullRequests.repoId, repoId), eq(pullRequests.state, 'open'), 
+    // ⚠ `IS NULL` only. A row already holding `[]` is the "we tried and GitHub refused"
+    // sentinel; re-querying it every sync forever is the cost this predicate avoids.
+    isNull(pullRequests.files)))
+        .limit(FILES_BACKFILL_PER_RUN)
+        .execute();
+    if (rows.length === 0)
+        return 0;
+    const resolved = await ensureRoutingPrFiles(accountId, rows.map((r) => r.id));
+    if (resolved.size > 0)
+        log?.info(`files backfill: filled ${resolved.size} pull request(s)`);
+    return resolved.size;
+}
+//# sourceMappingURL=routing-files.js.map

package/dist/sync/scheduled-jobs.js

@@ -0,0 +1,12 @@
+const jobs = [];
+export function registerScheduledJob(cron, handler, label = 'pro-job') {
+    jobs.push({ cron, label, handler });
+}
+export function getScheduledJobs() {
+    return jobs;
+}
+// Test/reset hook — registration is process-lifetime, but tests may want a clean slate.
+export function clearScheduledJobs() {
+    jobs.length = 0;
+}
+//# sourceMappingURL=scheduled-jobs.js.map