ensemble-review 1.0.35 → 1.0.37

package/dist/platform/advisor/emitters/prose.js

@@ -1,183 +0,0 @@
-import { CATEGORY_PHRASING, SEVERITY_FLOOR_PHRASING } from '../taxonomy.js';
-import { MAX_CONFIG_BYTES } from './adapter.js';
-export const MARKER_START = '<!-- limn:advisor:start -->';
-export const MARKER_END = '<!-- limn:advisor:end -->';
-export const INTENTS_HEADER_PREFIX = '<!-- limn:advisor:intents:';
-// Priority for budget drops: suppressions first (they are why the user is here), the
-// severity floor next, then escalations/amplifications, then the pair/lint advisories.
-const PRIORITY = [
-    'SUPPRESS_PATH',
-    'QUIET_PATH_NITS',
-    'SUPPRESS_CATEGORY',
-    'LOWER_VERBOSITY',
-    'ESCALATE',
-    'AMPLIFY_PATH',
-    'SCOPE_OFF',
-    'PROMOTE_TO_LINT',
-    'BOOTSTRAP_CONFIG',
-];
-export function sentenceFor(intent) {
-    switch (intent.kind) {
-        case 'SUPPRESS_PATH':
-            return `Do not review files under \`${intent.targetKey}\` — findings there consistently go unaddressed here.`;
-        case 'QUIET_PATH_NITS':
-            return `In \`${intent.targetKey}\`, do not post nitpick-level comments — raise only findings of minor severity and above there.`;
-        case 'SUPPRESS_CATEGORY': {
-            const t = intent.target;
-            const neg = t.kind === 'category' ? CATEGORY_PHRASING[t.category].negative : undefined;
-            return neg ?? `Do not raise ${intent.targetKey} findings.`;
-        }
-        case 'LOWER_VERBOSITY':
-            return SEVERITY_FLOOR_PHRASING.negative;
-        case 'ESCALATE': {
-            const t = intent.target;
-            const pos = t.kind === 'category' ? CATEGORY_PHRASING[t.category].positive : undefined;
-            return pos ?? `Prioritize ${intent.targetKey} findings.`;
-        }
-        case 'AMPLIFY_PATH':
-            return `Review files under \`${intent.targetKey}\` with extra depth — findings there are consistently acted on.`;
-        case 'SCOPE_OFF': {
-            const partner = intent.target.kind === 'partner' ? intent.target.partnerLabel : 'another reviewer';
-            return `Skip findings that ${partner} also raises (overlapping line coverage); focus where you are the only reviewer.`;
-        }
-        case 'PROMOTE_TO_LINT':
-            return `Do not flag "${intent.targetKey}" — it is being promoted to a deterministic lint rule.`;
-        case 'BOOTSTRAP_CONFIG':
-            return 'This instruction block was bootstrapped by Limn; tune the sentences above as the evidence changes.';
-    }
-}
-const headerLine = (intents) => `${INTENTS_HEADER_PREFIX} ${intents.map((i) => `${i.kind}|${i.targetKey}`).join(' ')} -->`;
-const assemble = (intents) => [
-    MARKER_START,
-    headerLine(intents),
-    '',
-    ...intents.map((i) => `- ${sentenceFor(i)}`),
-    '',
-    MARKER_END,
-].join('\n');
-// Render the managed block. `budget` is the max length of the BLOCK (the caller subtracts
-// whatever else shares the file's budget); over budget ⇒ drop lowest-priority intents one
-// at a time, deterministically.
-export function renderManagedBlock(intents, budget) {
-    const ordered = [...intents].sort((a, b) => PRIORITY.indexOf(a.kind) - PRIORITY.indexOf(b.kind) ||
-        a.targetKey.localeCompare(b.targetKey));
-    const included = [...ordered];
-    const dropped = [];
-    let block = assemble(included);
-    if (budget != null) {
-        while (included.length > 0 && block.length > budget) {
-            dropped.unshift(included.pop());
-            block = assemble(included);
-        }
-    }
-    return { block, included, dropped };
-}
-// Replace an existing managed block in `text`, or append one (blank-line separated). Never
-// touches a byte outside the markers; a malformed half-block (start without end) is a
-// refusal — overwriting it could eat user content.
-export function upsertManagedBlock(text, block) {
-    if (text == null || text.trim() === '')
-        return { ok: true, content: `${block}\n` };
-    const start = text.indexOf(MARKER_START);
-    const end = text.indexOf(MARKER_END);
-    if (start === -1 && end === -1) {
-        const sep = text.endsWith('\n') ? '\n' : '\n\n';
-        return { ok: true, content: `${text}${sep}${block}\n` };
-    }
-    if (start === -1 || end === -1 || end < start) {
-        return { ok: false, reason: 'malformed limn:advisor marker block — refusing to edit' };
-    }
-    return {
-        ok: true,
-        content: text.slice(0, start) + block + text.slice(end + MARKER_END.length),
-    };
-}
-export function extractManagedBlock(text) {
-    const start = text.indexOf(MARKER_START);
-    const end = text.indexOf(MARKER_END);
-    if (start === -1 || end === -1 || end < start)
-        return null;
-    return text.slice(start, end + MARKER_END.length);
-}
-export function genericProseAdapter(configPath, opts) {
-    const degraded = (alternative) => ({ level: 'degraded', alternative });
-    const proseNote = 'expressed as a prose instruction in the managed block';
-    return {
-        key: `prose:${configPath}`,
-        displayName: `Instructions (${configPath})`,
-        capabilities: {
-            SUPPRESS_PATH: degraded(proseNote),
-            QUIET_PATH_NITS: { level: 'expressible' },
-            SUPPRESS_CATEGORY: { level: 'expressible' },
-            LOWER_VERBOSITY: { level: 'expressible' },
-            SCOPE_OFF: degraded(proseNote),
-            AMPLIFY_PATH: { level: 'expressible' },
-            ESCALATE: { level: 'expressible' },
-            PROMOTE_TO_LINT: degraded(proseNote),
-            BOOTSTRAP_CONFIG: { level: 'expressible' },
-        },
-        configTargets: [{ path: configPath, format: 'prose' }],
-        parse(files) {
-            const file = files.find((f) => f.path === configPath);
-            const text = file?.text ?? null;
-            if (text != null && text.length > MAX_CONFIG_BYTES) {
-                return {
-                    ok: false,
-                    reason: `${configPath} exceeds ${MAX_CONFIG_BYTES} bytes — refusing to edit`,
-                    config: { text: null },
-                };
-            }
-            return { ok: true, config: { text } };
-        },
-        plan(intents, current) {
-            const items = [];
-            const render = renderManagedBlock(intents, opts?.charBudget);
-            const upserted = upsertManagedBlock(current.text, render.block);
-            if (!upserted.ok) {
-                for (const intent of intents) {
-                    items.push({
-                        intentKind: intent.kind,
-                        targetKey: intent.targetKey,
-                        status: 'unsupported',
-                        note: upserted.reason,
-                    });
-                }
-                return { items, state: { files: [], changed: false } };
-            }
-            for (const intent of render.included) {
-                items.push({ intentKind: intent.kind, targetKey: intent.targetKey, status: 'applied' });
-            }
-            for (const intent of render.dropped) {
-                items.push({
-                    intentKind: intent.kind,
-                    targetKey: intent.targetKey,
-                    status: 'unsupported',
-                    note: 'dropped: over the char budget',
-                });
-            }
-            const changed = render.included.length > 0 && upserted.content !== current.text;
-            return {
-                items,
-                state: {
-                    files: changed ? [{ path: configPath, content: upserted.content }] : [],
-                    changed,
-                },
-            };
-        },
-        serialize(plan) {
-            return plan.state.changed ? plan.state.files : [];
-        },
-        validate(files) {
-            const errors = [];
-            if (opts?.charBudget != null) {
-                for (const f of files) {
-                    if (f.content.length > opts.charBudget) {
-                        errors.push(`${f.path}: over the ${opts.charBudget}-char budget`);
-                    }
-                }
-            }
-            return { ok: errors.length === 0, errors };
-        },
-    };
-}
-//# sourceMappingURL=prose.js.map

package/dist/platform/advisor/emitters/registry.js

@@ -1,20 +0,0 @@
-import { coderabbitAdapter } from './coderabbit.js';
-import { greptileAdapter } from './greptile.js';
-import { copilotProseAdapter } from './copilot-prose.js';
-const ADAPTERS = {
-    coderabbit: coderabbitAdapter,
-    greptile: greptileAdapter,
-    copilot: copilotProseAdapter,
-};
-// `kind` is the AutomatedReviewerKind from the classifier; adapter keys deliberately match
-// the kinds they serve so a profile `kindHint` of 'known:coderabbit' round-trips.
-export function adapterForKind(kind) {
-    return ADAPTERS[kind] ?? null;
-}
-export function adapterByKey(key) {
-    return ADAPTERS[key] ?? null;
-}
-export function listAdapters() {
-    return Object.values(ADAPTERS);
-}
-//# sourceMappingURL=registry.js.map

package/dist/platform/advisor/emitters/yaml-doc.js

@@ -1,95 +0,0 @@
-// Shared eemeli `yaml` Document round-trip helpers. The Document API is the load-bearing
-// choice: comments, ordering, anchors and odd indentation SURVIVE a parse→edit→stringify
-// cycle, which is the hard requirement for editing a user's hand-written config (the
-// merge-never-regenerate rule). Every helper is additive: get-or-create a collection node,
-// append a scalar if absent — nothing rewrites what the user wrote.
-//
-// Input is REPO-AUTHORED: size-capped by the caller (MAX_CONFIG_BYTES), parsed with the CORE
-// schema only (no custom tag execution — `yaml` core tags are data-only), and a document
-// with parse errors is a refusal, never a best-effort edit.
-import { Document, isMap, isScalar, isSeq, parseDocument } from 'yaml';
-export function parseYamlConfig(text) {
-    const doc = parseDocument(text, { prettyErrors: false });
-    if (doc.errors.length > 0) {
-        return { ok: false, reason: `YAML parse error: ${doc.errors[0].message}` };
-    }
-    return { ok: true, doc };
-}
-export function emptyYamlDoc() {
-    return new Document({});
-}
-// Get-or-create the map at a dotted path (['reviews'] → the reviews map), creating plain
-// block maps along the way. Refuses (returns null) when an intermediate node exists but is
-// not a map — that is the user's structure and not ours to rewrite.
-export function ensureMapAt(doc, path) {
-    if (!doc.contents)
-        doc.contents = doc.createNode({});
-    let node = doc.contents;
-    for (const key of path) {
-        if (!isMap(node))
-            return null;
-        let next = node.get(key, true);
-        if (next == null) {
-            const created = doc.createNode({});
-            node.set(doc.createNode(key), created);
-            next = created;
-        }
-        node = next;
-    }
-    return isMap(node) ? node : null;
-}
-// Get-or-create the sequence at `key` under the map at `path`. Same refusal rule.
-export function ensureSeqAt(doc, path, key) {
-    const map = ensureMapAt(doc, path);
-    if (!map)
-        return null;
-    let seq = map.get(key, true);
-    if (seq == null) {
-        const created = doc.createNode([]);
-        map.set(doc.createNode(key), created);
-        seq = created;
-    }
-    return isSeq(seq) ? seq : null;
-}
-// Append a string scalar unless an equal scalar is already present. Returns whether the
-// value is in the sequence afterwards BECAUSE OF US (false = it was already there — a noop,
-// which the plan reports rather than double-appending on a re-run).
-export function appendUniqueString(doc, seq, value) {
-    for (const item of seq.items) {
-        if (isScalar(item) && item.value === value)
-            return false;
-    }
-    // An EMPTY flow seq (`[]` — ours from a bootstrap template, or a user's placeholder)
-    // switches to block style before the first entry: multi-entry flow renders as an unreadable
-    // one-liner, and there are no existing entries whose formatting could be disturbed.
-    if (seq.items.length === 0)
-        seq.flow = false;
-    seq.add(doc.createNode(value));
-    return true;
-}
-// Read a scalar at map path (null when absent or not a scalar).
-export function scalarAt(doc, path, key) {
-    let node = doc.contents;
-    for (const k of path) {
-        if (!isMap(node))
-            return null;
-        node = node.get(k, true);
-    }
-    if (!isMap(node))
-        return null;
-    const v = node.get(key, true);
-    return isScalar(v) && (typeof v.value === 'string' || typeof v.value === 'number')
-        ? String(v.value)
-        : null;
-}
-export function setScalar(doc, path, key, value) {
-    const map = ensureMapAt(doc, path);
-    if (!map)
-        return false;
-    map.set(doc.createNode(key), doc.createNode(value));
-    return true;
-}
-export function docToString(doc) {
-    return doc.toString();
-}
-//# sourceMappingURL=yaml-doc.js.map

package/dist/platform/advisor/evidence.js

@@ -1,79 +0,0 @@
-const pct = (num, den) => den > 0 ? Math.round((num / den) * 100) : null;
-export function evidenceFromPathCell(cell, bot, win) {
-    return {
-        windowKind: win.kind,
-        from: win.from,
-        to: win.to,
-        volume: cell.volume,
-        actedOn: cell.actedOn,
-        actedOnPct: pct(cell.actedOn, cell.volume),
-        untouched: cell.untouched,
-        untouchedPct: pct(cell.untouched, cell.volume),
-        mergedUntouched: cell.mergedUntouched,
-        overdueUntouched: cell.overdueUntouched,
-        dissent: cell.dissent,
-        actedOnHigh: cell.actedOnHigh,
-        bySeverity: cell.bySeverity,
-        samplePrIds: cell.samplePrIds,
-        pathCoveragePct: bot.pathCoveragePct,
-    };
-}
-export function evidenceFromCategoryCell(cell, bot, win) {
-    return {
-        windowKind: win.kind,
-        from: win.from,
-        to: win.to,
-        volume: cell.findings,
-        actedOn: cell.actedOn,
-        // Acted-on facts exist only for the THREAD-LINKED subset — the denominator is disclosed
-        // via `threadLinked`, never silently swapped for `findings`.
-        actedOnPct: pct(cell.actedOn, cell.threadLinked),
-        untouched: cell.untouched,
-        untouchedPct: pct(cell.untouched, cell.threadLinked),
-        mergedUntouched: cell.mergedUntouched,
-        overdueUntouched: cell.overdueUntouched,
-        dissent: cell.dissent,
-        actedOnHigh: cell.actedOnHigh,
-        bySeverity: cell.bySeverity,
-        threadLinked: cell.threadLinked,
-        samplePrIds: cell.samplePrIds,
-        pathCoveragePct: bot.pathCoveragePct,
-    };
-}
-export function evidenceFromBotTotals(bot, win) {
-    return {
-        windowKind: win.kind,
-        from: win.from,
-        to: win.to,
-        volume: bot.threads,
-        actedOn: bot.actedOn,
-        actedOnPct: pct(bot.actedOn, bot.threads),
-        untouched: bot.untouched,
-        untouchedPct: pct(bot.untouched, bot.threads),
-        mergedUntouched: bot.mergedUntouched,
-        overdueUntouched: bot.overdueUntouched,
-        dissent: bot.dissent,
-        actedOnHigh: 0,
-        samplePrIds: [],
-        pathCoveragePct: bot.pathCoveragePct,
-    };
-}
-export function evidenceFromOverlapCell(cell, bot, win) {
-    return {
-        windowKind: win.kind,
-        from: win.from,
-        to: win.to,
-        volume: cell.threads,
-        actedOn: bot.actedOn,
-        actedOnPct: pct(bot.actedOn, bot.threads),
-        untouched: bot.untouched,
-        untouchedPct: pct(bot.untouched, bot.threads),
-        mergedUntouched: bot.mergedUntouched,
-        overdueUntouched: bot.overdueUntouched,
-        dissent: bot.dissent,
-        actedOnHigh: 0,
-        samplePrIds: [],
-        pathCoveragePct: bot.pathCoveragePct,
-    };
-}
-//# sourceMappingURL=evidence.js.map

package/dist/platform/advisor/findings.js

@@ -1,15 +0,0 @@
-export function parseFindingsPayload(raw) {
-    const p = raw;
-    if (!p ||
-        typeof p !== 'object' ||
-        !Array.isArray(p.bots) ||
-        !Array.isArray(p.pathCells) ||
-        !Array.isArray(p.categoryCells) ||
-        !Array.isArray(p.overlapCells) ||
-        typeof p.window?.kind !== 'string' ||
-        typeof p.floors?.minCellThreads !== 'number') {
-        throw new Error('getAdvisorFindings returned an unrecognized payload (host/plugin contract drift?)');
-    }
-    return p;
-}
-//# sourceMappingURL=findings.js.map

package/dist/platform/advisor/intents.js

@@ -1,269 +0,0 @@
-import { evidenceFromBotTotals, evidenceFromCategoryCell, evidenceFromOverlapCell, evidenceFromPathCell, } from './evidence.js';
-import { retroFor } from './retro-check.js';
-import { CATEGORY_PHRASING } from './taxonomy.js';
-// Suppression: a (bot × path) or thread-linked (bot × category) where ≥70% went untouched —
-// the same bar as the free path suggestion (untouchedPct ≥ 70), kept in lockstep on purpose.
-export const SUPPRESS_MIN_UNTOUCHED_SHARE = 0.7;
-// The suppression VETO: a cell containing even ONE acted-on high-severity finding never
-// earns a full suppress — the team demonstrably got value there, and "4 of 5 ignored" is
-// not licence to also silence the one that mattered. Vetoed path cells fall through to the
-// nit-scoped QUIET_PATH_NITS check below instead.
-export const SUPPRESS_MAX_ACTED_HIGH = 0;
-// The MERGED-PAST gate (Alex, 2026-08-09): a suppression additionally needs at least one
-// untouched thread on a PR that has SINCE MERGED. Silence on an open PR is not final — the
-// team may still act; a merge over the bot's open thread is the team's final answer, and
-// only that earns a suppress. (Measured on erxes: 39% of merged PRs carry an untouched
-// CodeRabbit thread — the signal is real, not vestigial.)
-export const SUPPRESS_MIN_MERGED_UNTOUCHED = 1;
-// QUIET_PATH_NITS — the noise-focused path intent: keep the path, stop nit-level comments
-// there. Fires when the path's LABELLED findings are nit-dominated (the family's 0.7 bar)
-// and those nits are mostly ignored; the labelled floor reuses floors.minCellThreads (the
-// same ≥5 claim, over the labelled subset).
-export const QUIET_PATH_MIN_NIT_SHARE = 0.7;
-export const QUIET_PATH_MAX_NIT_ACTED_SHARE = 0.3;
-// Amplification: an area where ≥`floors.amplifyMinActedPct` of the bot's findings were acted
-// on AND at least this many were high-severity — evidence the bot is genuinely valuable there.
-export const AMPLIFY_MIN_ACTED_HIGH = 2;
-// Escalation (category): the thread-linked acted-on share that marks a category the team
-// consistently acts on — worth asking the bot to rank higher.
-export const ESCALATE_MIN_ACTED_SHARE = 0.7;
-export const ESCALATE_MIN_THREAD_LINKED = 5;
-// LOWER_VERBOSITY nit share (volume bar = floors.minCellFindings — core's ML_NIT pair).
-export const LOWER_VERBOSITY_MIN_NIT_SHARE = 0.7;
-// SCOPE_OFF mirrors core's overlap-suggestion pair.
-export const SCOPE_OFF_MIN_OVERLAP_SHARE = 0.4;
-// Bootstrap: an unconfigured bot only earns a config skeleton once it has real volume.
-export const BOOTSTRAP_MIN_THREADS = 10;
-// PROMOTE_TO_LINT (DeepSource title templates): a rule template must fire this often.
-export const PROMOTE_TO_LINT_MIN_FIRES = 20;
-const dedupeKeyFor = (kind, botUserId, targetKey, windowKind) => `${kind}|${botUserId}|${targetKey}|${windowKind}`;
-export function deriveIntents(payload, opts) {
-    const win = payload.window;
-    const botById = new Map(payload.bots.map((b) => [b.botUserId, b]));
-    const out = [];
-    const push = (intent) => {
-        out.push(intent);
-    };
-    const botOf = (id) => {
-        const b = botById.get(id);
-        // Cells never come from quality checks (core guarantees it), but the guard keeps the
-        // rule visible: a linter's noise is its job, and no intent may target one.
-        return b && !b.isQualityCheck ? b : undefined;
-    };
-    // ── Path cells → SUPPRESS_PATH / AMPLIFY_PATH / QUIET_PATH_NITS ───────────────────────
-    // One intent per cell, checked in subsumption order: full suppression (only when the
-    // veto passes — nothing high-severity was acted on there), then amplification, then the
-    // nit-scoped quieting. A vetoed suppression cell falls through to the quiet check; a
-    // vetoed cell that is not nit-dominated produces NOTHING, which is the honest outcome —
-    // "mostly ignored but the one acted-on finding was a big one" is not a tuning signal.
-    for (const cell of payload.pathCells) {
-        const bot = botOf(cell.botUserId);
-        if (!bot)
-            continue;
-        const untouchedShare = cell.volume > 0 ? cell.untouched / cell.volume : 0;
-        const actedShare = cell.volume > 0 ? cell.actedOn / cell.volume : 0;
-        const labelled = cell.bySeverity.nit + cell.bySeverity.minor + cell.bySeverity.major + cell.bySeverity.critical;
-        const nitShare = labelled > 0 ? cell.bySeverity.nit / labelled : 0;
-        const nitActedShare = cell.bySeverity.nit > 0 ? cell.actedOnNits / cell.bySeverity.nit : 0;
-        if (untouchedShare >= SUPPRESS_MIN_UNTOUCHED_SHARE &&
-            cell.actedOnHigh <= SUPPRESS_MAX_ACTED_HIGH &&
-            cell.mergedUntouched >= SUPPRESS_MIN_MERGED_UNTOUCHED) {
-            push({
-                kind: 'SUPPRESS_PATH',
-                botUserId: bot.botUserId,
-                botKey: bot.key,
-                botLabel: bot.label,
-                botKind: bot.kind,
-                target: { kind: 'path', pathBucket: cell.pathBucket },
-                targetKey: cell.pathBucket,
-                dedupeKey: dedupeKeyFor('SUPPRESS_PATH', bot.botUserId, cell.pathBucket, win.kind),
-                rationale: `${Math.round(untouchedShare * 100)}% of ${bot.label}'s ${cell.volume} threads in ${cell.pathBucket} went untouched (${cell.mergedUntouched} shipped in PRs that merged anyway), and nothing acted on there was high-severity — suppress this path.`,
-                evidence: evidenceFromPathCell(cell, bot, win),
-                retro: retroFor('SUPPRESS_PATH', { pathCell: cell }),
-            });
-        }
-        else if (actedShare * 100 >= payload.floors.amplifyMinActedPct &&
-            cell.actedOnHigh >= AMPLIFY_MIN_ACTED_HIGH) {
-            push({
-                kind: 'AMPLIFY_PATH',
-                botUserId: bot.botUserId,
-                botKey: bot.key,
-                botLabel: bot.label,
-                botKind: bot.kind,
-                target: { kind: 'path', pathBucket: cell.pathBucket },
-                targetKey: cell.pathBucket,
-                dedupeKey: dedupeKeyFor('AMPLIFY_PATH', bot.botUserId, cell.pathBucket, win.kind),
-                rationale: `${Math.round(actedShare * 100)}% of ${bot.label}'s ${cell.volume} threads in ${cell.pathBucket} were acted on (${cell.actedOnHigh} high-severity) — ask for deeper coverage here.`,
-                evidence: evidenceFromPathCell(cell, bot, win),
-                retro: retroFor('AMPLIFY_PATH', { pathCell: cell }),
-            });
-        }
-        else if (labelled >= payload.floors.minCellThreads &&
-            nitShare >= QUIET_PATH_MIN_NIT_SHARE &&
-            nitActedShare <= QUIET_PATH_MAX_NIT_ACTED_SHARE) {
-            push({
-                kind: 'QUIET_PATH_NITS',
-                botUserId: bot.botUserId,
-                botKey: bot.key,
-                botLabel: bot.label,
-                botKind: bot.kind,
-                target: { kind: 'path', pathBucket: cell.pathBucket },
-                targetKey: cell.pathBucket,
-                dedupeKey: dedupeKeyFor('QUIET_PATH_NITS', bot.botUserId, cell.pathBucket, win.kind),
-                rationale: `${cell.bySeverity.nit} of ${bot.label}'s ${labelled} scored findings in ${cell.pathBucket} are nits and ${cell.bySeverity.nit - cell.actedOnNits} of those went unaddressed — keep the path, stop nit-level comments there.`,
-                evidence: evidenceFromPathCell(cell, bot, win),
-                retro: retroFor('QUIET_PATH_NITS', { pathCell: cell }),
-            });
-        }
-    }
-    // ── Category cells → SUPPRESS_CATEGORY / ESCALATE ─────────────────────────────────────
-    for (const cell of payload.categoryCells) {
-        const bot = botOf(cell.botUserId);
-        if (!bot)
-            continue;
-        if (cell.category === 'praise')
-            continue; // labelled work, never a finding target
-        const phrasing = CATEGORY_PHRASING[cell.category];
-        const linkedUntouchedShare = cell.threadLinked > 0 ? cell.untouched / cell.threadLinked : 0;
-        const linkedActedShare = cell.threadLinked > 0 ? cell.actedOn / cell.threadLinked : 0;
-        if (cell.threadLinked >= payload.floors.minCellThreads &&
-            linkedUntouchedShare >= SUPPRESS_MIN_UNTOUCHED_SHARE &&
-            // The same veto + merged-past gate as SUPPRESS_PATH: an acted-on high-severity finding
-            // in the category is proof of value, and open-PR silence alone is not final.
-            cell.actedOnHigh <= SUPPRESS_MAX_ACTED_HIGH &&
-            cell.mergedUntouched >= SUPPRESS_MIN_MERGED_UNTOUCHED) {
-            push({
-                kind: 'SUPPRESS_CATEGORY',
-                botUserId: bot.botUserId,
-                botKey: bot.key,
-                botLabel: bot.label,
-                botKind: bot.kind,
-                target: { kind: 'category', category: cell.category },
-                targetKey: cell.category,
-                dedupeKey: dedupeKeyFor('SUPPRESS_CATEGORY', bot.botUserId, cell.category, win.kind),
-                rationale: `${Math.round(linkedUntouchedShare * 100)}% of ${bot.label}'s ${phrasing.label.toLowerCase()} findings went untouched (${cell.threadLinked} thread-linked of ${cell.findings}; ${cell.mergedUntouched} shipped in PRs that merged anyway) — suppress this category.`,
-                evidence: evidenceFromCategoryCell(cell, bot, win),
-                retro: retroFor('SUPPRESS_CATEGORY', { categoryCell: cell }),
-            });
-        }
-        else if (cell.threadLinked >= ESCALATE_MIN_THREAD_LINKED &&
-            linkedActedShare >= ESCALATE_MIN_ACTED_SHARE) {
-            push({
-                kind: 'ESCALATE',
-                botUserId: bot.botUserId,
-                botKey: bot.key,
-                botLabel: bot.label,
-                botKind: bot.kind,
-                target: { kind: 'category', category: cell.category },
-                targetKey: cell.category,
-                dedupeKey: dedupeKeyFor('ESCALATE', bot.botUserId, cell.category, win.kind),
-                rationale: `${Math.round(linkedActedShare * 100)}% of ${bot.label}'s ${phrasing.label.toLowerCase()} findings were acted on — ask the bot to rank this category higher.`,
-                evidence: evidenceFromCategoryCell(cell, bot, win),
-                retro: retroFor('ESCALATE', { categoryCell: cell }),
-            });
-        }
-    }
-    // ── Bot totals → LOWER_VERBOSITY / BOOTSTRAP_CONFIG ───────────────────────────────────
-    for (const bot of payload.bots) {
-        if (bot.isQualityCheck)
-            continue;
-        if (bot.mlFindings >= payload.floors.minCellFindings &&
-            bot.mlNits / bot.mlFindings >= LOWER_VERBOSITY_MIN_NIT_SHARE) {
-            push({
-                kind: 'LOWER_VERBOSITY',
-                botUserId: bot.botUserId,
-                botKey: bot.key,
-                botLabel: bot.label,
-                botKind: bot.kind,
-                target: { kind: 'severity' },
-                targetKey: 'nit',
-                dedupeKey: dedupeKeyFor('LOWER_VERBOSITY', bot.botUserId, 'nit', win.kind),
-                rationale: `${Math.round((bot.mlNits / bot.mlFindings) * 100)}% of ${bot.label}'s ${bot.mlFindings} scored findings are nits — raise its severity floor.`,
-                evidence: evidenceFromBotTotals(bot, win),
-                retro: retroFor('LOWER_VERBOSITY', { bot }),
-            });
-        }
-        if (!opts.botsWithConfigTarget.has(bot.botUserId) &&
-            bot.threads >= BOOTSTRAP_MIN_THREADS) {
-            push({
-                kind: 'BOOTSTRAP_CONFIG',
-                botUserId: bot.botUserId,
-                botKey: bot.key,
-                botLabel: bot.label,
-                botKind: bot.kind,
-                target: { kind: 'bootstrap' },
-                targetKey: 'config',
-                dedupeKey: dedupeKeyFor('BOOTSTRAP_CONFIG', bot.botUserId, 'config', win.kind),
-                rationale: `${bot.label} produced ${bot.threads} threads this window with no known configuration — bootstrap a config file so it becomes tunable.`,
-                evidence: evidenceFromBotTotals(bot, win),
-                retro: retroFor('BOOTSTRAP_CONFIG', { bot }),
-            });
-        }
-    }
-    // ── Overlap cells → SCOPE_OFF ─────────────────────────────────────────────────────────
-    // One intent per bot (its heaviest partner), not one per pair direction — the reader
-    // decides which of the two to narrow, and both bots may earn one (symmetric, like the
-    // free overlap suggestion).
-    const bestPartner = new Map();
-    for (const cell of payload.overlapCells) {
-        const cur = bestPartner.get(cell.botUserId);
-        if (!cur ||
-            cell.sharedClusters > cur.sharedClusters ||
-            (cell.sharedClusters === cur.sharedClusters && cell.partnerUserId < cur.partnerUserId))
-            bestPartner.set(cell.botUserId, cell);
-    }
-    for (const cell of bestPartner.values()) {
-        const bot = botOf(cell.botUserId);
-        if (!bot)
-            continue;
-        const share = cell.threads > 0 ? cell.overlapThreads / cell.threads : 0;
-        if (share < SCOPE_OFF_MIN_OVERLAP_SHARE)
-            continue;
-        const partner = botById.get(cell.partnerUserId);
-        const partnerLabel = partner?.label ?? `#${cell.partnerUserId}`;
-        push({
-            kind: 'SCOPE_OFF',
-            botUserId: bot.botUserId,
-            botKey: bot.key,
-            botLabel: bot.label,
-            botKind: bot.kind,
-            target: { kind: 'partner', partnerUserId: cell.partnerUserId, partnerLabel },
-            targetKey: `u${cell.partnerUserId}`,
-            dedupeKey: dedupeKeyFor('SCOPE_OFF', bot.botUserId, `u${cell.partnerUserId}`, win.kind),
-            rationale: `${cell.overlapThreads} of ${bot.label}'s ${cell.threads} threads land on lines other bots also flagged (most often ${partnerLabel}: ${cell.sharedClusters} shared cluster${cell.sharedClusters === 1 ? '' : 's'}) — narrow one of the two.`,
-            evidence: evidenceFromOverlapCell(cell, bot, win),
-            retro: retroFor('SCOPE_OFF', {}),
-        });
-    }
-    // ── T4 lint templates → PROMOTE_TO_LINT (DeepSource-only in v1; advisory text) ────────
-    for (const stat of opts.lintTemplates ?? []) {
-        if (stat.fires < PROMOTE_TO_LINT_MIN_FIRES)
-            continue;
-        const bot = botById.get(stat.botUserId);
-        if (!bot)
-            continue;
-        const actedPct = stat.fires > 0 ? Math.round((stat.actedOn / stat.fires) * 100) : 0;
-        push({
-            kind: 'PROMOTE_TO_LINT',
-            botUserId: bot.botUserId,
-            botKey: bot.key,
-            botLabel: bot.label,
-            botKind: bot.kind,
-            target: { kind: 'lint', template: stat.template },
-            targetKey: stat.template,
-            dedupeKey: dedupeKeyFor('PROMOTE_TO_LINT', bot.botUserId, stat.template, win.kind),
-            rationale: `"${stat.template}" fired ${stat.fires}× (${actedPct}% acted on) — a deterministic lint rule would catch this earlier and cheaper than a review bot.`,
-            evidence: evidenceFromBotTotals(bot, win),
-            retro: retroFor('PROMOTE_TO_LINT', { bot }),
-        });
-    }
-    // Deterministic order: worst evidence first within a bot, bots by thread volume (the
-    // payload's own order), then intent kind for stability.
-    const botOrder = new Map(payload.bots.map((b, i) => [b.botUserId, i]));
-    out.sort((a, b) => (botOrder.get(a.botUserId) ?? 0) - (botOrder.get(b.botUserId) ?? 0) ||
-        b.evidence.volume - a.evidence.volume ||
-        a.kind.localeCompare(b.kind) ||
-        a.targetKey.localeCompare(b.targetKey));
-    return out;
-}
-//# sourceMappingURL=intents.js.map