@pipeline-builder/pipeline-data 4.3.3 → 4.3.4

package/lib/api/reporting/plugin-exposure.js

@@ -21,9 +21,20 @@
  * re-synthed since a publish — which is most of the time, and exactly the gap a
  * vulnerability report is for. Conflating them would let a report say "fixed"
  * about a pipeline still running the old image.
+ *
+ * WHO WRITES WHAT:
+ *  - the pipeline service, on a pipeline write: `replacePipelineResolution` +
+ *    `reconcilePipelineExposures(source 'declared')`;
+ *  - the pipeline service, on a deploy registration carrying a step manifest:
+ *    `reconcilePipelineExposures(source 'deployed')`;
+ *  - the plugin service, when a version becomes the latest (an org plugin's new
+ *    default; a listing's publish, yank or unyank): `refreshLatestForPlugin`;
+ *  - the nightly rescan, per rescanned version: `syncVersionExposures`, which
+ *    fans the version's findings out to every pipeline declaring or running it
+ *    (or closes them when the version came back clean).
  */
 import { randomUUID } from 'node:crypto';
-import { createLogger, errorMessage } from '@pipeline-builder/api-core';
+import { asScanFlag, createLogger, errorMessage, scanFindingKey } from '@pipeline-builder/api-core';
 import { and, eq, inArray, isNull, lte, sql } from 'drizzle-orm';
 import { schema } from '../../database/drizzle-schema.js';
 import { withTenantTx } from '../../database/tenancy.js';
@@ -75,9 +86,12 @@ export async function replacePipelineResolution(pipelineId, steps) {
         pluginName: s.pluginName,
         declaredVersion: s.declaredVersion ?? null,
         resolvedVersion: s.resolvedVersion ?? null,
+        resolvedPluginId: s.resolvedPluginId ?? null,
+        resolvedDigest: s.resolvedDigest ?? null,
         latestVersion: s.latestVersion ?? null,
         versionGap: versionGap(s.resolvedVersion, s.latestVersion),
         withinPolicy: s.withinPolicy ?? true,
+        rootOrgId: s.rootOrgId ?? null,
         computedAt: new Date(),
     }));
     return withTenantTx(async (tx) => {
@@ -98,8 +112,13 @@ export async function replacePipelineResolution(pipelineId, steps) {
  * the instance that declares the plugin, and re-resolving each of those pipelines
  * from scratch would make publishing cost O(pipelines) work — so only the two
  * columns a publish can change are touched.
+ *
+ * `owner` says whose plugin it is: a listing (`publisher` handle — every org's
+ * pipelines that declare it, so the caller must be elevated), or an org's own
+ * plugin (`orgId` — that org's pipelines only: an org plugin's name is unique
+ * only within its org, so another org's same-named plugin is a different one).
  */
-export async function refreshLatestForPlugin(pluginName, pluginPublisher, latestVersion) {
+export async function refreshLatestForPlugin(pluginName, owner, latestVersion) {
     const rows = await withTenantTx((tx) => tx.update(schema.pipelinePluginResolution)
         .set({
         latestVersion,
@@ -118,19 +137,72 @@ export async function refreshLatestForPlugin(pluginName, pluginPublisher, latest
         ELSE 'none' END`,
         computedAt: new Date(),
     })
-        .where(and(eq(schema.pipelinePluginResolution.pluginName, pluginName), pluginPublisher === null
-        ? isNull(schema.pipelinePluginResolution.pluginPublisher)
-        : eq(schema.pipelinePluginResolution.pluginPublisher, pluginPublisher), 
+        .where(and(eq(schema.pipelinePluginResolution.pluginName, pluginName), ...('publisher' in owner
+        ? [eq(schema.pipelinePluginResolution.pluginPublisher, owner.publisher)]
+        : [isNull(schema.pipelinePluginResolution.pluginPublisher), eq(schema.pipelinePluginResolution.orgId, owner.orgId)]), 
     // Only rows whose resolved version parses as semver; anything else has no
     // gap to compute and the CASE would throw on the cast.
     sql `${schema.pipelinePluginResolution.resolvedVersion} ~ '^[0-9]+\\.[0-9]+\\.[0-9]+'`))
         .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId }));
     return rows.length;
 }
+/**
+ * Whether an exposure row is LIVE: not fixed, not dismissed as a false positive,
+ * and not under an acceptance that is still in force.
+ *
+ * The ONE predicate every reader uses (the report section, needs-attention, the
+ * org's open list). Two readers that disagree about what "exposed" means produce
+ * a report whose vulnerability panel and needs-attention list contradict each
+ * other — which is how this predicate came to exist. An acceptance LAPSES at its
+ * deadline and the row is live again; one with no deadline (which
+ * `triageExposure` refuses to write) is treated as in force, as every reader
+ * already did.
+ *
+ * `alias` is the table name or alias the caller's query uses.
+ */
+export function liveExposurePredicate(now, alias = 'plugin_vuln_exposure') {
+    const col = (c) => sql.raw(`${alias}.${c}`);
+    return sql `(${col('fixed_at')} IS NULL
+    AND (${col('triage_state')} = 'open'
+         OR (${col('triage_state')} = 'accepted'
+             AND ${col('accepted_until')} IS NOT NULL AND ${col('accepted_until')} <= ${now})))`;
+}
+const keysOf = (findings) => [...new Set(findings.map(scanFindingKey))].sort();
+/** At most this many findings are stored on an exposure row. */
+const EXPOSURE_TOP_FINDINGS = 10;
+/**
+ * The exposure a version's scan state amounts to, or null when it has none.
+ *
+ * Reads the rescan's `scan_summary` (fixable Critical AND High, whether or not the
+ * gate tripped) and falls back to `scan_flag` for a version flagged before any
+ * summary was written. A summary whose digest is not the step's is IGNORED: a
+ * version rebuilt on a patched base is a different artifact, and its findings say
+ * nothing about the image the pipeline runs. Only FIXABLE findings count — an
+ * exposure is something a rebuild or an upgrade can clear.
+ */
+export function exposureFromScan(state) {
+    const summary = state.scanSummary && typeof state.scanSummary === 'object' && !Array.isArray(state.scanSummary)
+        ? state.scanSummary
+        : null;
+    const summaryDigest = typeof summary?.imageDigest === 'string' ? summary.imageDigest : null;
+    if (summary && typeof summary.criticalFixable === 'number' && typeof summary.highFixable === 'number'
+        && (summaryDigest === null || !state.imageDigest || summaryDigest === state.imageDigest)) {
+        if (summary.criticalFixable <= 0 && summary.highFixable <= 0)
+            return null;
+        const all = (Array.isArray(summary.findings) ? summary.findings : [])
+            .filter((f) => f && typeof f.id === 'string');
+        const findings = all.filter((f) => Array.isArray(f.fixedIn) && f.fixedIn.length > 0);
+        return { criticalCount: summary.criticalFixable, highCount: summary.highFixable, topFindings: findings.slice(0, EXPOSURE_TOP_FINDINGS), findingKeys: keysOf(all) };
+    }
+    const flag = state.scanFlaggedAt ? asScanFlag(state.scanFlag) : null;
+    if (!flag || (flag.gated <= 0 && flag.high <= 0))
+        return null;
+    return { criticalCount: flag.gated, highCount: flag.high, topFindings: flag.findings.slice(0, EXPOSURE_TOP_FINDINGS), findingKeys: keysOf(flag.findings) };
+}
 /**
  * Open or refresh exposures.
  *
- * Upserts on (pipeline, plugin, version, source) so a nightly rescan REFRESHES the
+ * Upserts on (pipeline, plugin, version, digest, source) so a nightly rescan REFRESHES the
  * counts rather than opening a new row every night — otherwise the report would
  * show one exposure per night of the same problem, which reads as an escalating
  * situation when nothing changed.
@@ -155,6 +227,7 @@ export async function upsertExposures(inputs, now = new Date()) {
         criticalCount: e.criticalCount,
         highCount: e.highCount,
         topFindings: e.topFindings ?? [],
+        findingKeys: e.findingKeys ?? [],
         flaggedAt: now,
         updatedAt: now,
     }));
@@ -165,13 +238,14 @@ export async function upsertExposures(inputs, now = new Date()) {
                 schema.pluginVulnExposure.pipelineId,
                 schema.pluginVulnExposure.pluginName,
                 schema.pluginVulnExposure.pluginVersion,
+                schema.pluginVulnExposure.imageDigest,
                 schema.pluginVulnExposure.source,
             ],
             set: {
                 criticalCount: sql `excluded.critical_count`,
                 highCount: sql `excluded.high_count`,
                 topFindings: sql `excluded.top_findings`,
-                imageDigest: sql `COALESCE(excluded.image_digest, ${schema.pluginVulnExposure.imageDigest})`,
+                findingKeys: sql `excluded.finding_keys`,
                 // Still exposed, so the fix marker is cleared: a row that was closed by a
                 // deploy and is flagged again is a regression, and leaving `fixed_at` set
                 // would hide it.
@@ -179,12 +253,26 @@ export async function upsertExposures(inputs, now = new Date()) {
                 // An acceptance past its deadline stops being an acceptance. That is the
                 // entire point of time-boxing it, and it is enforced HERE rather than at
                 // read time so the stored state is the truth.
+                // An acceptance covers the findings it was made over, never ones found
+                // since: a refresh carrying a finding key the acceptance did not freeze
+                // reopens the row, so the decision is made again about what is there now.
                 triageState: sql `CASE
             WHEN ${schema.pluginVulnExposure.triageState} = 'accepted'
              AND ${schema.pluginVulnExposure.acceptedUntil} IS NOT NULL
              AND ${schema.pluginVulnExposure.acceptedUntil} <= ${now}
             THEN 'open'
+            WHEN ${schema.pluginVulnExposure.triageState} = 'accepted'
+             AND NOT (excluded.finding_keys <@ ${schema.pluginVulnExposure.acceptedFindingKeys})
+            THEN 'open'
             WHEN ${schema.pluginVulnExposure.triageState} = 'fixed' THEN 'open'
+            -- A REMOVED step / pipeline back on the same version: its acceptance
+            -- returns if still in force and it covers what the version carries now.
+            WHEN ${schema.pluginVulnExposure.triageState} = 'removed'
+             AND ${schema.pluginVulnExposure.acceptedUntil} IS NOT NULL
+             AND ${schema.pluginVulnExposure.acceptedUntil} > ${now}
+             AND excluded.finding_keys <@ ${schema.pluginVulnExposure.acceptedFindingKeys}
+            THEN 'accepted'
+            WHEN ${schema.pluginVulnExposure.triageState} = 'removed' THEN 'open'
             ELSE ${schema.pluginVulnExposure.triageState} END`,
                 updatedAt: now,
             },
@@ -197,32 +285,200 @@ export async function upsertExposures(inputs, now = new Date()) {
         return 0;
     }
 }
+const liveKey = (v) => `${v.pluginName}@${v.pluginVersion}@${v.imageDigest ?? ''}`;
 /**
- * Close the exposures a pipeline has moved off.
+ * Close the exposures of one SOURCE a pipeline has moved off — `fixed` when the
+ * pipeline still uses the plugin at another version, `removed` when no live step
+ * uses the plugin at all (the triage fields stay, so a re-added step gets an
+ * unexpired acceptance back — see {@link upsertExposures}).
  *
- * Called when a deploy records a new step manifest: anything flagged for that
- * pipeline whose version is NOT in the set it now runs is fixed. Closing by
+ * Called when a deploy records a new step manifest (`deployed`) or a pipeline
+ * write re-resolves its config (`declared`): anything open for that pipeline and
+ * source whose (version, digest) is NOT in `liveVersions` is fixed. Closing by
  * absence rather than waiting for a rescan to notice is what makes "we fixed it"
  * show up in the report on the next deploy instead of the next night.
+ *
+ * Per source, because the two sides move independently: a config updated to the
+ * fixed version closes the DECLARED exposure while the old image keeps running,
+ * and its DEPLOYED exposure must stay open until the deploy lands.
  */
-export async function closeFixedExposures(pipelineId, liveVersions, now = new Date()) {
-    const live = new Set(liveVersions.map((v) => `${v.pluginName}@${v.pluginVersion}`));
+export async function closeFixedExposures(pipelineId, source, liveVersions, now = new Date(), opts = {}) {
+    const live = new Set(liveVersions.map(liveKey));
+    const livePlugins = new Set([...liveVersions, ...(opts.livePlugins ?? [])].map((v) => (typeof v === 'string' ? v : v.pluginName)));
     const open = await withTenantTx((tx) => tx.select({
         id: schema.pluginVulnExposure.id,
         pluginName: schema.pluginVulnExposure.pluginName,
         pluginVersion: schema.pluginVulnExposure.pluginVersion,
+        imageDigest: schema.pluginVulnExposure.imageDigest,
     }).from(schema.pluginVulnExposure)
-        .where(and(eq(schema.pluginVulnExposure.pipelineId, pipelineId), isNull(schema.pluginVulnExposure.fixedAt))));
-    const stale = open
-        .filter((r) => !live.has(`${r.pluginName}@${r.pluginVersion}`))
-        .map((r) => r.id);
-    if (stale.length === 0)
+        .where(and(eq(schema.pluginVulnExposure.pipelineId, pipelineId), eq(schema.pluginVulnExposure.source, source), isNull(schema.pluginVulnExposure.fixedAt))));
+    const staleRows = open.filter((r) => !live.has(liveKey(r)));
+    if (staleRows.length === 0)
         return 0;
-    const closed = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)
-        .set({ fixedAt: now, triageState: 'fixed', updatedAt: now })
-        .where(inArray(schema.pluginVulnExposure.id, stale))
+    const fixed = staleRows.filter((r) => livePlugins.has(r.pluginName)).map((r) => r.id);
+    const removed = staleRows.filter((r) => !livePlugins.has(r.pluginName)).map((r) => r.id);
+    let closed = 0;
+    for (const [ids, state] of [[fixed, 'fixed'], [removed, 'removed']]) {
+        if (ids.length === 0)
+            continue;
+        const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)
+            .set({ fixedAt: now, triageState: state, updatedAt: now })
+            .where(inArray(schema.pluginVulnExposure.id, [...ids]))
+            .returning({ id: schema.pluginVulnExposure.id }));
+        closed += rows.length;
+    }
+    return closed;
+}
+/**
+ * Close every open exposure of a pipeline (or of one source) as `removed` — the
+ * pipeline was deleted, or deregistered (its deploy is gone). The triage fields
+ * stay: a restore re-records the pipeline's resolution, and
+ * {@link upsertExposures} reopens the rows (restoring an acceptance still in
+ * force). Returns the rows closed.
+ */
+export async function closePipelineExposures(pipelineId, state, opts = {}, now = new Date()) {
+    const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)
+        .set({ fixedAt: now, triageState: state, updatedAt: now })
+        .where(and(eq(schema.pluginVulnExposure.pipelineId, pipelineId), isNull(schema.pluginVulnExposure.fixedAt), ...(opts.source ? [eq(schema.pluginVulnExposure.source, opts.source)] : [])))
         .returning({ id: schema.pluginVulnExposure.id }));
-    return closed.length;
+    return rows.length;
+}
+/**
+ * Bring one pipeline's exposures of one source in line with the steps it now
+ * declares (`declared`) or runs (`deployed`): open / refresh a row for every step
+ * whose version has open fixable findings, close the rest by absence.
+ *
+ * Never throws — exposure tracking is reporting, and a pipeline write or a deploy
+ * registration must not fail because the report table could not be written.
+ */
+export async function reconcilePipelineExposures(input, now = new Date()) {
+    const exposed = [];
+    const seen = new Set();
+    for (const step of input.steps) {
+        const counts = exposureFromScan({ ...step.scan, imageDigest: step.imageDigest ?? step.scan.imageDigest ?? null });
+        if (!counts)
+            continue;
+        const key = liveKey({ pluginName: step.pluginName, pluginVersion: step.pluginVersion, imageDigest: step.imageDigest });
+        if (seen.has(key))
+            continue; // two steps on one version are one exposure
+        seen.add(key);
+        exposed.push({
+            orgId: input.orgId,
+            pipelineId: input.pipelineId,
+            pluginPublisher: step.pluginPublisher ?? null,
+            pluginName: step.pluginName,
+            pluginVersion: step.pluginVersion,
+            imageDigest: step.imageDigest ?? null,
+            source: input.source,
+            ...counts,
+            topFindings: counts.topFindings,
+        });
+    }
+    try {
+        const opened = await upsertExposures(exposed, now);
+        // Every plugin a step still uses (clean versions too): a row for one of
+        // them closes `fixed`; a row for a plugin no step uses any more, `removed`.
+        const closed = await closeFixedExposures(input.pipelineId, input.source, exposed, now, { livePlugins: input.steps.map((s) => s.pluginName) });
+        return { opened, closed };
+    }
+    catch (err) {
+        logger.warn('Pipeline exposure reconcile failed', { pipelineId: input.pipelineId, source: input.source, error: errorMessage(err) });
+        return { opened: 0, closed: 0 };
+    }
+}
+/**
+ * Every LIVE pipeline declaring (`pipeline_plugin_resolution`) or running
+ * (`pipeline_step_manifests`) a plugin version, one entry per (pipeline, source)
+ * with the steps on it. A soft-deleted pipeline is NOT affected: counting it
+ * would put a pipeline nobody can open into a notice or a report. Reads under
+ * the CALLER's tenant scope: an org-scoped caller sees its own pipelines, the
+ * rescan (elevated) sees every org's.
+ */
+export async function pipelinesOnVersion(ref) {
+    const publisherSql = (col) => (ref.pluginPublisher === undefined
+        ? sql ``
+        : ref.pluginPublisher === null ? sql ` AND ${sql.raw(col)} IS NULL` : sql ` AND ${sql.raw(col)} = ${ref.pluginPublisher}`);
+    const digestSql = (col) => (ref.imageDigest ? sql ` AND ${sql.raw(col)} = ${ref.imageDigest}` : sql ``);
+    const orgSql = (col) => (ref.orgIds ? sql ` AND ${sql.raw(col)} = ANY(${[...ref.orgIds]})` : sql ``);
+    if (ref.orgIds && ref.orgIds.length === 0)
+        return [];
+    const result = await withTenantTx((tx) => tx.execute(sql `
+    SELECT x.org_id, x.pipeline_id, x.source, MIN(x.plugin_publisher) AS plugin_publisher, MIN(x.image_digest) AS image_digest,
+           p.pipeline_name, array_agg(DISTINCT x.step ORDER BY x.step) AS steps
+    FROM (
+      SELECT m.org_id, m.pipeline_id::text AS pipeline_id, 'deployed' AS source, m.plugin_publisher, m.image_digest,
+             m.stage_name || '/' || m.action_name AS step
+      FROM pipeline_step_manifests m
+      WHERE m.plugin_name = ${ref.pluginName} AND m.plugin_version = ${ref.pluginVersion}
+        ${publisherSql('m.plugin_publisher')}${digestSql('m.image_digest')}${orgSql('m.org_id')}
+      UNION ALL
+      SELECT r.org_id, r.pipeline_id, 'declared' AS source, r.plugin_publisher, r.resolved_digest AS image_digest,
+             CASE WHEN r.stage_name = 'synth' AND r.step_name = 'synth' THEN 'synth' ELSE r.stage_name || '/' || r.step_name END AS step
+      FROM pipeline_plugin_resolution r
+      WHERE r.plugin_name = ${ref.pluginName} AND r.resolved_version = ${ref.pluginVersion}
+        ${publisherSql('r.plugin_publisher')}${digestSql('r.resolved_digest')}${orgSql('r.org_id')}
+    ) x
+    JOIN pipelines p ON p.id::text = x.pipeline_id AND p.deleted_at IS NULL
+    GROUP BY x.org_id, x.pipeline_id, x.source, p.pipeline_name
+    ORDER BY x.pipeline_id, x.source
+  `));
+    const rows = Array.isArray(result) ? result : (result?.rows ?? []);
+    return rows.map((r) => ({
+        orgId: String(r.org_id),
+        pipelineId: String(r.pipeline_id),
+        pipelineName: r.pipeline_name ?? null,
+        source: r.source,
+        pluginPublisher: r.plugin_publisher ?? null,
+        imageDigest: r.image_digest ?? null,
+        steps: Array.isArray(r.steps) ? r.steps : [],
+    }));
+}
+/**
+ * The rescan's entry point: one rescanned version's findings, fanned out to every
+ * pipeline that declares or runs it.
+ *
+ * A version with open fixable findings opens / refreshes one exposure per
+ * (pipeline, source); a version that came back CLEAN closes every open exposure
+ * on it (`fixed`), so a rebuild-in-place or an advisory withdrawn upstream shows
+ * as fixed on the next night rather than lingering until each pipeline redeploys.
+ *
+ * Must run with a scope that can read and write every org's rows (the rescan's
+ * elevated context). Never throws.
+ */
+export async function syncVersionExposures(ref, scan, now = new Date()) {
+    try {
+        const counts = exposureFromScan({ ...scan, imageDigest: ref.imageDigest ?? scan.imageDigest ?? null });
+        if (!counts)
+            return { opened: 0, closed: await closeVersionExposures(ref, now) };
+        const pipelines = await pipelinesOnVersion(ref);
+        const opened = await upsertExposures(pipelines.map((p) => ({
+            orgId: p.orgId,
+            pipelineId: p.pipelineId,
+            pluginPublisher: p.pluginPublisher,
+            pluginName: ref.pluginName,
+            pluginVersion: ref.pluginVersion,
+            imageDigest: ref.imageDigest ?? p.imageDigest,
+            source: p.source,
+            criticalCount: counts.criticalCount,
+            highCount: counts.highCount,
+            topFindings: counts.topFindings,
+            findingKeys: counts.findingKeys,
+        })), now);
+        return { opened, closed: 0 };
+    }
+    catch (err) {
+        logger.warn('Version exposure sync failed', { plugin: ref.pluginName, version: ref.pluginVersion, error: errorMessage(err) });
+        return { opened: 0, closed: 0 };
+    }
+}
+/** Close every open exposure on a version (optionally one image of it). */
+export async function closeVersionExposures(ref, now = new Date()) {
+    const E = schema.pluginVulnExposure;
+    const rows = await withTenantTx((tx) => tx.update(E)
+        .set({ fixedAt: now, triageState: 'fixed', updatedAt: now })
+        .where(and(eq(E.pluginName, ref.pluginName), eq(E.pluginVersion, ref.pluginVersion), isNull(E.fixedAt), ...(ref.imageDigest ? [eq(E.imageDigest, ref.imageDigest)] : []), ...(ref.pluginPublisher === undefined ? [] : [ref.pluginPublisher === null ? isNull(E.pluginPublisher) : eq(E.pluginPublisher, ref.pluginPublisher)]), ...(ref.orgIds ? [inArray(E.orgId, [...ref.orgIds])] : [])))
+        .returning({ id: E.id }));
+    return rows.length;
 }
 /**
  * The org's live exposures, for the report section.
@@ -246,11 +502,7 @@ export async function openExposures(orgId) {
         acceptedUntil: schema.pluginVulnExposure.acceptedUntil,
         flaggedAt: schema.pluginVulnExposure.flaggedAt,
     }).from(schema.pluginVulnExposure)
-        .where(and(eq(schema.pluginVulnExposure.orgId, orgId), isNull(schema.pluginVulnExposure.fixedAt), 
-    // An acceptance that has run out is not an acceptance.
-    sql `(${schema.pluginVulnExposure.triageState} <> 'accepted'
-           OR ${schema.pluginVulnExposure.acceptedUntil} IS NULL
-           OR ${schema.pluginVulnExposure.acceptedUntil} <= ${now})`))
+        .where(and(eq(schema.pluginVulnExposure.orgId, orgId), liveExposurePredicate(now)))
         .orderBy(sql `${schema.pluginVulnExposure.criticalCount} DESC, ${schema.pluginVulnExposure.highCount} DESC`));
     return rows.map((r) => ({
         pipelineId: r.pipelineId,
@@ -261,35 +513,168 @@ export async function openExposures(orgId) {
         criticalCount: r.criticalCount,
         highCount: r.highCount,
         topFindings: r.topFindings ?? [],
-        // An expired acceptance reads as open, which is what it is.
-        triageState: r.triageState === 'accepted' && r.acceptedUntil ? 'open' : r.triageState,
+        // Only acceptances NOT in force pass the live predicate, so an `accepted`
+        // row here is an expired one, and reads as what it is: open.
+        triageState: r.triageState === 'accepted' ? 'open' : r.triageState,
         flaggedAt: r.flaggedAt,
     }));
 }
+const E = () => schema.pluginVulnExposure;
+function toPipelineExposure(r, now) {
+    const until = r.acceptedUntil ?? null;
+    const active = r.triageState === 'accepted' && r.fixedAt == null && until !== null && until.getTime() > now.getTime();
+    return {
+        id: r.id,
+        orgId: r.orgId,
+        pipelineId: r.pipelineId,
+        pluginPublisher: r.pluginPublisher ?? null,
+        pluginName: r.pluginName,
+        pluginVersion: r.pluginVersion,
+        imageDigest: r.imageDigest ?? null,
+        source: r.source,
+        criticalCount: r.criticalCount,
+        highCount: r.highCount,
+        topFindings: r.topFindings ?? [],
+        findingKeys: r.findingKeys ?? [],
+        triageState: r.triageState === 'accepted' && !active && r.fixedAt == null ? 'open' : r.triageState,
+        acceptanceActive: active,
+        acceptedUntil: until,
+        acceptedFindingKeys: r.acceptedFindingKeys ?? [],
+        acceptedKev: r.acceptedKev === true,
+        triageReason: r.triageReason ?? null,
+        triagedBy: r.triagedBy ?? null,
+        triagedAt: r.triagedAt ?? null,
+        flaggedAt: r.flaggedAt,
+        fixedAt: r.fixedAt ?? null,
+    };
+}
+/**
+ * One pipeline's exposures: the unfixed ones (open, accepted, false positive),
+ * plus the fixed ones when asked — most severe first. Reads under the CALLER's
+ * scope, narrowed to `orgId`.
+ */
+export async function pipelineExposures(orgId, pipelineId, opts = {}) {
+    const now = opts.now ?? new Date();
+    const rows = await withTenantTx((tx) => tx.select().from(E())
+        .where(and(eq(E().orgId, orgId), eq(E().pipelineId, pipelineId), ...(opts.includeFixed ? [] : [isNull(E().fixedAt)])))
+        .orderBy(sql `${E().criticalCount} DESC, ${E().highCount} DESC, ${E().pluginName}`));
+    return rows.map((r) => toPipelineExposure(r, now));
+}
+/** One exposure row of `orgId`, or null. */
+export async function exposureById(orgId, id, now = new Date()) {
+    const rows = await withTenantTx((tx) => tx.select().from(E()).where(and(eq(E().id, id), eq(E().orgId, orgId))));
+    const row = rows[0];
+    return row ? toPipelineExposure(row, now) : null;
+}
 /**
- * Record a triage decision.
+ * Record a triage decision on one exposure — and on its SIBLINGS: the same
+ * pipeline's other open row for the same version and image (the declared and
+ * the deployed side). A risk decision is about what the pipeline runs, and
+ * leaving one side open would have the report and the lookup disagree.
  *
  * `accepted` REQUIRES a deadline and a reason. A permanent, unexplained mute is
  * how a finding stops being anybody's problem, and there is no good reason to
  * support it — the caller gets an error rather than a silently unbounded
- * acceptance.
+ * acceptance. The accepted finding keys are FROZEN at the decision: an
+ * acceptance covers what was there when it was made, never a finding since.
+ *
+ * Returns the updated rows (empty when `id` is not `orgId`'s unfixed exposure).
  */
 export async function triageExposure(orgId, id, decision) {
     if (decision.state === 'accepted' && (!decision.acceptedUntil || !decision.reason?.trim())) {
         throw new Error('Accepting a vulnerability exposure needs a reason and an expiry date');
     }
-    const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)
+    const now = new Date();
+    const target = await exposureById(orgId, id, now);
+    if (!target || target.fixedAt)
+        return [];
+    const rows = await withTenantTx((tx) => tx.update(E())
         .set({
         triageState: decision.state,
         acceptedUntil: decision.state === 'accepted' ? (decision.acceptedUntil ?? null) : null,
-        triageReason: decision.reason ?? null,
+        acceptedFindingKeys: decision.state === 'accepted' ? sql `${E().findingKeys}` : [],
+        acceptedKev: decision.state === 'accepted' && decision.kev === true,
+        triageReason: decision.reason?.trim() || null,
         triagedBy: decision.actor,
-        triagedAt: new Date(),
-        updatedAt: new Date(),
+        triagedAt: now,
+        updatedAt: now,
     })
-        .where(and(eq(schema.pluginVulnExposure.id, id), eq(schema.pluginVulnExposure.orgId, orgId)))
-        .returning({ id: schema.pluginVulnExposure.id }));
-    return rows.length > 0;
+        .where(and(eq(E().orgId, orgId), eq(E().pipelineId, target.pipelineId), eq(E().pluginName, target.pluginName), eq(E().pluginVersion, target.pluginVersion), target.imageDigest === null ? isNull(E().imageDigest) : eq(E().imageDigest, target.imageDigest), isNull(E().fixedAt)))
+        .returning());
+    return rows.map((r) => toPipelineExposure(r, now));
+}
+/** `name@version@digest` — the key {@link activeAcceptances} answers under. */
+export const acceptanceKey = (pluginName, pluginVersion, imageDigest) => `${pluginName}@${pluginVersion}@${imageDigest ?? ''}`;
+/**
+ * The acceptances IN FORCE for one pipeline (`accepted`, unfixed, deadline in the
+ * future), merged per version and image: the union of the finding keys the rows
+ * froze, KEV only when every merged row accepted it. Reads under the caller's
+ * scope narrowed to `orgId`; a failed read is "no acceptance" — the stricter answer.
+ */
+export async function activeAcceptances(orgId, pipelineId, now = new Date()) {
+    const out = { byKey: new Map(), versionsByPlugin: new Map() };
+    try {
+        const rows = await withTenantTx((tx) => tx.select({
+            id: E().id,
+            pluginName: E().pluginName,
+            pluginVersion: E().pluginVersion,
+            imageDigest: E().imageDigest,
+            acceptedUntil: E().acceptedUntil,
+            acceptedFindingKeys: E().acceptedFindingKeys,
+            acceptedKev: E().acceptedKev,
+        }).from(E())
+            .where(and(eq(E().orgId, orgId), eq(E().pipelineId, pipelineId), eq(E().triageState, 'accepted'), isNull(E().fixedAt), sql `${E().acceptedUntil} > ${now}`)));
+        for (const r of rows) {
+            const key = acceptanceKey(r.pluginName, r.pluginVersion, r.imageDigest);
+            const prev = out.byKey.get(key);
+            out.byKey.set(key, prev
+                ? {
+                    findingKeys: [...new Set([...prev.findingKeys, ...(r.acceptedFindingKeys ?? [])])],
+                    kev: prev.kev && r.acceptedKev,
+                    acceptedUntil: prev.acceptedUntil && new Date(prev.acceptedUntil) < r.acceptedUntil ? prev.acceptedUntil : r.acceptedUntil,
+                    exposureIds: [...prev.exposureIds, r.id],
+                }
+                : { findingKeys: r.acceptedFindingKeys ?? [], kev: r.acceptedKev, acceptedUntil: r.acceptedUntil, exposureIds: [r.id] });
+            const versions = out.versionsByPlugin.get(r.pluginName) ?? new Set();
+            versions.add(r.pluginVersion);
+            out.versionsByPlugin.set(r.pluginName, versions);
+        }
+    }
+    catch (err) {
+        logger.warn('Pipeline acceptances unreadable; treating as none', { pipelineId, error: errorMessage(err) });
+    }
+    return out;
+}
+/**
+ * Reopen every acceptance whose deadline has passed, and return them so the
+ * pipeline owners can be told (N33). Readers already treat such a row as open;
+ * writing it makes the stored state the truth and gives the notice exactly one
+ * moment to fire. Must run with a scope that can write every org's rows (the
+ * nightly rescan's elevated context). Never throws.
+ */
+export async function reopenLapsedAcceptances(now = new Date()) {
+    try {
+        const rows = await withTenantTx((tx) => tx.update(E())
+            .set({ triageState: 'open', updatedAt: now })
+            .where(and(eq(E().triageState, 'accepted'), isNull(E().fixedAt), lte(E().acceptedUntil, now)))
+            .returning({
+            id: E().id,
+            orgId: E().orgId,
+            pipelineId: E().pipelineId,
+            pluginPublisher: E().pluginPublisher,
+            pluginName: E().pluginName,
+            pluginVersion: E().pluginVersion,
+            imageDigest: E().imageDigest,
+            triagedBy: E().triagedBy,
+            triageReason: E().triageReason,
+            acceptedUntil: E().acceptedUntil,
+        }));
+        return rows;
+    }
+    catch (err) {
+        logger.warn('Lapsed acceptances not reopened', { error: errorMessage(err) });
+        return [];
+    }
 }
 /**
  * Exposures whose acceptance has lapsed, for the org's security notifications.
@@ -309,4 +694,4 @@ export async function lapsedAcceptances(orgId, now = new Date()) {
         .where(and(eq(schema.pluginVulnExposure.orgId, orgId), eq(schema.pluginVulnExposure.triageState, 'accepted'), isNull(schema.pluginVulnExposure.fixedAt), lte(schema.pluginVulnExposure.acceptedUntil, now))));
     return rows;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-exposure.js","sourceRoot":"","sources":["../../../src/api/reporting/plugin-exposure.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What plugin versions an org's pipelines are actually on, and which of those are\n * known-vulnerable.\n *\n * Two tables, written here, read by the outdated-plugin and vulnerability report\n * sections:\n *\n *  - `pipeline_plugin_resolution` — the DECLARED side. Recomputed on pipeline\n *    write and on plugin publish, because the alternative is resolving every step\n *    of every pipeline against the catalog on every read, and that is not a query\n *    anyone can afford to put in a report.\n *  - `plugin_vuln_exposure` — the VULNERABLE side, per PIPELINE. A version-level\n *    table would force every reader to re-derive \"which of our pipelines is\n *    exposed\", which is the only form of the question anybody asks.\n *\n * DECLARED IS NOT DEPLOYED, and the report says which it is showing. A pipeline's\n * config declares `^2.0.0`; what ran at its last deploy is whatever the step\n * manifest recorded, pinned to a digest. Those disagree whenever a pipeline has not\n * re-synthed since a publish — which is most of the time, and exactly the gap a\n * vulnerability report is for. Conflating them would let a report say \"fixed\"\n * about a pipeline still running the old image.\n */\n\nimport { randomUUID } from 'node:crypto';\nimport { createLogger, errorMessage } from '@pipeline-builder/api-core';\nimport { and, eq, inArray, isNull, lte, sql } from 'drizzle-orm';\nimport { schema } from '../../database/drizzle-schema.js';\nimport type { ExposureSource } from '../../database/schema/reporting-analytics.js';\nimport { withTenantTx } from '../../database/tenancy.js';\n\nconst logger = createLogger('plugin-exposure');\n\n/** How far behind a resolved version is from the newest one available. */\nexport type VersionGap = 'major' | 'minor' | 'patch' | 'none';\n\n/** One resolved step, as the writer takes it. */\nexport interface ResolvedStep {\n  orgId: string;\n  pipelineId: string;\n  stageName: string;\n  stepName: string;\n  pluginPublisher?: string | null;\n  pluginName: string;\n  declaredVersion?: string | null;\n  resolvedVersion?: string | null;\n  latestVersion?: string | null;\n  withinPolicy?: boolean;\n}\n\n/** `1.2.3` → `[1, 2, 3]`; anything unparseable → null. */\nfunction semver(v: string | null | undefined): [number, number, number] | null {\n  const m = /^v?(\\d+)\\.(\\d+)\\.(\\d+)/.exec(v ?? '');\n  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;\n}\n\n/**\n * How far `resolved` is behind `latest`.\n *\n * `null` when either side is unparseable, NOT `'none'`. \"We could not tell\" and\n * \"it is up to date\" are opposite answers, and reporting the second for the first\n * is how a pipeline on an ancient pre-release version gets a clean bill of health.\n */\nexport function versionGap(resolved: string | null | undefined, latest: string | null | undefined): VersionGap | null {\n  const a = semver(resolved);\n  const b = semver(latest);\n  if (!a || !b) return null;\n  if (b[0] > a[0]) return 'major';\n  if (b[0] < a[0]) return 'none'; // resolved is ahead of \"latest\" — not behind\n  if (b[1] > a[1]) return 'minor';\n  if (b[1] < a[1]) return 'none';\n  if (b[2] > a[2]) return 'patch';\n  return 'none';\n}\n\n/**\n * Replace a pipeline's resolution rows.\n *\n * DELETE-then-INSERT for the pipeline, in one transaction, because a step can be\n * REMOVED from a config: an upsert-only writer would leave the deleted step's row\n * behind forever, and the outdated-plugin section would keep reporting a step the\n * pipeline no longer has.\n */\nexport async function replacePipelineResolution(\n  pipelineId: string,\n  steps: readonly ResolvedStep[],\n): Promise<number> {\n  const values = steps.map((s) => ({\n    orgId: s.orgId,\n    pipelineId: s.pipelineId,\n    stageName: s.stageName,\n    stepName: s.stepName,\n    pluginPublisher: s.pluginPublisher ?? null,\n    pluginName: s.pluginName,\n    declaredVersion: s.declaredVersion ?? null,\n    resolvedVersion: s.resolvedVersion ?? null,\n    latestVersion: s.latestVersion ?? null,\n    versionGap: versionGap(s.resolvedVersion, s.latestVersion),\n    withinPolicy: s.withinPolicy ?? true,\n    computedAt: new Date(),\n  }));\n\n  return withTenantTx(async (tx) => {\n    await tx.delete(schema.pipelinePluginResolution)\n      .where(eq(schema.pipelinePluginResolution.pipelineId, pipelineId));\n    if (values.length === 0) return 0;\n    const landed = await tx.insert(schema.pipelinePluginResolution).values(values)\n      .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId });\n    return (landed as unknown[]).length;\n  });\n}\n\n/**\n * Refresh the `latest`/gap columns for one plugin across every pipeline that uses\n * it, without re-resolving anything else.\n *\n * Called on publish. A publish changes what \"latest\" means for every pipeline in\n * the instance that declares the plugin, and re-resolving each of those pipelines\n * from scratch would make publishing cost O(pipelines) work — so only the two\n * columns a publish can change are touched.\n */\nexport async function refreshLatestForPlugin(\n  pluginName: string,\n  pluginPublisher: string | null,\n  latestVersion: string,\n): Promise<number> {\n  const rows = await withTenantTx((tx) => tx.update(schema.pipelinePluginResolution)\n    .set({\n      latestVersion,\n      // Recomputed in SQL from the row's own resolved version, so one statement\n      // covers every pipeline rather than a round trip each.\n      // `::text` on every bind of the version: Postgres otherwise deduces\n      // inconsistent types for the same parameter (varchar for the assignment,\n      // text for `split_part`) and refuses to plan the statement.\n      versionGap: sql`CASE\n        WHEN ${schema.pipelinePluginResolution.resolvedVersion} IS NULL THEN NULL\n        WHEN split_part(${latestVersion}::text, '.', 1)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'major'\n        WHEN split_part(${latestVersion}::text, '.', 1)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'none'\n        WHEN split_part(${latestVersion}::text, '.', 2)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'minor'\n        WHEN split_part(${latestVersion}::text, '.', 2)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'none'\n        WHEN split_part(${latestVersion}::text, '.', 3)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 3)::int THEN 'patch'\n        ELSE 'none' END`,\n      computedAt: new Date(),\n    })\n    .where(and(\n      eq(schema.pipelinePluginResolution.pluginName, pluginName),\n      pluginPublisher === null\n        ? isNull(schema.pipelinePluginResolution.pluginPublisher)\n        : eq(schema.pipelinePluginResolution.pluginPublisher, pluginPublisher),\n      // Only rows whose resolved version parses as semver; anything else has no\n      // gap to compute and the CASE would throw on the cast.\n      sql`${schema.pipelinePluginResolution.resolvedVersion} ~ '^[0-9]+\\\\.[0-9]+\\\\.[0-9]+'`,\n    ))\n    .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId }));\n  return (rows as unknown[]).length;\n}\n\n/** One flagged version, as the rescan reports it. */\nexport interface ExposureInput {\n  orgId: string;\n  pipelineId: string;\n  pluginPublisher?: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest?: string | null;\n  source: ExposureSource;\n  criticalCount: number;\n  highCount: number;\n  topFindings?: Array<Record<string, unknown>>;\n}\n\n/**\n * Open or refresh exposures.\n *\n * Upserts on (pipeline, plugin, version, source) so a nightly rescan REFRESHES the\n * counts rather than opening a new row every night — otherwise the report would\n * show one exposure per night of the same problem, which reads as an escalating\n * situation when nothing changed.\n *\n * A refresh deliberately does NOT reset `triage_state`: an org that accepted a\n * finding with a reason and a deadline has made a decision, and re-raising it every\n * night is how a team learns to ignore the report. It DOES clear a stale\n * acceptance, because that is what the deadline was for.\n */\nexport async function upsertExposures(inputs: readonly ExposureInput[], now = new Date()): Promise<number> {\n  if (inputs.length === 0) return 0;\n  const values = inputs.map((e) => ({\n    id: randomUUID(),\n    orgId: e.orgId,\n    pipelineId: e.pipelineId,\n    pluginPublisher: e.pluginPublisher ?? null,\n    pluginName: e.pluginName,\n    pluginVersion: e.pluginVersion,\n    imageDigest: e.imageDigest ?? null,\n    source: e.source,\n    criticalCount: e.criticalCount,\n    highCount: e.highCount,\n    topFindings: e.topFindings ?? [],\n    flaggedAt: now,\n    updatedAt: now,\n  }));\n\n  try {\n    const landed = await withTenantTx((tx) => tx.insert(schema.pluginVulnExposure).values(values)\n      .onConflictDoUpdate({\n        target: [\n          schema.pluginVulnExposure.pipelineId,\n          schema.pluginVulnExposure.pluginName,\n          schema.pluginVulnExposure.pluginVersion,\n          schema.pluginVulnExposure.source,\n        ],\n        set: {\n          criticalCount: sql`excluded.critical_count`,\n          highCount: sql`excluded.high_count`,\n          topFindings: sql`excluded.top_findings`,\n          imageDigest: sql`COALESCE(excluded.image_digest, ${schema.pluginVulnExposure.imageDigest})`,\n          // Still exposed, so the fix marker is cleared: a row that was closed by a\n          // deploy and is flagged again is a regression, and leaving `fixed_at` set\n          // would hide it.\n          fixedAt: null,\n          // An acceptance past its deadline stops being an acceptance. That is the\n          // entire point of time-boxing it, and it is enforced HERE rather than at\n          // read time so the stored state is the truth.\n          triageState: sql`CASE\n            WHEN ${schema.pluginVulnExposure.triageState} = 'accepted'\n             AND ${schema.pluginVulnExposure.acceptedUntil} IS NOT NULL\n             AND ${schema.pluginVulnExposure.acceptedUntil} <= ${now}\n            THEN 'open'\n            WHEN ${schema.pluginVulnExposure.triageState} = 'fixed' THEN 'open'\n            ELSE ${schema.pluginVulnExposure.triageState} END`,\n          updatedAt: now,\n        },\n      })\n      .returning({ id: schema.pluginVulnExposure.id }));\n    return (landed as unknown[]).length;\n  } catch (err) {\n    logger.warn('Plugin exposure upsert failed', { count: values.length, error: errorMessage(err) });\n    return 0;\n  }\n}\n\n/**\n * Close the exposures a pipeline has moved off.\n *\n * Called when a deploy records a new step manifest: anything flagged for that\n * pipeline whose version is NOT in the set it now runs is fixed. Closing by\n * absence rather than waiting for a rescan to notice is what makes \"we fixed it\"\n * show up in the report on the next deploy instead of the next night.\n */\nexport async function closeFixedExposures(\n  pipelineId: string,\n  liveVersions: ReadonlyArray<{ pluginName: string; pluginVersion: string }>,\n  now = new Date(),\n): Promise<number> {\n  const live = new Set(liveVersions.map((v) => `${v.pluginName}@${v.pluginVersion}`));\n  const open = await withTenantTx((tx) => tx.select({\n    id: schema.pluginVulnExposure.id,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.pipelineId, pipelineId),\n      isNull(schema.pluginVulnExposure.fixedAt),\n    )));\n  const stale = (open as Array<{ id: string; pluginName: string; pluginVersion: string }>)\n    .filter((r) => !live.has(`${r.pluginName}@${r.pluginVersion}`))\n    .map((r) => r.id);\n  if (stale.length === 0) return 0;\n\n  const closed = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)\n    .set({ fixedAt: now, triageState: 'fixed', updatedAt: now })\n    .where(inArray(schema.pluginVulnExposure.id, stale))\n    .returning({ id: schema.pluginVulnExposure.id }));\n  return (closed as unknown[]).length;\n}\n\n/**\n * The org's live exposures, for the report section.\n *\n * `accepted` rows whose deadline has passed come back as OPEN even if no rescan\n * has refreshed them yet: a read must not present an expired acceptance as a\n * current one, and the report is read far more often than the rescan runs.\n */\nexport async function openExposures(orgId: string): Promise<Array<{\n  pipelineId: string;\n  pluginName: string;\n  pluginVersion: string;\n  pluginPublisher: string | null;\n  source: ExposureSource;\n  criticalCount: number;\n  highCount: number;\n  topFindings: Array<Record<string, unknown>>;\n  triageState: string;\n  flaggedAt: Date;\n}>> {\n  const now = new Date();\n  const rows = await withTenantTx((tx) => tx.select({\n    pipelineId: schema.pluginVulnExposure.pipelineId,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n    pluginPublisher: schema.pluginVulnExposure.pluginPublisher,\n    source: schema.pluginVulnExposure.source,\n    criticalCount: schema.pluginVulnExposure.criticalCount,\n    highCount: schema.pluginVulnExposure.highCount,\n    topFindings: schema.pluginVulnExposure.topFindings,\n    triageState: schema.pluginVulnExposure.triageState,\n    acceptedUntil: schema.pluginVulnExposure.acceptedUntil,\n    flaggedAt: schema.pluginVulnExposure.flaggedAt,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.orgId, orgId),\n      isNull(schema.pluginVulnExposure.fixedAt),\n      // An acceptance that has run out is not an acceptance.\n      sql`(${schema.pluginVulnExposure.triageState} <> 'accepted'\n           OR ${schema.pluginVulnExposure.acceptedUntil} IS NULL\n           OR ${schema.pluginVulnExposure.acceptedUntil} <= ${now})`,\n    ))\n    .orderBy(sql`${schema.pluginVulnExposure.criticalCount} DESC, ${schema.pluginVulnExposure.highCount} DESC`));\n\n  return (rows as Array<Record<string, unknown>>).map((r) => ({\n    pipelineId: r.pipelineId as string,\n    pluginName: r.pluginName as string,\n    pluginVersion: r.pluginVersion as string,\n    pluginPublisher: (r.pluginPublisher as string | null) ?? null,\n    source: r.source as ExposureSource,\n    criticalCount: r.criticalCount as number,\n    highCount: r.highCount as number,\n    topFindings: (r.topFindings as Array<Record<string, unknown>>) ?? [],\n    // An expired acceptance reads as open, which is what it is.\n    triageState: r.triageState === 'accepted' && r.acceptedUntil ? 'open' : (r.triageState as string),\n    flaggedAt: r.flaggedAt as Date,\n  }));\n}\n\n/**\n * Record a triage decision.\n *\n * `accepted` REQUIRES a deadline and a reason. A permanent, unexplained mute is\n * how a finding stops being anybody's problem, and there is no good reason to\n * support it — the caller gets an error rather than a silently unbounded\n * acceptance.\n */\nexport async function triageExposure(\n  orgId: string,\n  id: string,\n  decision: { state: 'open' | 'accepted' | 'false_positive'; reason?: string; acceptedUntil?: Date; actor: string },\n): Promise<boolean> {\n  if (decision.state === 'accepted' && (!decision.acceptedUntil || !decision.reason?.trim())) {\n    throw new Error('Accepting a vulnerability exposure needs a reason and an expiry date');\n  }\n  const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)\n    .set({\n      triageState: decision.state,\n      acceptedUntil: decision.state === 'accepted' ? (decision.acceptedUntil ?? null) : null,\n      triageReason: decision.reason ?? null,\n      triagedBy: decision.actor,\n      triagedAt: new Date(),\n      updatedAt: new Date(),\n    })\n    .where(and(\n      eq(schema.pluginVulnExposure.id, id),\n      eq(schema.pluginVulnExposure.orgId, orgId),\n    ))\n    .returning({ id: schema.pluginVulnExposure.id }));\n  return (rows as unknown[]).length > 0;\n}\n\n/**\n * Exposures whose acceptance has lapsed, for the org's security notifications.\n *\n * Surfaced rather than silently reopened: somebody decided to accept this until a\n * date, that date has passed, and the person who decided is the one who should\n * hear about it.\n */\nexport async function lapsedAcceptances(orgId: string, now = new Date()): Promise<Array<{\n  id: string;\n  pluginName: string;\n  pluginVersion: string;\n  triagedBy: string | null;\n  acceptedUntil: Date | null;\n}>> {\n  const rows = await withTenantTx((tx) => tx.select({\n    id: schema.pluginVulnExposure.id,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n    triagedBy: schema.pluginVulnExposure.triagedBy,\n    acceptedUntil: schema.pluginVulnExposure.acceptedUntil,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.orgId, orgId),\n      eq(schema.pluginVulnExposure.triageState, 'accepted'),\n      isNull(schema.pluginVulnExposure.fixedAt),\n      lte(schema.pluginVulnExposure.acceptedUntil, now),\n    )));\n  return rows as Array<{ id: string; pluginName: string; pluginVersion: string; triagedBy: string | null; acceptedUntil: Date | null }>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-exposure.js","sourceRoot":"","sources":["../../../src/api/reporting/plugin-exposure.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What plugin versions an org's pipelines are actually on, and which of those are\n * known-vulnerable.\n *\n * Two tables, written here, read by the outdated-plugin and vulnerability report\n * sections:\n *\n *  - `pipeline_plugin_resolution` — the DECLARED side. Recomputed on pipeline\n *    write and on plugin publish, because the alternative is resolving every step\n *    of every pipeline against the catalog on every read, and that is not a query\n *    anyone can afford to put in a report.\n *  - `plugin_vuln_exposure` — the VULNERABLE side, per PIPELINE. A version-level\n *    table would force every reader to re-derive \"which of our pipelines is\n *    exposed\", which is the only form of the question anybody asks.\n *\n * DECLARED IS NOT DEPLOYED, and the report says which it is showing. A pipeline's\n * config declares `^2.0.0`; what ran at its last deploy is whatever the step\n * manifest recorded, pinned to a digest. Those disagree whenever a pipeline has not\n * re-synthed since a publish — which is most of the time, and exactly the gap a\n * vulnerability report is for. Conflating them would let a report say \"fixed\"\n * about a pipeline still running the old image.\n *\n * WHO WRITES WHAT:\n *  - the pipeline service, on a pipeline write: `replacePipelineResolution` +\n *    `reconcilePipelineExposures(source 'declared')`;\n *  - the pipeline service, on a deploy registration carrying a step manifest:\n *    `reconcilePipelineExposures(source 'deployed')`;\n *  - the plugin service, when a version becomes the latest (an org plugin's new\n *    default; a listing's publish, yank or unyank): `refreshLatestForPlugin`;\n *  - the nightly rescan, per rescanned version: `syncVersionExposures`, which\n *    fans the version's findings out to every pipeline declaring or running it\n *    (or closes them when the version came back clean).\n */\n\nimport { randomUUID } from 'node:crypto';\nimport { asScanFlag, createLogger, errorMessage, scanFindingKey, type PluginScanFinding, type VulnAcceptance } from '@pipeline-builder/api-core';\nimport { and, eq, inArray, isNull, lte, sql, type SQL } from 'drizzle-orm';\nimport { schema } from '../../database/drizzle-schema.js';\nimport type { ExposureSource } from '../../database/schema/reporting-analytics.js';\nimport { withTenantTx } from '../../database/tenancy.js';\n\nconst logger = createLogger('plugin-exposure');\n\n/** How far behind a resolved version is from the newest one available. */\nexport type VersionGap = 'major' | 'minor' | 'patch' | 'none';\n\n/** One resolved step, as the writer takes it. */\nexport interface ResolvedStep {\n  orgId: string;\n  pipelineId: string;\n  stageName: string;\n  stepName: string;\n  pluginPublisher?: string | null;\n  pluginName: string;\n  declaredVersion?: string | null;\n  resolvedVersion?: string | null;\n  /** The resolved record: a `plugins` row id or a listing version id. */\n  resolvedPluginId?: string | null;\n  /** The image digest the resolved version is pinned to (null = image-less). */\n  resolvedDigest?: string | null;\n  latestVersion?: string | null;\n  withinPolicy?: boolean;\n  /** The root org of a team's pipeline (see the column). */\n  rootOrgId?: string | null;\n}\n\n/** `1.2.3` → `[1, 2, 3]`; anything unparseable → null. */\nfunction semver(v: string | null | undefined): [number, number, number] | null {\n  const m = /^v?(\\d+)\\.(\\d+)\\.(\\d+)/.exec(v ?? '');\n  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;\n}\n\n/**\n * How far `resolved` is behind `latest`.\n *\n * `null` when either side is unparseable, NOT `'none'`. \"We could not tell\" and\n * \"it is up to date\" are opposite answers, and reporting the second for the first\n * is how a pipeline on an ancient pre-release version gets a clean bill of health.\n */\nexport function versionGap(resolved: string | null | undefined, latest: string | null | undefined): VersionGap | null {\n  const a = semver(resolved);\n  const b = semver(latest);\n  if (!a || !b) return null;\n  if (b[0] > a[0]) return 'major';\n  if (b[0] < a[0]) return 'none'; // resolved is ahead of \"latest\" — not behind\n  if (b[1] > a[1]) return 'minor';\n  if (b[1] < a[1]) return 'none';\n  if (b[2] > a[2]) return 'patch';\n  return 'none';\n}\n\n/**\n * Replace a pipeline's resolution rows.\n *\n * DELETE-then-INSERT for the pipeline, in one transaction, because a step can be\n * REMOVED from a config: an upsert-only writer would leave the deleted step's row\n * behind forever, and the outdated-plugin section would keep reporting a step the\n * pipeline no longer has.\n */\nexport async function replacePipelineResolution(\n  pipelineId: string,\n  steps: readonly ResolvedStep[],\n): Promise<number> {\n  const values = steps.map((s) => ({\n    orgId: s.orgId,\n    pipelineId: s.pipelineId,\n    stageName: s.stageName,\n    stepName: s.stepName,\n    pluginPublisher: s.pluginPublisher ?? null,\n    pluginName: s.pluginName,\n    declaredVersion: s.declaredVersion ?? null,\n    resolvedVersion: s.resolvedVersion ?? null,\n    resolvedPluginId: s.resolvedPluginId ?? null,\n    resolvedDigest: s.resolvedDigest ?? null,\n    latestVersion: s.latestVersion ?? null,\n    versionGap: versionGap(s.resolvedVersion, s.latestVersion),\n    withinPolicy: s.withinPolicy ?? true,\n    rootOrgId: s.rootOrgId ?? null,\n    computedAt: new Date(),\n  }));\n\n  return withTenantTx(async (tx) => {\n    await tx.delete(schema.pipelinePluginResolution)\n      .where(eq(schema.pipelinePluginResolution.pipelineId, pipelineId));\n    if (values.length === 0) return 0;\n    const landed = await tx.insert(schema.pipelinePluginResolution).values(values)\n      .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId });\n    return (landed as unknown[]).length;\n  });\n}\n\n/**\n * Refresh the `latest`/gap columns for one plugin across every pipeline that uses\n * it, without re-resolving anything else.\n *\n * Called on publish. A publish changes what \"latest\" means for every pipeline in\n * the instance that declares the plugin, and re-resolving each of those pipelines\n * from scratch would make publishing cost O(pipelines) work — so only the two\n * columns a publish can change are touched.\n *\n * `owner` says whose plugin it is: a listing (`publisher` handle — every org's\n * pipelines that declare it, so the caller must be elevated), or an org's own\n * plugin (`orgId` — that org's pipelines only: an org plugin's name is unique\n * only within its org, so another org's same-named plugin is a different one).\n */\nexport async function refreshLatestForPlugin(\n  pluginName: string,\n  owner: { publisher: string } | { orgId: string },\n  latestVersion: string,\n): Promise<number> {\n  const rows = await withTenantTx((tx) => tx.update(schema.pipelinePluginResolution)\n    .set({\n      latestVersion,\n      // Recomputed in SQL from the row's own resolved version, so one statement\n      // covers every pipeline rather than a round trip each.\n      // `::text` on every bind of the version: Postgres otherwise deduces\n      // inconsistent types for the same parameter (varchar for the assignment,\n      // text for `split_part`) and refuses to plan the statement.\n      versionGap: sql`CASE\n        WHEN ${schema.pipelinePluginResolution.resolvedVersion} IS NULL THEN NULL\n        WHEN split_part(${latestVersion}::text, '.', 1)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'major'\n        WHEN split_part(${latestVersion}::text, '.', 1)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 1)::int THEN 'none'\n        WHEN split_part(${latestVersion}::text, '.', 2)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'minor'\n        WHEN split_part(${latestVersion}::text, '.', 2)::int < split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 2)::int THEN 'none'\n        WHEN split_part(${latestVersion}::text, '.', 3)::int > split_part(${schema.pipelinePluginResolution.resolvedVersion}, '.', 3)::int THEN 'patch'\n        ELSE 'none' END`,\n      computedAt: new Date(),\n    })\n    .where(and(\n      eq(schema.pipelinePluginResolution.pluginName, pluginName),\n      ...('publisher' in owner\n        ? [eq(schema.pipelinePluginResolution.pluginPublisher, owner.publisher)]\n        : [isNull(schema.pipelinePluginResolution.pluginPublisher), eq(schema.pipelinePluginResolution.orgId, owner.orgId)]),\n      // Only rows whose resolved version parses as semver; anything else has no\n      // gap to compute and the CASE would throw on the cast.\n      sql`${schema.pipelinePluginResolution.resolvedVersion} ~ '^[0-9]+\\\\.[0-9]+\\\\.[0-9]+'`,\n    ))\n    .returning({ pipelineId: schema.pipelinePluginResolution.pipelineId }));\n  return (rows as unknown[]).length;\n}\n\n/** One flagged version, as the rescan reports it. */\nexport interface ExposureInput {\n  orgId: string;\n  pipelineId: string;\n  pluginPublisher?: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest?: string | null;\n  source: ExposureSource;\n  criticalCount: number;\n  highCount: number;\n  topFindings?: Array<Record<string, unknown>>;\n  /** Every Critical/High finding key of the version (see the column). */\n  findingKeys?: string[];\n}\n\n/**\n * Whether an exposure row is LIVE: not fixed, not dismissed as a false positive,\n * and not under an acceptance that is still in force.\n *\n * The ONE predicate every reader uses (the report section, needs-attention, the\n * org's open list). Two readers that disagree about what \"exposed\" means produce\n * a report whose vulnerability panel and needs-attention list contradict each\n * other — which is how this predicate came to exist. An acceptance LAPSES at its\n * deadline and the row is live again; one with no deadline (which\n * `triageExposure` refuses to write) is treated as in force, as every reader\n * already did.\n *\n * `alias` is the table name or alias the caller's query uses.\n */\nexport function liveExposurePredicate(now: Date, alias = 'plugin_vuln_exposure'): SQL {\n  const col = (c: string) => sql.raw(`${alias}.${c}`);\n  return sql`(${col('fixed_at')} IS NULL\n    AND (${col('triage_state')} = 'open'\n         OR (${col('triage_state')} = 'accepted'\n             AND ${col('accepted_until')} IS NOT NULL AND ${col('accepted_until')} <= ${now})))`;\n}\n\n/** What a version's scan state contributes to an exposure (see {@link exposureFromScan}). */\nexport interface ScanState {\n  /** The digest the step runs. A scan summary describing another image is ignored. */\n  imageDigest?: string | null;\n  scanSummary?: unknown;\n  scanFlag?: unknown;\n  scanFlaggedAt?: Date | string | null;\n}\n\n/** The counts an exposure row carries. */\nexport interface ExposureCounts {\n  criticalCount: number;\n  highCount: number;\n  topFindings: PluginScanFinding[];\n  /** Keys of EVERY Critical/High finding itemized (fixable or not), sorted. */\n  findingKeys: string[];\n}\n\nconst keysOf = (findings: readonly PluginScanFinding[]): string[] => [...new Set(findings.map(scanFindingKey))].sort();\n\n/** At most this many findings are stored on an exposure row. */\nconst EXPOSURE_TOP_FINDINGS = 10;\n\n/**\n * The exposure a version's scan state amounts to, or null when it has none.\n *\n * Reads the rescan's `scan_summary` (fixable Critical AND High, whether or not the\n * gate tripped) and falls back to `scan_flag` for a version flagged before any\n * summary was written. A summary whose digest is not the step's is IGNORED: a\n * version rebuilt on a patched base is a different artifact, and its findings say\n * nothing about the image the pipeline runs. Only FIXABLE findings count — an\n * exposure is something a rebuild or an upgrade can clear.\n */\nexport function exposureFromScan(state: ScanState): ExposureCounts | null {\n  const summary = state.scanSummary && typeof state.scanSummary === 'object' && !Array.isArray(state.scanSummary)\n    ? state.scanSummary as Record<string, unknown>\n    : null;\n  const summaryDigest = typeof summary?.imageDigest === 'string' ? summary.imageDigest : null;\n  if (summary && typeof summary.criticalFixable === 'number' && typeof summary.highFixable === 'number'\n    && (summaryDigest === null || !state.imageDigest || summaryDigest === state.imageDigest)) {\n    if (summary.criticalFixable <= 0 && summary.highFixable <= 0) return null;\n    const all = (Array.isArray(summary.findings) ? summary.findings as PluginScanFinding[] : [])\n      .filter((f) => f && typeof f.id === 'string');\n    const findings = all.filter((f) => Array.isArray(f.fixedIn) && f.fixedIn.length > 0);\n    return { criticalCount: summary.criticalFixable, highCount: summary.highFixable, topFindings: findings.slice(0, EXPOSURE_TOP_FINDINGS), findingKeys: keysOf(all) };\n  }\n  const flag = state.scanFlaggedAt ? asScanFlag(state.scanFlag) : null;\n  if (!flag || (flag.gated <= 0 && flag.high <= 0)) return null;\n  return { criticalCount: flag.gated, highCount: flag.high, topFindings: flag.findings.slice(0, EXPOSURE_TOP_FINDINGS), findingKeys: keysOf(flag.findings) };\n}\n\n/**\n * Open or refresh exposures.\n *\n * Upserts on (pipeline, plugin, version, digest, source) so a nightly rescan REFRESHES the\n * counts rather than opening a new row every night — otherwise the report would\n * show one exposure per night of the same problem, which reads as an escalating\n * situation when nothing changed.\n *\n * A refresh deliberately does NOT reset `triage_state`: an org that accepted a\n * finding with a reason and a deadline has made a decision, and re-raising it every\n * night is how a team learns to ignore the report. It DOES clear a stale\n * acceptance, because that is what the deadline was for.\n */\nexport async function upsertExposures(inputs: readonly ExposureInput[], now = new Date()): Promise<number> {\n  if (inputs.length === 0) return 0;\n  const values = inputs.map((e) => ({\n    id: randomUUID(),\n    orgId: e.orgId,\n    pipelineId: e.pipelineId,\n    pluginPublisher: e.pluginPublisher ?? null,\n    pluginName: e.pluginName,\n    pluginVersion: e.pluginVersion,\n    imageDigest: e.imageDigest ?? null,\n    source: e.source,\n    criticalCount: e.criticalCount,\n    highCount: e.highCount,\n    topFindings: e.topFindings ?? [],\n    findingKeys: e.findingKeys ?? [],\n    flaggedAt: now,\n    updatedAt: now,\n  }));\n\n  try {\n    const landed = await withTenantTx((tx) => tx.insert(schema.pluginVulnExposure).values(values)\n      .onConflictDoUpdate({\n        target: [\n          schema.pluginVulnExposure.pipelineId,\n          schema.pluginVulnExposure.pluginName,\n          schema.pluginVulnExposure.pluginVersion,\n          schema.pluginVulnExposure.imageDigest,\n          schema.pluginVulnExposure.source,\n        ],\n        set: {\n          criticalCount: sql`excluded.critical_count`,\n          highCount: sql`excluded.high_count`,\n          topFindings: sql`excluded.top_findings`,\n          findingKeys: sql`excluded.finding_keys`,\n          // Still exposed, so the fix marker is cleared: a row that was closed by a\n          // deploy and is flagged again is a regression, and leaving `fixed_at` set\n          // would hide it.\n          fixedAt: null,\n          // An acceptance past its deadline stops being an acceptance. That is the\n          // entire point of time-boxing it, and it is enforced HERE rather than at\n          // read time so the stored state is the truth.\n          // An acceptance covers the findings it was made over, never ones found\n          // since: a refresh carrying a finding key the acceptance did not freeze\n          // reopens the row, so the decision is made again about what is there now.\n          triageState: sql`CASE\n            WHEN ${schema.pluginVulnExposure.triageState} = 'accepted'\n             AND ${schema.pluginVulnExposure.acceptedUntil} IS NOT NULL\n             AND ${schema.pluginVulnExposure.acceptedUntil} <= ${now}\n            THEN 'open'\n            WHEN ${schema.pluginVulnExposure.triageState} = 'accepted'\n             AND NOT (excluded.finding_keys <@ ${schema.pluginVulnExposure.acceptedFindingKeys})\n            THEN 'open'\n            WHEN ${schema.pluginVulnExposure.triageState} = 'fixed' THEN 'open'\n            -- A REMOVED step / pipeline back on the same version: its acceptance\n            -- returns if still in force and it covers what the version carries now.\n            WHEN ${schema.pluginVulnExposure.triageState} = 'removed'\n             AND ${schema.pluginVulnExposure.acceptedUntil} IS NOT NULL\n             AND ${schema.pluginVulnExposure.acceptedUntil} > ${now}\n             AND excluded.finding_keys <@ ${schema.pluginVulnExposure.acceptedFindingKeys}\n            THEN 'accepted'\n            WHEN ${schema.pluginVulnExposure.triageState} = 'removed' THEN 'open'\n            ELSE ${schema.pluginVulnExposure.triageState} END`,\n          updatedAt: now,\n        },\n      })\n      .returning({ id: schema.pluginVulnExposure.id }));\n    return (landed as unknown[]).length;\n  } catch (err) {\n    logger.warn('Plugin exposure upsert failed', { count: values.length, error: errorMessage(err) });\n    return 0;\n  }\n}\n\n/** One version a pipeline still declares / runs WITH open findings. */\nexport interface LiveVersion {\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest?: string | null;\n}\n\nconst liveKey = (v: LiveVersion): string => `${v.pluginName}@${v.pluginVersion}@${v.imageDigest ?? ''}`;\n\n/**\n * Close the exposures of one SOURCE a pipeline has moved off — `fixed` when the\n * pipeline still uses the plugin at another version, `removed` when no live step\n * uses the plugin at all (the triage fields stay, so a re-added step gets an\n * unexpired acceptance back — see {@link upsertExposures}).\n *\n * Called when a deploy records a new step manifest (`deployed`) or a pipeline\n * write re-resolves its config (`declared`): anything open for that pipeline and\n * source whose (version, digest) is NOT in `liveVersions` is fixed. Closing by\n * absence rather than waiting for a rescan to notice is what makes \"we fixed it\"\n * show up in the report on the next deploy instead of the next night.\n *\n * Per source, because the two sides move independently: a config updated to the\n * fixed version closes the DECLARED exposure while the old image keeps running,\n * and its DEPLOYED exposure must stay open until the deploy lands.\n */\nexport async function closeFixedExposures(\n  pipelineId: string,\n  source: ExposureSource,\n  liveVersions: readonly LiveVersion[],\n  now = new Date(),\n  opts: { livePlugins?: readonly string[] } = {},\n): Promise<number> {\n  const live = new Set(liveVersions.map(liveKey));\n  const livePlugins = new Set([...liveVersions, ...(opts.livePlugins ?? [])].map((v) => (typeof v === 'string' ? v : v.pluginName)));\n  const open = await withTenantTx((tx) => tx.select({\n    id: schema.pluginVulnExposure.id,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n    imageDigest: schema.pluginVulnExposure.imageDigest,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.pipelineId, pipelineId),\n      eq(schema.pluginVulnExposure.source, source),\n      isNull(schema.pluginVulnExposure.fixedAt),\n    )));\n  const staleRows = (open as Array<LiveVersion & { id: string }>).filter((r) => !live.has(liveKey(r)));\n  if (staleRows.length === 0) return 0;\n  const fixed = staleRows.filter((r) => livePlugins.has(r.pluginName)).map((r) => r.id);\n  const removed = staleRows.filter((r) => !livePlugins.has(r.pluginName)).map((r) => r.id);\n  let closed = 0;\n  for (const [ids, state] of [[fixed, 'fixed'], [removed, 'removed']] as const) {\n    if (ids.length === 0) continue;\n    const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)\n      .set({ fixedAt: now, triageState: state, updatedAt: now })\n      .where(inArray(schema.pluginVulnExposure.id, [...ids]))\n      .returning({ id: schema.pluginVulnExposure.id }));\n    closed += (rows as unknown[]).length;\n  }\n  return closed;\n}\n\n/**\n * Close every open exposure of a pipeline (or of one source) as `removed` — the\n * pipeline was deleted, or deregistered (its deploy is gone). The triage fields\n * stay: a restore re-records the pipeline's resolution, and\n * {@link upsertExposures} reopens the rows (restoring an acceptance still in\n * force). Returns the rows closed.\n */\nexport async function closePipelineExposures(\n  pipelineId: string,\n  state: 'removed',\n  opts: { source?: ExposureSource } = {},\n  now = new Date(),\n): Promise<number> {\n  const rows = await withTenantTx((tx) => tx.update(schema.pluginVulnExposure)\n    .set({ fixedAt: now, triageState: state, updatedAt: now })\n    .where(and(\n      eq(schema.pluginVulnExposure.pipelineId, pipelineId),\n      isNull(schema.pluginVulnExposure.fixedAt),\n      ...(opts.source ? [eq(schema.pluginVulnExposure.source, opts.source)] : []),\n    ))\n    .returning({ id: schema.pluginVulnExposure.id }));\n  return (rows as unknown[]).length;\n}\n\n/** One step of a pipeline as {@link reconcilePipelineExposures} takes it. */\nexport interface ExposureStep {\n  pluginPublisher?: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest?: string | null;\n  /** The resolved version's scan state, as stored on its row. */\n  scan: ScanState;\n}\n\n/**\n * Bring one pipeline's exposures of one source in line with the steps it now\n * declares (`declared`) or runs (`deployed`): open / refresh a row for every step\n * whose version has open fixable findings, close the rest by absence.\n *\n * Never throws — exposure tracking is reporting, and a pipeline write or a deploy\n * registration must not fail because the report table could not be written.\n */\nexport async function reconcilePipelineExposures(\n  input: { orgId: string; pipelineId: string; source: ExposureSource; steps: readonly ExposureStep[] },\n  now = new Date(),\n): Promise<{ opened: number; closed: number }> {\n  const exposed: ExposureInput[] = [];\n  const seen = new Set<string>();\n  for (const step of input.steps) {\n    const counts = exposureFromScan({ ...step.scan, imageDigest: step.imageDigest ?? step.scan.imageDigest ?? null });\n    if (!counts) continue;\n    const key = liveKey({ pluginName: step.pluginName, pluginVersion: step.pluginVersion, imageDigest: step.imageDigest });\n    if (seen.has(key)) continue; // two steps on one version are one exposure\n    seen.add(key);\n    exposed.push({\n      orgId: input.orgId,\n      pipelineId: input.pipelineId,\n      pluginPublisher: step.pluginPublisher ?? null,\n      pluginName: step.pluginName,\n      pluginVersion: step.pluginVersion,\n      imageDigest: step.imageDigest ?? null,\n      source: input.source,\n      ...counts,\n      topFindings: counts.topFindings as unknown as Array<Record<string, unknown>>,\n    });\n  }\n  try {\n    const opened = await upsertExposures(exposed, now);\n    // Every plugin a step still uses (clean versions too): a row for one of\n    // them closes `fixed`; a row for a plugin no step uses any more, `removed`.\n    const closed = await closeFixedExposures(input.pipelineId, input.source, exposed, now, { livePlugins: input.steps.map((s) => s.pluginName) });\n    return { opened, closed };\n  } catch (err) {\n    logger.warn('Pipeline exposure reconcile failed', { pipelineId: input.pipelineId, source: input.source, error: errorMessage(err) });\n    return { opened: 0, closed: 0 };\n  }\n}\n\n/** A plugin version (optionally one image of it) whose pipelines are wanted. */\nexport interface PluginVersionRef {\n  pluginName: string;\n  pluginVersion: string;\n  /** Listing publisher handle; null = an org's own plugin row; omitted = either. */\n  pluginPublisher?: string | null;\n  /** Narrow to pipelines on this image. Omitted = any image of the version. */\n  imageDigest?: string | null;\n  /** Narrow to these orgs. Omitted = every org the caller's scope can read. */\n  orgIds?: readonly string[];\n}\n\n/** A pipeline that declares or runs a given plugin version. */\nexport interface PipelineOnVersion {\n  orgId: string;\n  pipelineId: string;\n  pipelineName: string | null;\n  /** `deployed` = its last deploy's step manifest; `declared` = its config resolves to it. */\n  source: ExposureSource;\n  pluginPublisher: string | null;\n  imageDigest: string | null;\n  /** The steps on it: `synth` or `<stage>/<step>` (declared) / `<stage>/<action>` (deployed). */\n  steps: string[];\n}\n\n/**\n * Every LIVE pipeline declaring (`pipeline_plugin_resolution`) or running\n * (`pipeline_step_manifests`) a plugin version, one entry per (pipeline, source)\n * with the steps on it. A soft-deleted pipeline is NOT affected: counting it\n * would put a pipeline nobody can open into a notice or a report. Reads under\n * the CALLER's tenant scope: an org-scoped caller sees its own pipelines, the\n * rescan (elevated) sees every org's.\n */\nexport async function pipelinesOnVersion(ref: PluginVersionRef): Promise<PipelineOnVersion[]> {\n  const publisherSql = (col: string) => (ref.pluginPublisher === undefined\n    ? sql``\n    : ref.pluginPublisher === null ? sql` AND ${sql.raw(col)} IS NULL` : sql` AND ${sql.raw(col)} = ${ref.pluginPublisher}`);\n  const digestSql = (col: string) => (ref.imageDigest ? sql` AND ${sql.raw(col)} = ${ref.imageDigest}` : sql``);\n  const orgSql = (col: string) => (ref.orgIds ? sql` AND ${sql.raw(col)} = ANY(${[...ref.orgIds]})` : sql``);\n  if (ref.orgIds && ref.orgIds.length === 0) return [];\n  const result = await withTenantTx((tx) => tx.execute(sql`\n    SELECT x.org_id, x.pipeline_id, x.source, MIN(x.plugin_publisher) AS plugin_publisher, MIN(x.image_digest) AS image_digest,\n           p.pipeline_name, array_agg(DISTINCT x.step ORDER BY x.step) AS steps\n    FROM (\n      SELECT m.org_id, m.pipeline_id::text AS pipeline_id, 'deployed' AS source, m.plugin_publisher, m.image_digest,\n             m.stage_name || '/' || m.action_name AS step\n      FROM pipeline_step_manifests m\n      WHERE m.plugin_name = ${ref.pluginName} AND m.plugin_version = ${ref.pluginVersion}\n        ${publisherSql('m.plugin_publisher')}${digestSql('m.image_digest')}${orgSql('m.org_id')}\n      UNION ALL\n      SELECT r.org_id, r.pipeline_id, 'declared' AS source, r.plugin_publisher, r.resolved_digest AS image_digest,\n             CASE WHEN r.stage_name = 'synth' AND r.step_name = 'synth' THEN 'synth' ELSE r.stage_name || '/' || r.step_name END AS step\n      FROM pipeline_plugin_resolution r\n      WHERE r.plugin_name = ${ref.pluginName} AND r.resolved_version = ${ref.pluginVersion}\n        ${publisherSql('r.plugin_publisher')}${digestSql('r.resolved_digest')}${orgSql('r.org_id')}\n    ) x\n    JOIN pipelines p ON p.id::text = x.pipeline_id AND p.deleted_at IS NULL\n    GROUP BY x.org_id, x.pipeline_id, x.source, p.pipeline_name\n    ORDER BY x.pipeline_id, x.source\n  `));\n  const rows = Array.isArray(result) ? result : ((result as { rows?: unknown[] })?.rows ?? []);\n  return (rows as Array<Record<string, unknown>>).map((r) => ({\n    orgId: String(r.org_id),\n    pipelineId: String(r.pipeline_id),\n    pipelineName: (r.pipeline_name as string | null) ?? null,\n    source: r.source as ExposureSource,\n    pluginPublisher: (r.plugin_publisher as string | null) ?? null,\n    imageDigest: (r.image_digest as string | null) ?? null,\n    steps: Array.isArray(r.steps) ? (r.steps as string[]) : [],\n  }));\n}\n\n/**\n * The rescan's entry point: one rescanned version's findings, fanned out to every\n * pipeline that declares or runs it.\n *\n * A version with open fixable findings opens / refreshes one exposure per\n * (pipeline, source); a version that came back CLEAN closes every open exposure\n * on it (`fixed`), so a rebuild-in-place or an advisory withdrawn upstream shows\n * as fixed on the next night rather than lingering until each pipeline redeploys.\n *\n * Must run with a scope that can read and write every org's rows (the rescan's\n * elevated context). Never throws.\n */\nexport async function syncVersionExposures(\n  ref: PluginVersionRef,\n  scan: ScanState,\n  now = new Date(),\n): Promise<{ opened: number; closed: number }> {\n  try {\n    const counts = exposureFromScan({ ...scan, imageDigest: ref.imageDigest ?? scan.imageDigest ?? null });\n    if (!counts) return { opened: 0, closed: await closeVersionExposures(ref, now) };\n    const pipelines = await pipelinesOnVersion(ref);\n    const opened = await upsertExposures(pipelines.map((p) => ({\n      orgId: p.orgId,\n      pipelineId: p.pipelineId,\n      pluginPublisher: p.pluginPublisher,\n      pluginName: ref.pluginName,\n      pluginVersion: ref.pluginVersion,\n      imageDigest: ref.imageDigest ?? p.imageDigest,\n      source: p.source,\n      criticalCount: counts.criticalCount,\n      highCount: counts.highCount,\n      topFindings: counts.topFindings as unknown as Array<Record<string, unknown>>,\n      findingKeys: counts.findingKeys,\n    })), now);\n    return { opened, closed: 0 };\n  } catch (err) {\n    logger.warn('Version exposure sync failed', { plugin: ref.pluginName, version: ref.pluginVersion, error: errorMessage(err) });\n    return { opened: 0, closed: 0 };\n  }\n}\n\n/** Close every open exposure on a version (optionally one image of it). */\nexport async function closeVersionExposures(ref: PluginVersionRef, now = new Date()): Promise<number> {\n  const E = schema.pluginVulnExposure;\n  const rows = await withTenantTx((tx) => tx.update(E)\n    .set({ fixedAt: now, triageState: 'fixed', updatedAt: now })\n    .where(and(\n      eq(E.pluginName, ref.pluginName),\n      eq(E.pluginVersion, ref.pluginVersion),\n      isNull(E.fixedAt),\n      ...(ref.imageDigest ? [eq(E.imageDigest, ref.imageDigest)] : []),\n      ...(ref.pluginPublisher === undefined ? [] : [ref.pluginPublisher === null ? isNull(E.pluginPublisher) : eq(E.pluginPublisher, ref.pluginPublisher)]),\n      ...(ref.orgIds ? [inArray(E.orgId, [...ref.orgIds])] : []),\n    ))\n    .returning({ id: E.id }));\n  return (rows as unknown[]).length;\n}\n\n/**\n * The org's live exposures, for the report section.\n *\n * `accepted` rows whose deadline has passed come back as OPEN even if no rescan\n * has refreshed them yet: a read must not present an expired acceptance as a\n * current one, and the report is read far more often than the rescan runs.\n */\nexport async function openExposures(orgId: string): Promise<Array<{\n  pipelineId: string;\n  pluginName: string;\n  pluginVersion: string;\n  pluginPublisher: string | null;\n  source: ExposureSource;\n  criticalCount: number;\n  highCount: number;\n  topFindings: Array<Record<string, unknown>>;\n  triageState: string;\n  flaggedAt: Date;\n}>> {\n  const now = new Date();\n  const rows = await withTenantTx((tx) => tx.select({\n    pipelineId: schema.pluginVulnExposure.pipelineId,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n    pluginPublisher: schema.pluginVulnExposure.pluginPublisher,\n    source: schema.pluginVulnExposure.source,\n    criticalCount: schema.pluginVulnExposure.criticalCount,\n    highCount: schema.pluginVulnExposure.highCount,\n    topFindings: schema.pluginVulnExposure.topFindings,\n    triageState: schema.pluginVulnExposure.triageState,\n    acceptedUntil: schema.pluginVulnExposure.acceptedUntil,\n    flaggedAt: schema.pluginVulnExposure.flaggedAt,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.orgId, orgId),\n      liveExposurePredicate(now),\n    ))\n    .orderBy(sql`${schema.pluginVulnExposure.criticalCount} DESC, ${schema.pluginVulnExposure.highCount} DESC`));\n\n  return (rows as Array<Record<string, unknown>>).map((r) => ({\n    pipelineId: r.pipelineId as string,\n    pluginName: r.pluginName as string,\n    pluginVersion: r.pluginVersion as string,\n    pluginPublisher: (r.pluginPublisher as string | null) ?? null,\n    source: r.source as ExposureSource,\n    criticalCount: r.criticalCount as number,\n    highCount: r.highCount as number,\n    topFindings: (r.topFindings as Array<Record<string, unknown>>) ?? [],\n    // Only acceptances NOT in force pass the live predicate, so an `accepted`\n    // row here is an expired one, and reads as what it is: open.\n    triageState: r.triageState === 'accepted' ? 'open' : (r.triageState as string),\n    flaggedAt: r.flaggedAt as Date,\n  }));\n}\n\n/** One exposure row as the per-pipeline security views read it. */\nexport interface PipelineExposure {\n  id: string;\n  orgId: string;\n  pipelineId: string;\n  pluginPublisher: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest: string | null;\n  source: ExposureSource;\n  criticalCount: number;\n  highCount: number;\n  topFindings: Array<Record<string, unknown>>;\n  findingKeys: string[];\n  /** As stored; an `accepted` row past its deadline reads `open` (see {@link liveExposurePredicate}). */\n  triageState: string;\n  /** An acceptance still in force right now. */\n  acceptanceActive: boolean;\n  acceptedUntil: Date | null;\n  acceptedFindingKeys: string[];\n  acceptedKev: boolean;\n  triageReason: string | null;\n  triagedBy: string | null;\n  triagedAt: Date | null;\n  flaggedAt: Date;\n  fixedAt: Date | null;\n}\n\nconst E = () => schema.pluginVulnExposure;\n\nfunction toPipelineExposure(r: Record<string, unknown>, now: Date): PipelineExposure {\n  const until = (r.acceptedUntil as Date | null) ?? null;\n  const active = r.triageState === 'accepted' && r.fixedAt == null && until !== null && until.getTime() > now.getTime();\n  return {\n    id: r.id as string,\n    orgId: r.orgId as string,\n    pipelineId: r.pipelineId as string,\n    pluginPublisher: (r.pluginPublisher as string | null) ?? null,\n    pluginName: r.pluginName as string,\n    pluginVersion: r.pluginVersion as string,\n    imageDigest: (r.imageDigest as string | null) ?? null,\n    source: r.source as ExposureSource,\n    criticalCount: r.criticalCount as number,\n    highCount: r.highCount as number,\n    topFindings: (r.topFindings as Array<Record<string, unknown>>) ?? [],\n    findingKeys: (r.findingKeys as string[]) ?? [],\n    triageState: r.triageState === 'accepted' && !active && r.fixedAt == null ? 'open' : (r.triageState as string),\n    acceptanceActive: active,\n    acceptedUntil: until,\n    acceptedFindingKeys: (r.acceptedFindingKeys as string[]) ?? [],\n    acceptedKev: r.acceptedKev === true,\n    triageReason: (r.triageReason as string | null) ?? null,\n    triagedBy: (r.triagedBy as string | null) ?? null,\n    triagedAt: (r.triagedAt as Date | null) ?? null,\n    flaggedAt: r.flaggedAt as Date,\n    fixedAt: (r.fixedAt as Date | null) ?? null,\n  };\n}\n\n/**\n * One pipeline's exposures: the unfixed ones (open, accepted, false positive),\n * plus the fixed ones when asked — most severe first. Reads under the CALLER's\n * scope, narrowed to `orgId`.\n */\nexport async function pipelineExposures(\n  orgId: string,\n  pipelineId: string,\n  opts: { includeFixed?: boolean; now?: Date } = {},\n): Promise<PipelineExposure[]> {\n  const now = opts.now ?? new Date();\n  const rows = await withTenantTx((tx) => tx.select().from(E())\n    .where(and(\n      eq(E().orgId, orgId),\n      eq(E().pipelineId, pipelineId),\n      ...(opts.includeFixed ? [] : [isNull(E().fixedAt)]),\n    ))\n    .orderBy(sql`${E().criticalCount} DESC, ${E().highCount} DESC, ${E().pluginName}`));\n  return (rows as Array<Record<string, unknown>>).map((r) => toPipelineExposure(r, now));\n}\n\n/** One exposure row of `orgId`, or null. */\nexport async function exposureById(orgId: string, id: string, now = new Date()): Promise<PipelineExposure | null> {\n  const rows = await withTenantTx((tx) => tx.select().from(E()).where(and(eq(E().id, id), eq(E().orgId, orgId))));\n  const row = (rows as Array<Record<string, unknown>>)[0];\n  return row ? toPipelineExposure(row, now) : null;\n}\n\n/** A triage decision. */\nexport interface TriageDecision {\n  state: 'open' | 'accepted' | 'false_positive';\n  reason?: string;\n  acceptedUntil?: Date;\n  /** Accept KEV-listed findings too. Never implied: an acceptance without it does not cover them. */\n  kev?: boolean;\n  actor: string;\n}\n\n/**\n * Record a triage decision on one exposure — and on its SIBLINGS: the same\n * pipeline's other open row for the same version and image (the declared and\n * the deployed side). A risk decision is about what the pipeline runs, and\n * leaving one side open would have the report and the lookup disagree.\n *\n * `accepted` REQUIRES a deadline and a reason. A permanent, unexplained mute is\n * how a finding stops being anybody's problem, and there is no good reason to\n * support it — the caller gets an error rather than a silently unbounded\n * acceptance. The accepted finding keys are FROZEN at the decision: an\n * acceptance covers what was there when it was made, never a finding since.\n *\n * Returns the updated rows (empty when `id` is not `orgId`'s unfixed exposure).\n */\nexport async function triageExposure(orgId: string, id: string, decision: TriageDecision): Promise<PipelineExposure[]> {\n  if (decision.state === 'accepted' && (!decision.acceptedUntil || !decision.reason?.trim())) {\n    throw new Error('Accepting a vulnerability exposure needs a reason and an expiry date');\n  }\n  const now = new Date();\n  const target = await exposureById(orgId, id, now);\n  if (!target || target.fixedAt) return [];\n  const rows = await withTenantTx((tx) => tx.update(E())\n    .set({\n      triageState: decision.state,\n      acceptedUntil: decision.state === 'accepted' ? (decision.acceptedUntil ?? null) : null,\n      acceptedFindingKeys: decision.state === 'accepted' ? sql`${E().findingKeys}` : [],\n      acceptedKev: decision.state === 'accepted' && decision.kev === true,\n      triageReason: decision.reason?.trim() || null,\n      triagedBy: decision.actor,\n      triagedAt: now,\n      updatedAt: now,\n    })\n    .where(and(\n      eq(E().orgId, orgId),\n      eq(E().pipelineId, target.pipelineId),\n      eq(E().pluginName, target.pluginName),\n      eq(E().pluginVersion, target.pluginVersion),\n      target.imageDigest === null ? isNull(E().imageDigest) : eq(E().imageDigest, target.imageDigest),\n      isNull(E().fixedAt),\n    ))\n    .returning());\n  return (rows as Array<Record<string, unknown>>).map((r) => toPipelineExposure(r, now));\n}\n\n/** `name@version@digest` — the key {@link activeAcceptances} answers under. */\nexport const acceptanceKey = (pluginName: string, pluginVersion: string, imageDigest?: string | null): string =>\n  `${pluginName}@${pluginVersion}@${imageDigest ?? ''}`;\n\n/** A pipeline's acceptances in force, keyed by {@link acceptanceKey}, plus the accepted versions per plugin. */\nexport interface PipelineAcceptances {\n  byKey: Map<string, VulnAcceptance & { exposureIds: string[] }>;\n  /** `pluginName` → versions with an acceptance (the resolver's `acceptedVersions` hint). */\n  versionsByPlugin: Map<string, Set<string>>;\n}\n\n/**\n * The acceptances IN FORCE for one pipeline (`accepted`, unfixed, deadline in the\n * future), merged per version and image: the union of the finding keys the rows\n * froze, KEV only when every merged row accepted it. Reads under the caller's\n * scope narrowed to `orgId`; a failed read is \"no acceptance\" — the stricter answer.\n */\nexport async function activeAcceptances(orgId: string, pipelineId: string, now = new Date()): Promise<PipelineAcceptances> {\n  const out: PipelineAcceptances = { byKey: new Map(), versionsByPlugin: new Map() };\n  try {\n    const rows = await withTenantTx((tx) => tx.select({\n      id: E().id,\n      pluginName: E().pluginName,\n      pluginVersion: E().pluginVersion,\n      imageDigest: E().imageDigest,\n      acceptedUntil: E().acceptedUntil,\n      acceptedFindingKeys: E().acceptedFindingKeys,\n      acceptedKev: E().acceptedKev,\n    }).from(E())\n      .where(and(\n        eq(E().orgId, orgId),\n        eq(E().pipelineId, pipelineId),\n        eq(E().triageState, 'accepted'),\n        isNull(E().fixedAt),\n        sql`${E().acceptedUntil} > ${now}`,\n      ))) as Array<{ id: string; pluginName: string; pluginVersion: string; imageDigest: string | null; acceptedUntil: Date; acceptedFindingKeys: string[]; acceptedKev: boolean }>;\n    for (const r of rows) {\n      const key = acceptanceKey(r.pluginName, r.pluginVersion, r.imageDigest);\n      const prev = out.byKey.get(key);\n      out.byKey.set(key, prev\n        ? {\n          findingKeys: [...new Set([...prev.findingKeys, ...(r.acceptedFindingKeys ?? [])])],\n          kev: prev.kev && r.acceptedKev,\n          acceptedUntil: prev.acceptedUntil && new Date(prev.acceptedUntil) < r.acceptedUntil ? prev.acceptedUntil : r.acceptedUntil,\n          exposureIds: [...prev.exposureIds, r.id],\n        }\n        : { findingKeys: r.acceptedFindingKeys ?? [], kev: r.acceptedKev, acceptedUntil: r.acceptedUntil, exposureIds: [r.id] });\n      const versions = out.versionsByPlugin.get(r.pluginName) ?? new Set<string>();\n      versions.add(r.pluginVersion);\n      out.versionsByPlugin.set(r.pluginName, versions);\n    }\n  } catch (err) {\n    logger.warn('Pipeline acceptances unreadable; treating as none', { pipelineId, error: errorMessage(err) });\n  }\n  return out;\n}\n\n/** An acceptance that lapsed, as {@link reopenLapsedAcceptances} returns it. */\nexport interface LapsedAcceptance {\n  id: string;\n  orgId: string;\n  pipelineId: string;\n  pluginPublisher: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest: string | null;\n  triagedBy: string | null;\n  triageReason: string | null;\n  acceptedUntil: Date | null;\n}\n\n/**\n * Reopen every acceptance whose deadline has passed, and return them so the\n * pipeline owners can be told (N33). Readers already treat such a row as open;\n * writing it makes the stored state the truth and gives the notice exactly one\n * moment to fire. Must run with a scope that can write every org's rows (the\n * nightly rescan's elevated context). Never throws.\n */\nexport async function reopenLapsedAcceptances(now = new Date()): Promise<LapsedAcceptance[]> {\n  try {\n    const rows = await withTenantTx((tx) => tx.update(E())\n      .set({ triageState: 'open', updatedAt: now })\n      .where(and(\n        eq(E().triageState, 'accepted'),\n        isNull(E().fixedAt),\n        lte(E().acceptedUntil, now),\n      ))\n      .returning({\n        id: E().id,\n        orgId: E().orgId,\n        pipelineId: E().pipelineId,\n        pluginPublisher: E().pluginPublisher,\n        pluginName: E().pluginName,\n        pluginVersion: E().pluginVersion,\n        imageDigest: E().imageDigest,\n        triagedBy: E().triagedBy,\n        triageReason: E().triageReason,\n        acceptedUntil: E().acceptedUntil,\n      }));\n    return rows as LapsedAcceptance[];\n  } catch (err) {\n    logger.warn('Lapsed acceptances not reopened', { error: errorMessage(err) });\n    return [];\n  }\n}\n\n/**\n * Exposures whose acceptance has lapsed, for the org's security notifications.\n *\n * Surfaced rather than silently reopened: somebody decided to accept this until a\n * date, that date has passed, and the person who decided is the one who should\n * hear about it.\n */\nexport async function lapsedAcceptances(orgId: string, now = new Date()): Promise<Array<{\n  id: string;\n  pluginName: string;\n  pluginVersion: string;\n  triagedBy: string | null;\n  acceptedUntil: Date | null;\n}>> {\n  const rows = await withTenantTx((tx) => tx.select({\n    id: schema.pluginVulnExposure.id,\n    pluginName: schema.pluginVulnExposure.pluginName,\n    pluginVersion: schema.pluginVulnExposure.pluginVersion,\n    triagedBy: schema.pluginVulnExposure.triagedBy,\n    acceptedUntil: schema.pluginVulnExposure.acceptedUntil,\n  }).from(schema.pluginVulnExposure)\n    .where(and(\n      eq(schema.pluginVulnExposure.orgId, orgId),\n      eq(schema.pluginVulnExposure.triageState, 'accepted'),\n      isNull(schema.pluginVulnExposure.fixedAt),\n      lte(schema.pluginVulnExposure.acceptedUntil, now),\n    )));\n  return rows as Array<{ id: string; pluginName: string; pluginVersion: string; triagedBy: string | null; acceptedUntil: Date | null }>;\n}\n"]}