@pipeline-builder/pipeline-data 4.1.24 → 4.1.26

package/lib/api/reporting/analytics-queries.js

@@ -0,0 +1,598 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The queries the bespoke report sections read.
+ *
+ * All of them go through `execution_daily_rollups`, `dora_deployments`,
+ * `pipeline_plugin_resolution` or `plugin_vuln_exposure` — never raw
+ * `pipeline_events`. That is the whole point of those tables: a quarterly report
+ * over a busy org costs a few hundred rows, and keeps working after retention has
+ * swept the events.
+ *
+ * TWO RULES EVERY QUERY HERE FOLLOWS:
+ *
+ *  - NOTHING IS PER-PERSON. Every aggregate is per pipeline, per stage, per
+ *    category or per environment. The section registry refuses a per-person id at
+ *    registration; these queries make sure there is nothing to register.
+ *  - A ZERO AND A BLIND SPOT ARE DIFFERENT. Where a number can be absent for lack
+ *    of data rather than lack of activity, the shape carries that (`null`, a
+ *    `coverage` count, an explicit reason) instead of collapsing to 0.
+ */
+import { and, eq, gte, inArray, lt, sql } from 'drizzle-orm';
+import { FAILURE_CATEGORY_LABELS, isTeamActionable } from './failure-classifier.js';
+import { schema } from '../../database/drizzle-schema.js';
+import { withTenantTx } from '../../database/tenancy.js';
+/** The org predicate: one org, or a rollup set. */
+function orgPredicate(col, scope) {
+    return scope.orgIds && scope.orgIds.length > 0
+        ? inArray(col, scope.orgIds)
+        : eq(col, scope.orgId);
+}
+/**
+ * Per-pipeline delivery, worst first.
+ *
+ * WORST FIRST, and capped, because the point of the section is "where should
+ * attention go". A list sorted by name, or an unbounded one, is a data dump: the
+ * lead still has to find the problem, which is the work the report was supposed to
+ * do. Ties break on volume, so a 50%-success pipeline that ran twice does not
+ * outrank one that ran two hundred times.
+ *
+ * `successPct` is NULL for a pipeline with no runs in the window — not 0. A
+ * pipeline nobody ran is not a pipeline that failed.
+ */
+export async function getPipelineBreakdown(scope, limit = 10) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    WITH totals AS (
+      SELECT
+        r.pipeline_id,
+        SUM(r.runs)::int AS runs,
+        SUM(r.succeeded)::int AS succeeded,
+        SUM(r.failed)::int AS failed,
+        MAX(r.p95_ms)::int AS p95_ms,
+        SUM(r.build_seconds)::int AS build_seconds
+      FROM execution_daily_rollups r
+      WHERE r.org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz
+        -- The pipeline-level grain only: summing the stage rows too would count
+        -- every run once per stage.
+        AND r.stage_name = ''
+      GROUP BY r.pipeline_id
+    ),
+    deploys AS (
+      SELECT pipeline_id, COUNT(*)::int AS deploys
+      FROM dora_deployments
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz
+        AND succeeded = true
+      GROUP BY pipeline_id
+    ),
+    last_fail AS (
+      -- The most recent failing STAGE row per pipeline: what to look at first.
+      SELECT DISTINCT ON (pipeline_id) pipeline_id, day, stage_name
+      FROM execution_daily_rollups
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND day >= ${scope.from}::timestamptz AND day < ${scope.to}::timestamptz
+        AND stage_name <> '' AND failed > 0
+      ORDER BY pipeline_id, day DESC, failed DESC
+    )
+    SELECT
+      t.pipeline_id,
+      p.pipeline_name,
+      p.project,
+      t.runs, t.succeeded, t.failed, t.p95_ms, t.build_seconds,
+      COALESCE(d.deploys, 0) AS deploys,
+      f.day AS last_failure_at,
+      f.stage_name AS last_failure_stage,
+      CASE WHEN t.runs > 0 THEN ROUND((t.succeeded::numeric / t.runs) * 100, 1) ELSE NULL END AS success_pct
+    FROM totals t
+    LEFT JOIN deploys d ON d.pipeline_id = t.pipeline_id
+    LEFT JOIN last_fail f ON f.pipeline_id = t.pipeline_id
+    LEFT JOIN pipelines p ON p.id::text = t.pipeline_id
+    -- Worst first: lowest success rate, then most runs, so a 50% pipeline that ran
+    -- twice does not outrank one that ran two hundred times.
+    ORDER BY success_pct ASC NULLS LAST, t.runs DESC
+    LIMIT ${limit}
+  `));
+    return rowsOf(rows).map((r) => ({
+        pipelineId: String(r.pipeline_id),
+        pipelineName: r.pipeline_name ?? null,
+        project: r.project ?? null,
+        runs: num(r.runs),
+        succeeded: num(r.succeeded),
+        failed: num(r.failed),
+        successPct: r.success_pct === null ? null : Number(r.success_pct),
+        p95Ms: r.p95_ms === null ? null : num(r.p95_ms),
+        deploys: num(r.deploys),
+        lastFailureAt: isoOrNull(r.last_failure_at),
+        lastFailureStage: r.last_failure_stage ?? null,
+        buildSeconds: num(r.build_seconds),
+    }));
+}
+/**
+ * Failures by category, with the previous period's counts for the trend.
+ *
+ * SPLITS ACTIONABLE FROM NOT. A week whose failures were all cloud throttling is a
+ * different conversation from one whose failures were all broken tests, and
+ * presenting them in one ranked list invites exactly the wrong conclusion — a team
+ * being asked to fix an AWS capacity problem.
+ */
+export async function getFailureAnalysis(scope, previous) {
+    const counts = await categoryCounts(scope);
+    const prior = previous ? await categoryCounts({ ...scope, ...previous }) : null;
+    const total = [...counts.values()].reduce((s, v) => s + v.count, 0);
+    const topByCategory = await topPipelinesByCategory(scope);
+    const categories = [...counts.entries()]
+        .map(([category, v]) => ({
+        category,
+        label: FAILURE_CATEGORY_LABELS[category] ?? category,
+        count: v.count,
+        sharePct: total > 0 ? Number(((v.count / total) * 100).toFixed(1)) : 0,
+        teamActionable: isTeamActionable(category),
+        change: prior ? v.count - (prior.get(category)?.count ?? 0) : null,
+        topPipelines: topByCategory.get(category) ?? [],
+    }))
+        .sort((a, b) => b.count - a.count);
+    return {
+        categories,
+        total,
+        actionableTotal: categories.filter((c) => c.teamActionable).reduce((s, c) => s + c.count, 0),
+    };
+}
+async function categoryCounts(scope) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT key AS category, SUM(value::int)::int AS count
+    FROM execution_daily_rollups r, jsonb_each(r.failures_by_category)
+    WHERE r.org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+      AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz
+      AND r.stage_name = ''
+    GROUP BY key
+  `));
+    const out = new Map();
+    for (const r of rowsOf(rows))
+        out.set(r.category, { count: num(r.count) });
+    return out;
+}
+async function topPipelinesByCategory(scope, perCategory = 3) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT category, pipeline_id, pipeline_name, count FROM (
+      SELECT
+        e.key AS category,
+        r.pipeline_id,
+        p.pipeline_name,
+        SUM(e.value::int)::int AS count,
+        ROW_NUMBER() OVER (PARTITION BY e.key ORDER BY SUM(e.value::int) DESC) AS rn
+      -- CROSS JOIN LATERAL, not a comma join. With FROM a, f(a.x) e LEFT JOIN b,
+      -- the LEFT JOIN binds to e alone and r falls out of scope in its ON clause
+      -- ("invalid reference to FROM-clause entry"). The explicit lateral keeps all
+      -- three in one join tree.
+      FROM execution_daily_rollups r
+      CROSS JOIN LATERAL jsonb_each(r.failures_by_category) e
+      LEFT JOIN pipelines p ON p.id::text = r.pipeline_id
+      WHERE r.org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz
+        AND r.stage_name = ''
+      GROUP BY e.key, r.pipeline_id, p.pipeline_name
+    ) ranked
+    WHERE rn <= ${perCategory}
+  `));
+    const out = new Map();
+    for (const r of rowsOf(rows)) {
+        const key = r.category;
+        const list = out.get(key) ?? [];
+        list.push({
+            pipelineId: String(r.pipeline_id),
+            pipelineName: r.pipeline_name ?? null,
+            count: num(r.count),
+        });
+        out.set(key, list);
+    }
+    return out;
+}
+/**
+ * Per-stage timings for one pipeline, slowest first.
+ *
+ * The section a lead opens after the breakdown says a pipeline got slower: "which
+ * stage" is the next question, and answering it from raw events would mean a
+ * second scan of the same window.
+ */
+export async function getStagePerformance(scope, pipelineId, previous) {
+    const current = await stageRows(scope, pipelineId);
+    const prior = previous
+        ? new Map((await stageRows({ ...scope, ...previous }, pipelineId)).map((s) => [s.stageName, s]))
+        : new Map();
+    return current.map((s) => {
+        const before = prior.get(s.stageName)?.p95Ms ?? null;
+        return {
+            ...s,
+            p95ChangePct: before && before > 0 && s.p95Ms !== null
+                ? Number((((s.p95Ms - before) / before) * 100).toFixed(1))
+                : null,
+        };
+    }).sort((a, b) => (b.p95Ms ?? 0) - (a.p95Ms ?? 0));
+}
+async function stageRows(scope, pipelineId) {
+    const rows = await withTenantTx((tx) => tx.select({
+        stageName: schema.executionDailyRollup.stageName,
+        runs: sql `SUM(${schema.executionDailyRollup.runs})::int`,
+        failed: sql `SUM(${schema.executionDailyRollup.failed})::int`,
+        // MAX of the daily p95s, not an average of percentiles: averaging
+        // percentiles is not a percentile of anything, and the worst day is the
+        // number somebody would act on.
+        p50Ms: sql `MAX(${schema.executionDailyRollup.p50Ms})::int`,
+        p95Ms: sql `MAX(${schema.executionDailyRollup.p95Ms})::int`,
+    }).from(schema.executionDailyRollup)
+        .where(and(orgPredicate(schema.executionDailyRollup.orgId, scope), eq(schema.executionDailyRollup.pipelineId, pipelineId), gte(schema.executionDailyRollup.day, new Date(scope.from)), lt(schema.executionDailyRollup.day, new Date(scope.to)), sql `${schema.executionDailyRollup.stageName} <> ''`))
+        .groupBy(schema.executionDailyRollup.stageName));
+    const map = new Map();
+    for (const r of rows) {
+        map.set(String(r.stageName), {
+            stageName: String(r.stageName),
+            runs: num(r.runs),
+            failed: num(r.failed),
+            p50Ms: r.p50Ms === null ? null : num(r.p50Ms),
+            p95Ms: r.p95Ms === null ? null : num(r.p95Ms),
+        });
+    }
+    return [...map.values()];
+}
+/**
+ * Where the build time went.
+ *
+ * SECONDS, NOT DOLLARS. A cost figure needs the instance types, the spot/on-demand
+ * mix and the account's own discounts, none of which this platform knows — so a
+ * dollar number here would be a guess presented as an invoice. Build time is the
+ * thing actually measured.
+ */
+export async function getResourceConsumption(scope, limit = 20) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT
+      p.project,
+      r.pipeline_id,
+      p.pipeline_name,
+      SUM(r.build_seconds)::int AS build_seconds,
+      SUM(r.runs)::int AS runs
+    FROM execution_daily_rollups r
+    LEFT JOIN pipelines p ON p.id::text = r.pipeline_id
+    WHERE r.org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+      AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz
+      AND r.stage_name = ''
+    GROUP BY p.project, r.pipeline_id, p.pipeline_name
+    ORDER BY build_seconds DESC
+    LIMIT ${limit}
+  `));
+    const list = rowsOf(rows);
+    const total = list.reduce((s, r) => s + num(r.build_seconds), 0);
+    return {
+        totalBuildSeconds: total,
+        pipelines: list.map((r) => ({
+            project: r.project ?? null,
+            pipelineId: String(r.pipeline_id),
+            pipelineName: r.pipeline_name ?? null,
+            buildSeconds: num(r.build_seconds),
+            runs: num(r.runs),
+            sharePct: total > 0 ? Number(((num(r.build_seconds) / total) * 100).toFixed(1)) : 0,
+        })),
+    };
+}
+/**
+ * Where commits got to, and where they stopped.
+ *
+ * "Stuck" is the number worth reading. A commit that reached staging four days ago
+ * and never went further is work that is finished and not delivered — which does
+ * not appear in deployment frequency, success rate or lead time, because by every
+ * one of those measures nothing happened.
+ */
+export async function getPromotionView(scope, productionEnv = 'production', limit = 25) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT commit_sha, environment, MIN(deployed_at) AS deployed_at
+    FROM dora_deployments
+    WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+      AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz
+      AND succeeded = true
+      AND commit_sha IS NOT NULL
+    GROUP BY commit_sha, environment
+    ORDER BY MIN(deployed_at) DESC
+  `));
+    const byCommit = new Map();
+    for (const r of rowsOf(rows)) {
+        const sha = String(r.commit_sha);
+        const list = byCommit.get(sha) ?? [];
+        list.push({ environment: String(r.environment), deployedAt: new Date(String(r.deployed_at)) });
+        byCommit.set(sha, list);
+    }
+    const commits = [...byCommit.entries()].map(([commitSha, raw]) => {
+        const ordered = [...raw].sort((a, b) => a.deployedAt.getTime() - b.deployedAt.getTime());
+        const stops = ordered.map((stop, i) => ({
+            environment: stop.environment,
+            deployedAt: stop.deployedAt.toISOString(),
+            hoursFromPrevious: i === 0
+                ? null
+                : Number(((stop.deployedAt.getTime() - ordered[i - 1].deployedAt.getTime()) / 3600_000).toFixed(1)),
+        }));
+        const furthest = ordered[ordered.length - 1]?.environment ?? '';
+        return { commitSha, stops, furthest, stuck: furthest !== productionEnv };
+    })
+        .sort((a, b) => {
+        const aLast = a.stops[a.stops.length - 1]?.deployedAt ?? '';
+        const bLast = b.stops[b.stops.length - 1]?.deployedAt ?? '';
+        return bLast.localeCompare(aLast);
+    })
+        .slice(0, limit);
+    return { commits, stuckCount: commits.filter((c) => c.stuck).length };
+}
+/**
+ * Which pipelines are behind on a plugin, worst gap first.
+ *
+ * Reads the DECLARED side (`pipeline_plugin_resolution`). A pipeline's declared
+ * range and what it last actually ran can disagree — which is why the vulnerability
+ * section below reads the deployed side and says which it is showing.
+ */
+export async function getOutdatedPlugins(scope, limit = 50) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT
+      r.pipeline_id, p.pipeline_name, r.stage_name, r.step_name,
+      COALESCE(r.plugin_publisher || '/', '') || r.plugin_name AS plugin,
+      r.resolved_version, r.latest_version, r.version_gap, r.within_policy
+    FROM pipeline_plugin_resolution r
+    LEFT JOIN pipelines p ON p.id::text = r.pipeline_id
+    WHERE r.org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+      AND (r.version_gap IN ('major', 'minor', 'patch') OR r.within_policy = false)
+    ORDER BY CASE r.version_gap WHEN 'major' THEN 0 WHEN 'minor' THEN 1 WHEN 'patch' THEN 2 ELSE 3 END,
+             r.pipeline_id
+    LIMIT ${limit}
+  `));
+    const list = rowsOf(rows).map((r) => ({
+        pipelineId: String(r.pipeline_id),
+        pipelineName: r.pipeline_name ?? null,
+        stageName: String(r.stage_name),
+        stepName: String(r.step_name),
+        plugin: String(r.plugin),
+        inUse: r.resolved_version ?? null,
+        latest: r.latest_version ?? null,
+        gap: r.version_gap ?? null,
+        withinPolicy: r.within_policy !== false,
+    }));
+    return {
+        rows: list,
+        behindPipelines: new Set(list.map((r) => r.pipelineId)).size,
+        majorBehind: list.filter((r) => r.gap === 'major').length,
+    };
+}
+/**
+ * Plugin vulnerabilities, per pipeline, Criticals first.
+ *
+ * SAYS WHETHER IT IS DECLARED OR DEPLOYED. A pipeline whose config was updated to a
+ * fixed version but which has not re-synthed is still running the vulnerable image,
+ * and a report that collapsed the two would tell a manager the problem is solved
+ * while the old image keeps running.
+ */
+export async function getPluginVulnerabilities(scope, limit = 50) {
+    const now = new Date();
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT
+      v.pipeline_id, p.pipeline_name,
+      COALESCE(v.plugin_publisher || '/', '') || v.plugin_name AS plugin,
+      v.plugin_version, v.source, v.critical_count, v.high_count, v.top_findings, v.flagged_at
+    FROM plugin_vuln_exposure v
+    LEFT JOIN pipelines p ON p.id::text = v.pipeline_id
+    WHERE v.org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+      AND v.fixed_at IS NULL
+      -- An acceptance past its deadline is not an acceptance.
+      AND (v.triage_state NOT IN ('accepted', 'false_positive')
+           OR (v.triage_state = 'accepted' AND v.accepted_until IS NOT NULL AND v.accepted_until <= ${now}))
+    ORDER BY v.critical_count DESC, v.high_count DESC
+    LIMIT ${limit}
+  `));
+    const list = rowsOf(rows).map((r) => ({
+        pipelineId: String(r.pipeline_id),
+        pipelineName: r.pipeline_name ?? null,
+        plugin: String(r.plugin),
+        version: String(r.plugin_version),
+        source: String(r.source),
+        critical: num(r.critical_count),
+        high: num(r.high_count),
+        findings: r.top_findings ?? [],
+        flaggedAt: isoOrNull(r.flagged_at) ?? new Date(0).toISOString(),
+    }));
+    return {
+        rows: list,
+        exposedPipelines: new Set(list.map((r) => r.pipelineId)).size,
+        criticalPipelines: new Set(list.filter((r) => r.critical > 0).map((r) => r.pipelineId)).size,
+    };
+}
+/**
+ * Adoption, coverage and creation source.
+ *
+ * `deployTrackedPipelines` is the honest denominator for everything DORA says: a
+ * pipeline that has not re-synthed with deploy tags produces no deploy rows, so it
+ * is invisible to deployment frequency — and reporting "4 deploys" without saying
+ * that 20 of 30 pipelines cannot be seen is the single most misleading thing this
+ * feature could do.
+ */
+export async function getAdoption(scope, timeSavedMinutes) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    WITH scoped AS (
+      SELECT id::text AS id, org_id, creation_source
+      FROM pipelines
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND deleted_at IS NULL
+    ),
+    active AS (
+      SELECT DISTINCT pipeline_id, org_id
+      FROM execution_daily_rollups
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND day >= ${scope.from}::timestamptz AND day < ${scope.to}::timestamptz
+        AND stage_name = '' AND runs > 0
+    ),
+    tracked AS (
+      SELECT DISTINCT pipeline_id
+      FROM dora_deployments
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz
+    )
+    SELECT
+      (SELECT COUNT(*) FROM scoped)::int AS total_pipelines,
+      (SELECT COUNT(*) FROM active)::int AS active_pipelines,
+      (SELECT COUNT(DISTINCT org_id) FROM active)::int AS active_teams,
+      (SELECT COUNT(*) FROM tracked)::int AS deploy_tracked,
+      (SELECT COALESCE(jsonb_object_agg(COALESCE(creation_source, 'unknown'), n), '{}'::jsonb)
+         FROM (SELECT creation_source, COUNT(*)::int AS n FROM scoped GROUP BY creation_source) s
+      ) AS by_source
+  `));
+    const r = rowsOf(rows)[0] ?? {};
+    const created = num(r.total_pipelines);
+    return {
+        totalPipelines: created,
+        activePipelines: num(r.active_pipelines),
+        activeTeams: Math.max(1, num(r.active_teams)),
+        deployTrackedPipelines: num(r.deploy_tracked),
+        bySource: r.by_source ?? {},
+        // Only when the ORG configured the assumption — a platform-supplied number
+        // here would be the platform marking its own homework.
+        estimatedMinutesSaved: timeSavedMinutes && timeSavedMinutes > 0 ? created * timeSavedMinutes : null,
+    };
+}
+/**
+ * Failure streaks and last-success dates, for the needs-attention rules.
+ *
+ * Reads the daily rollup, not `pipeline_events` — the same reason as everything
+ * else here: a streak that ended three weeks ago must still be readable after
+ * retention has swept the events that produced it.
+ *
+ * `lookbackDays` extends PAST the window on purpose. "Last succeeded 12 days ago"
+ * is the finding a weekly report most needs, and a query bounded by a 7-day window
+ * could never produce it.
+ */
+export async function getPipelineStreaks(scope, lookbackDays = 90) {
+    const since = new Date(new Date(scope.to).getTime() - lookbackDays * 86_400_000).toISOString();
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    WITH days AS (
+      SELECT pipeline_id, day,
+             SUM(succeeded)::int AS succeeded,
+             SUM(failed)::int    AS failed
+      FROM execution_daily_rollups
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND day >= ${since}::timestamptz AND day < ${scope.to}::timestamptz
+      GROUP BY pipeline_id, day
+    ),
+    last_ok AS (
+      SELECT pipeline_id, MAX(day) AS last_success_day
+      FROM days WHERE succeeded > 0
+      GROUP BY pipeline_id
+    )
+    SELECT d.pipeline_id,
+           l.last_success_day,
+           COALESCE(SUM(d.failed) FILTER (
+             WHERE l.last_success_day IS NULL OR d.day > l.last_success_day
+           ), 0)::int AS streak
+    FROM days d
+    LEFT JOIN last_ok l ON l.pipeline_id = d.pipeline_id
+    GROUP BY d.pipeline_id, l.last_success_day
+  `));
+    return rowsOf(rows).map((r) => ({
+        pipelineId: String(r.pipeline_id),
+        consecutiveFailures: num(r.streak),
+        lastSuccessAt: r.last_success_day ? new Date(String(r.last_success_day)) : null,
+    }));
+}
+/**
+ * Pipelines that RAN in the window but produced no deploy rows.
+ *
+ * A measurement gap, not a failure, and the reason a deployment-frequency number can
+ * be quietly wrong: a pipeline whose synth predates the `pb.deploys` tags deploys
+ * perfectly well and is invisible to every DORA aggregate. Nothing else in the
+ * report would say so.
+ */
+export async function getUntrackedPipelines(scope) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    WITH active AS (
+      SELECT pipeline_id
+      FROM execution_daily_rollups
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND day >= ${scope.from}::timestamptz AND day < ${scope.to}::timestamptz
+        AND stage_name = ''
+      GROUP BY pipeline_id
+      HAVING SUM(runs) > 0
+    ),
+    tracked AS (
+      SELECT DISTINCT pipeline_id
+      FROM dora_deployments
+      WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+        AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz
+    )
+    SELECT a.pipeline_id FROM active a
+    WHERE NOT EXISTS (SELECT 1 FROM tracked t WHERE t.pipeline_id = a.pipeline_id)
+  `));
+    return rowsOf(rows).map((r) => String(r.pipeline_id));
+}
+/**
+ * Pipelines running a plugin version with an OPEN Critical exposure.
+ *
+ * Point-in-time, not windowed: what matters is whether the pipeline is running one
+ * NOW. A Critical that was open last Tuesday and is fixed today is not something to
+ * put in front of a manager, and `fixed_at` is what says so.
+ *
+ * An ACCEPTED exposure is excluded. Someone with the authority to accept a risk has
+ * already decided about it in writing, with a reason and a deadline; re-raising it
+ * weekly is how a report teaches its reader to skip a section. The lapse of that
+ * acceptance is a separate finding (`lapsedAcceptances`).
+ */
+export async function getVulnerablePipelines(scope) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT DISTINCT pipeline_id
+    FROM plugin_vuln_exposure
+    WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+      AND fixed_at IS NULL
+      AND critical_count > 0
+      AND triage_state <> 'accepted'
+  `));
+    return rowsOf(rows).map((r) => String(r.pipeline_id));
+}
+/**
+ * When each pipeline in the window was last changed.
+ *
+ * `pipelines.updated_at`, not an audit query: the audit trail lives in another store
+ * with its own retention, and the one fact this needs — "was this touched shortly
+ * before it broke" — is already on the row, durably, in the same transaction the
+ * change was made in.
+ *
+ * The consequence is stated rather than hidden: `updated_at` moves for ANY write,
+ * including a rename. So the finding says "after a configuration change", which is
+ * true of a rename too, and does not claim to name the change.
+ */
+export async function getPipelineConfigChanges(scope) {
+    const rows = await withTenantTx((tx) => tx.execute(sql `
+    SELECT id::text AS id, updated_at
+    FROM pipelines
+    WHERE org_id ${scope.orgIds?.length ? sql `= ANY(${scope.orgIds})` : sql `= ${scope.orgId}`}
+      AND deleted_at IS NULL
+      AND updated_at IS NOT NULL
+  `));
+    const out = new Map();
+    for (const r of rowsOf(rows)) {
+        const at = r.updated_at ? new Date(String(r.updated_at)) : null;
+        if (at && !Number.isNaN(at.getTime()))
+            out.set(String(r.id), at);
+    }
+    return out;
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/** Rows from a raw `execute`, whichever shape the driver returned. */
+function rowsOf(result) {
+    if (Array.isArray(result))
+        return result;
+    const rows = result?.rows;
+    return Array.isArray(rows) ? rows : [];
+}
+/** A count from a driver that may hand back a string for a bigint. */
+function num(v) {
+    const n = typeof v === 'number' ? v : Number(v ?? 0);
+    return Number.isFinite(n) ? n : 0;
+}
+function isoOrNull(v) {
+    if (!v)
+        return null;
+    const d = v instanceof Date ? v : new Date(String(v));
+    return Number.isNaN(d.getTime()) ? null : d.toISOString();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analytics-queries.js","sourceRoot":"","sources":["../../../src/api/reporting/analytics-queries.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The queries the bespoke report sections read.\n *\n * All of them go through `execution_daily_rollups`, `dora_deployments`,\n * `pipeline_plugin_resolution` or `plugin_vuln_exposure` — never raw\n * `pipeline_events`. That is the whole point of those tables: a quarterly report\n * over a busy org costs a few hundred rows, and keeps working after retention has\n * swept the events.\n *\n * TWO RULES EVERY QUERY HERE FOLLOWS:\n *\n *  - NOTHING IS PER-PERSON. Every aggregate is per pipeline, per stage, per\n *    category or per environment. The section registry refuses a per-person id at\n *    registration; these queries make sure there is nothing to register.\n *  - A ZERO AND A BLIND SPOT ARE DIFFERENT. Where a number can be absent for lack\n *    of data rather than lack of activity, the shape carries that (`null`, a\n *    `coverage` count, an explicit reason) instead of collapsing to 0.\n */\n\nimport { and, eq, gte, inArray, lt, sql } from 'drizzle-orm';\nimport { FAILURE_CATEGORY_LABELS, isTeamActionable } from './failure-classifier.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport type { FailureCategory } from '../../database/schema/reporting-analytics.js';\nimport { withTenantTx } from '../../database/tenancy.js';\n\n/** The window and org scope every query takes. */\nexport interface AnalyticsScope {\n  orgId: string;\n  /** `[self, ...descendants]` for a rollup; undefined = this org only. */\n  orgIds?: string[];\n  from: string;\n  to: string;\n}\n\n/** The org predicate: one org, or a rollup set. */\nfunction orgPredicate(col: Parameters<typeof inArray>[0], scope: AnalyticsScope) {\n  return scope.orgIds && scope.orgIds.length > 0\n    ? inArray(col, scope.orgIds)\n    : eq(col as never, scope.orgId as never);\n}\n\n/** One pipeline's line in the breakdown. */\nexport interface PipelineBreakdownRow {\n  pipelineId: string;\n  pipelineName: string | null;\n  project: string | null;\n  runs: number;\n  succeeded: number;\n  failed: number;\n  successPct: number | null;\n  p95Ms: number | null;\n  deploys: number;\n  /** The most recent failure's day and stage, for \"what to look at first\". */\n  lastFailureAt: string | null;\n  lastFailureStage: string | null;\n  buildSeconds: number;\n}\n\n/**\n * Per-pipeline delivery, worst first.\n *\n * WORST FIRST, and capped, because the point of the section is \"where should\n * attention go\". A list sorted by name, or an unbounded one, is a data dump: the\n * lead still has to find the problem, which is the work the report was supposed to\n * do. Ties break on volume, so a 50%-success pipeline that ran twice does not\n * outrank one that ran two hundred times.\n *\n * `successPct` is NULL for a pipeline with no runs in the window — not 0. A\n * pipeline nobody ran is not a pipeline that failed.\n */\nexport async function getPipelineBreakdown(scope: AnalyticsScope, limit = 10): Promise<PipelineBreakdownRow[]> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    WITH totals AS (\n      SELECT\n        r.pipeline_id,\n        SUM(r.runs)::int AS runs,\n        SUM(r.succeeded)::int AS succeeded,\n        SUM(r.failed)::int AS failed,\n        MAX(r.p95_ms)::int AS p95_ms,\n        SUM(r.build_seconds)::int AS build_seconds\n      FROM execution_daily_rollups r\n      WHERE r.org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz\n        -- The pipeline-level grain only: summing the stage rows too would count\n        -- every run once per stage.\n        AND r.stage_name = ''\n      GROUP BY r.pipeline_id\n    ),\n    deploys AS (\n      SELECT pipeline_id, COUNT(*)::int AS deploys\n      FROM dora_deployments\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz\n        AND succeeded = true\n      GROUP BY pipeline_id\n    ),\n    last_fail AS (\n      -- The most recent failing STAGE row per pipeline: what to look at first.\n      SELECT DISTINCT ON (pipeline_id) pipeline_id, day, stage_name\n      FROM execution_daily_rollups\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND day >= ${scope.from}::timestamptz AND day < ${scope.to}::timestamptz\n        AND stage_name <> '' AND failed > 0\n      ORDER BY pipeline_id, day DESC, failed DESC\n    )\n    SELECT\n      t.pipeline_id,\n      p.pipeline_name,\n      p.project,\n      t.runs, t.succeeded, t.failed, t.p95_ms, t.build_seconds,\n      COALESCE(d.deploys, 0) AS deploys,\n      f.day AS last_failure_at,\n      f.stage_name AS last_failure_stage,\n      CASE WHEN t.runs > 0 THEN ROUND((t.succeeded::numeric / t.runs) * 100, 1) ELSE NULL END AS success_pct\n    FROM totals t\n    LEFT JOIN deploys d ON d.pipeline_id = t.pipeline_id\n    LEFT JOIN last_fail f ON f.pipeline_id = t.pipeline_id\n    LEFT JOIN pipelines p ON p.id::text = t.pipeline_id\n    -- Worst first: lowest success rate, then most runs, so a 50% pipeline that ran\n    -- twice does not outrank one that ran two hundred times.\n    ORDER BY success_pct ASC NULLS LAST, t.runs DESC\n    LIMIT ${limit}\n  `));\n  return rowsOf(rows).map((r) => ({\n    pipelineId: String(r.pipeline_id),\n    pipelineName: (r.pipeline_name as string | null) ?? null,\n    project: (r.project as string | null) ?? null,\n    runs: num(r.runs),\n    succeeded: num(r.succeeded),\n    failed: num(r.failed),\n    successPct: r.success_pct === null ? null : Number(r.success_pct),\n    p95Ms: r.p95_ms === null ? null : num(r.p95_ms),\n    deploys: num(r.deploys),\n    lastFailureAt: isoOrNull(r.last_failure_at),\n    lastFailureStage: (r.last_failure_stage as string | null) ?? null,\n    buildSeconds: num(r.build_seconds),\n  }));\n}\n\n/** One failure category's share of the period. */\nexport interface FailureCategoryRow {\n  category: FailureCategory;\n  label: string;\n  count: number;\n  sharePct: number;\n  /** Whether the team can act on it, or it happened to them. */\n  teamActionable: boolean;\n  /** Change vs the previous period, in failures. */\n  change: number | null;\n  /** The pipelines it hit hardest. */\n  topPipelines: Array<{ pipelineId: string; pipelineName: string | null; count: number }>;\n}\n\n/**\n * Failures by category, with the previous period's counts for the trend.\n *\n * SPLITS ACTIONABLE FROM NOT. A week whose failures were all cloud throttling is a\n * different conversation from one whose failures were all broken tests, and\n * presenting them in one ranked list invites exactly the wrong conclusion — a team\n * being asked to fix an AWS capacity problem.\n */\nexport async function getFailureAnalysis(\n  scope: AnalyticsScope,\n  previous?: { from: string; to: string },\n): Promise<{ categories: FailureCategoryRow[]; total: number; actionableTotal: number }> {\n  const counts = await categoryCounts(scope);\n  const prior = previous ? await categoryCounts({ ...scope, ...previous }) : null;\n  const total = [...counts.values()].reduce((s, v) => s + v.count, 0);\n  const topByCategory = await topPipelinesByCategory(scope);\n\n  const categories = [...counts.entries()]\n    .map(([category, v]) => ({\n      category,\n      label: FAILURE_CATEGORY_LABELS[category] ?? category,\n      count: v.count,\n      sharePct: total > 0 ? Number(((v.count / total) * 100).toFixed(1)) : 0,\n      teamActionable: isTeamActionable(category),\n      change: prior ? v.count - (prior.get(category)?.count ?? 0) : null,\n      topPipelines: topByCategory.get(category) ?? [],\n    }))\n    .sort((a, b) => b.count - a.count);\n\n  return {\n    categories,\n    total,\n    actionableTotal: categories.filter((c) => c.teamActionable).reduce((s, c) => s + c.count, 0),\n  };\n}\n\nasync function categoryCounts(scope: AnalyticsScope): Promise<Map<FailureCategory, { count: number }>> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT key AS category, SUM(value::int)::int AS count\n    FROM execution_daily_rollups r, jsonb_each(r.failures_by_category)\n    WHERE r.org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n      AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz\n      AND r.stage_name = ''\n    GROUP BY key\n  `));\n  const out = new Map<FailureCategory, { count: number }>();\n  for (const r of rowsOf(rows)) out.set(r.category as FailureCategory, { count: num(r.count) });\n  return out;\n}\n\nasync function topPipelinesByCategory(\n  scope: AnalyticsScope,\n  perCategory = 3,\n): Promise<Map<FailureCategory, Array<{ pipelineId: string; pipelineName: string | null; count: number }>>> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT category, pipeline_id, pipeline_name, count FROM (\n      SELECT\n        e.key AS category,\n        r.pipeline_id,\n        p.pipeline_name,\n        SUM(e.value::int)::int AS count,\n        ROW_NUMBER() OVER (PARTITION BY e.key ORDER BY SUM(e.value::int) DESC) AS rn\n      -- CROSS JOIN LATERAL, not a comma join. With FROM a, f(a.x) e LEFT JOIN b,\n      -- the LEFT JOIN binds to e alone and r falls out of scope in its ON clause\n      -- (\"invalid reference to FROM-clause entry\"). The explicit lateral keeps all\n      -- three in one join tree.\n      FROM execution_daily_rollups r\n      CROSS JOIN LATERAL jsonb_each(r.failures_by_category) e\n      LEFT JOIN pipelines p ON p.id::text = r.pipeline_id\n      WHERE r.org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz\n        AND r.stage_name = ''\n      GROUP BY e.key, r.pipeline_id, p.pipeline_name\n    ) ranked\n    WHERE rn <= ${perCategory}\n  `));\n  const out = new Map<FailureCategory, Array<{ pipelineId: string; pipelineName: string | null; count: number }>>();\n  for (const r of rowsOf(rows)) {\n    const key = r.category as FailureCategory;\n    const list = out.get(key) ?? [];\n    list.push({\n      pipelineId: String(r.pipeline_id),\n      pipelineName: (r.pipeline_name as string | null) ?? null,\n      count: num(r.count),\n    });\n    out.set(key, list);\n  }\n  return out;\n}\n\n/** One stage's timing, for the drill-down. */\nexport interface StagePerformanceRow {\n  stageName: string;\n  runs: number;\n  p50Ms: number | null;\n  p95Ms: number | null;\n  /** Change in p95 vs the previous period, as a percentage. */\n  p95ChangePct: number | null;\n  failed: number;\n}\n\n/**\n * Per-stage timings for one pipeline, slowest first.\n *\n * The section a lead opens after the breakdown says a pipeline got slower: \"which\n * stage\" is the next question, and answering it from raw events would mean a\n * second scan of the same window.\n */\nexport async function getStagePerformance(\n  scope: AnalyticsScope,\n  pipelineId: string,\n  previous?: { from: string; to: string },\n): Promise<StagePerformanceRow[]> {\n  const current = await stageRows(scope, pipelineId);\n  const prior: Map<string, { p95Ms: number | null }> = previous\n    ? new Map((await stageRows({ ...scope, ...previous }, pipelineId)).map((s) => [s.stageName, s]))\n    : new Map();\n  return current.map((s) => {\n    const before = prior.get(s.stageName)?.p95Ms ?? null;\n    return {\n      ...s,\n      p95ChangePct: before && before > 0 && s.p95Ms !== null\n        ? Number((((s.p95Ms - before) / before) * 100).toFixed(1))\n        : null,\n    };\n  }).sort((a, b) => (b.p95Ms ?? 0) - (a.p95Ms ?? 0));\n}\n\ninterface StageRow { stageName: string; runs: number; p50Ms: number | null; p95Ms: number | null; failed: number }\n\nasync function stageRows(scope: AnalyticsScope, pipelineId: string): Promise<StageRow[]> {\n  const rows = await withTenantTx((tx) => tx.select({\n    stageName: schema.executionDailyRollup.stageName,\n    runs: sql<number>`SUM(${schema.executionDailyRollup.runs})::int`,\n    failed: sql<number>`SUM(${schema.executionDailyRollup.failed})::int`,\n    // MAX of the daily p95s, not an average of percentiles: averaging\n    // percentiles is not a percentile of anything, and the worst day is the\n    // number somebody would act on.\n    p50Ms: sql<number | null>`MAX(${schema.executionDailyRollup.p50Ms})::int`,\n    p95Ms: sql<number | null>`MAX(${schema.executionDailyRollup.p95Ms})::int`,\n  }).from(schema.executionDailyRollup)\n    .where(and(\n      orgPredicate(schema.executionDailyRollup.orgId, scope),\n      eq(schema.executionDailyRollup.pipelineId, pipelineId),\n      gte(schema.executionDailyRollup.day, new Date(scope.from)),\n      lt(schema.executionDailyRollup.day, new Date(scope.to)),\n      sql`${schema.executionDailyRollup.stageName} <> ''`,\n    ))\n    .groupBy(schema.executionDailyRollup.stageName));\n  const map = new Map<string, StageRow>();\n  for (const r of rows as Array<Record<string, unknown>>) {\n    map.set(String(r.stageName), {\n      stageName: String(r.stageName),\n      runs: num(r.runs),\n      failed: num(r.failed),\n      p50Ms: r.p50Ms === null ? null : num(r.p50Ms),\n      p95Ms: r.p95Ms === null ? null : num(r.p95Ms),\n    });\n  }\n  return [...map.values()];\n}\n\n/** Build time by project and pipeline. No money anywhere. */\nexport interface ResourceRow {\n  project: string | null;\n  pipelineId: string;\n  pipelineName: string | null;\n  buildSeconds: number;\n  runs: number;\n  sharePct: number;\n}\n\n/**\n * Where the build time went.\n *\n * SECONDS, NOT DOLLARS. A cost figure needs the instance types, the spot/on-demand\n * mix and the account's own discounts, none of which this platform knows — so a\n * dollar number here would be a guess presented as an invoice. Build time is the\n * thing actually measured.\n */\nexport async function getResourceConsumption(scope: AnalyticsScope, limit = 20): Promise<{\n  pipelines: ResourceRow[];\n  totalBuildSeconds: number;\n}> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT\n      p.project,\n      r.pipeline_id,\n      p.pipeline_name,\n      SUM(r.build_seconds)::int AS build_seconds,\n      SUM(r.runs)::int AS runs\n    FROM execution_daily_rollups r\n    LEFT JOIN pipelines p ON p.id::text = r.pipeline_id\n    WHERE r.org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n      AND r.day >= ${scope.from}::timestamptz AND r.day < ${scope.to}::timestamptz\n      AND r.stage_name = ''\n    GROUP BY p.project, r.pipeline_id, p.pipeline_name\n    ORDER BY build_seconds DESC\n    LIMIT ${limit}\n  `));\n  const list = rowsOf(rows);\n  const total = list.reduce((s, r) => s + num(r.build_seconds), 0);\n  return {\n    totalBuildSeconds: total,\n    pipelines: list.map((r) => ({\n      project: (r.project as string | null) ?? null,\n      pipelineId: String(r.pipeline_id),\n      pipelineName: (r.pipeline_name as string | null) ?? null,\n      buildSeconds: num(r.build_seconds),\n      runs: num(r.runs),\n      sharePct: total > 0 ? Number(((num(r.build_seconds) / total) * 100).toFixed(1)) : 0,\n    })),\n  };\n}\n\n/** One commit's journey across environments. */\nexport interface PromotionRow {\n  commitSha: string;\n  /** Environment → when it landed there, in the order it reached them. */\n  stops: Array<{ environment: string; deployedAt: string; hoursFromPrevious: number | null }>;\n  /** True when the commit reached a non-production environment and stopped. */\n  stuck: boolean;\n  furthest: string;\n}\n\n/**\n * Where commits got to, and where they stopped.\n *\n * \"Stuck\" is the number worth reading. A commit that reached staging four days ago\n * and never went further is work that is finished and not delivered — which does\n * not appear in deployment frequency, success rate or lead time, because by every\n * one of those measures nothing happened.\n */\nexport async function getPromotionView(\n  scope: AnalyticsScope,\n  productionEnv = 'production',\n  limit = 25,\n): Promise<{ commits: PromotionRow[]; stuckCount: number }> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT commit_sha, environment, MIN(deployed_at) AS deployed_at\n    FROM dora_deployments\n    WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n      AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz\n      AND succeeded = true\n      AND commit_sha IS NOT NULL\n    GROUP BY commit_sha, environment\n    ORDER BY MIN(deployed_at) DESC\n  `));\n\n  const byCommit = new Map<string, Array<{ environment: string; deployedAt: Date }>>();\n  for (const r of rowsOf(rows)) {\n    const sha = String(r.commit_sha);\n    const list = byCommit.get(sha) ?? [];\n    list.push({ environment: String(r.environment), deployedAt: new Date(String(r.deployed_at)) });\n    byCommit.set(sha, list);\n  }\n\n  const commits: PromotionRow[] = [...byCommit.entries()].map(([commitSha, raw]) => {\n    const ordered = [...raw].sort((a, b) => a.deployedAt.getTime() - b.deployedAt.getTime());\n    const stops = ordered.map((stop, i) => ({\n      environment: stop.environment,\n      deployedAt: stop.deployedAt.toISOString(),\n      hoursFromPrevious: i === 0\n        ? null\n        : Number(((stop.deployedAt.getTime() - (ordered[i - 1] as { deployedAt: Date }).deployedAt.getTime()) / 3600_000).toFixed(1)),\n    }));\n    const furthest = ordered[ordered.length - 1]?.environment ?? '';\n    return { commitSha, stops, furthest, stuck: furthest !== productionEnv };\n  })\n    .sort((a, b) => {\n      const aLast = a.stops[a.stops.length - 1]?.deployedAt ?? '';\n      const bLast = b.stops[b.stops.length - 1]?.deployedAt ?? '';\n      return bLast.localeCompare(aLast);\n    })\n    .slice(0, limit);\n\n  return { commits, stuckCount: commits.filter((c) => c.stuck).length };\n}\n\n/** Outdated plugin usage, per pipeline and step. */\nexport interface OutdatedPluginRow {\n  pipelineId: string;\n  pipelineName: string | null;\n  stageName: string;\n  stepName: string;\n  plugin: string;\n  inUse: string | null;\n  latest: string | null;\n  gap: string | null;\n  withinPolicy: boolean;\n}\n\n/**\n * Which pipelines are behind on a plugin, worst gap first.\n *\n * Reads the DECLARED side (`pipeline_plugin_resolution`). A pipeline's declared\n * range and what it last actually ran can disagree — which is why the vulnerability\n * section below reads the deployed side and says which it is showing.\n */\nexport async function getOutdatedPlugins(scope: AnalyticsScope, limit = 50): Promise<{\n  rows: OutdatedPluginRow[];\n  behindPipelines: number;\n  majorBehind: number;\n}> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT\n      r.pipeline_id, p.pipeline_name, r.stage_name, r.step_name,\n      COALESCE(r.plugin_publisher || '/', '') || r.plugin_name AS plugin,\n      r.resolved_version, r.latest_version, r.version_gap, r.within_policy\n    FROM pipeline_plugin_resolution r\n    LEFT JOIN pipelines p ON p.id::text = r.pipeline_id\n    WHERE r.org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n      AND (r.version_gap IN ('major', 'minor', 'patch') OR r.within_policy = false)\n    ORDER BY CASE r.version_gap WHEN 'major' THEN 0 WHEN 'minor' THEN 1 WHEN 'patch' THEN 2 ELSE 3 END,\n             r.pipeline_id\n    LIMIT ${limit}\n  `));\n  const list = rowsOf(rows).map((r) => ({\n    pipelineId: String(r.pipeline_id),\n    pipelineName: (r.pipeline_name as string | null) ?? null,\n    stageName: String(r.stage_name),\n    stepName: String(r.step_name),\n    plugin: String(r.plugin),\n    inUse: (r.resolved_version as string | null) ?? null,\n    latest: (r.latest_version as string | null) ?? null,\n    gap: (r.version_gap as string | null) ?? null,\n    withinPolicy: r.within_policy !== false,\n  }));\n  return {\n    rows: list,\n    behindPipelines: new Set(list.map((r) => r.pipelineId)).size,\n    majorBehind: list.filter((r) => r.gap === 'major').length,\n  };\n}\n\n/** A pipeline's exposure to a vulnerable plugin version. */\nexport interface VulnerabilityRow {\n  pipelineId: string;\n  pipelineName: string | null;\n  plugin: string;\n  version: string;\n  /** `deployed` = what actually ran; `declared` = what the config asks for. */\n  source: string;\n  critical: number;\n  high: number;\n  findings: Array<Record<string, unknown>>;\n  flaggedAt: string;\n}\n\n/**\n * Plugin vulnerabilities, per pipeline, Criticals first.\n *\n * SAYS WHETHER IT IS DECLARED OR DEPLOYED. A pipeline whose config was updated to a\n * fixed version but which has not re-synthed is still running the vulnerable image,\n * and a report that collapsed the two would tell a manager the problem is solved\n * while the old image keeps running.\n */\nexport async function getPluginVulnerabilities(scope: AnalyticsScope, limit = 50): Promise<{\n  rows: VulnerabilityRow[];\n  exposedPipelines: number;\n  criticalPipelines: number;\n}> {\n  const now = new Date();\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT\n      v.pipeline_id, p.pipeline_name,\n      COALESCE(v.plugin_publisher || '/', '') || v.plugin_name AS plugin,\n      v.plugin_version, v.source, v.critical_count, v.high_count, v.top_findings, v.flagged_at\n    FROM plugin_vuln_exposure v\n    LEFT JOIN pipelines p ON p.id::text = v.pipeline_id\n    WHERE v.org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n      AND v.fixed_at IS NULL\n      -- An acceptance past its deadline is not an acceptance.\n      AND (v.triage_state NOT IN ('accepted', 'false_positive')\n           OR (v.triage_state = 'accepted' AND v.accepted_until IS NOT NULL AND v.accepted_until <= ${now}))\n    ORDER BY v.critical_count DESC, v.high_count DESC\n    LIMIT ${limit}\n  `));\n  const list = rowsOf(rows).map((r) => ({\n    pipelineId: String(r.pipeline_id),\n    pipelineName: (r.pipeline_name as string | null) ?? null,\n    plugin: String(r.plugin),\n    version: String(r.plugin_version),\n    source: String(r.source),\n    critical: num(r.critical_count),\n    high: num(r.high_count),\n    findings: (r.top_findings as Array<Record<string, unknown>>) ?? [],\n    flaggedAt: isoOrNull(r.flagged_at) ?? new Date(0).toISOString(),\n  }));\n  return {\n    rows: list,\n    exposedPipelines: new Set(list.map((r) => r.pipelineId)).size,\n    criticalPipelines: new Set(list.filter((r) => r.critical > 0).map((r) => r.pipelineId)).size,\n  };\n}\n\n/** Adoption and deploy-tracking coverage within the reported scope. */\nexport interface AdoptionSummary {\n  activePipelines: number;\n  totalPipelines: number;\n  /** Pipelines that produced a deploy row — i.e. ones DORA can see. */\n  deployTrackedPipelines: number;\n  /** By `creation_source`, for \"are the golden paths being used\". */\n  bySource: Record<string, number>;\n  /** Teams in the rollup that had activity. 1 for a single-org report. */\n  activeTeams: number;\n  /** Only when the org configured the assumption. Never platform-supplied. */\n  estimatedMinutesSaved: number | null;\n}\n\n/**\n * Adoption, coverage and creation source.\n *\n * `deployTrackedPipelines` is the honest denominator for everything DORA says: a\n * pipeline that has not re-synthed with deploy tags produces no deploy rows, so it\n * is invisible to deployment frequency — and reporting \"4 deploys\" without saying\n * that 20 of 30 pipelines cannot be seen is the single most misleading thing this\n * feature could do.\n */\nexport async function getAdoption(scope: AnalyticsScope, timeSavedMinutes?: number | null): Promise<AdoptionSummary> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    WITH scoped AS (\n      SELECT id::text AS id, org_id, creation_source\n      FROM pipelines\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND deleted_at IS NULL\n    ),\n    active AS (\n      SELECT DISTINCT pipeline_id, org_id\n      FROM execution_daily_rollups\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND day >= ${scope.from}::timestamptz AND day < ${scope.to}::timestamptz\n        AND stage_name = '' AND runs > 0\n    ),\n    tracked AS (\n      SELECT DISTINCT pipeline_id\n      FROM dora_deployments\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz\n    )\n    SELECT\n      (SELECT COUNT(*) FROM scoped)::int AS total_pipelines,\n      (SELECT COUNT(*) FROM active)::int AS active_pipelines,\n      (SELECT COUNT(DISTINCT org_id) FROM active)::int AS active_teams,\n      (SELECT COUNT(*) FROM tracked)::int AS deploy_tracked,\n      (SELECT COALESCE(jsonb_object_agg(COALESCE(creation_source, 'unknown'), n), '{}'::jsonb)\n         FROM (SELECT creation_source, COUNT(*)::int AS n FROM scoped GROUP BY creation_source) s\n      ) AS by_source\n  `));\n  const r = rowsOf(rows)[0] ?? {};\n  const created = num(r.total_pipelines);\n  return {\n    totalPipelines: created,\n    activePipelines: num(r.active_pipelines),\n    activeTeams: Math.max(1, num(r.active_teams)),\n    deployTrackedPipelines: num(r.deploy_tracked),\n    bySource: (r.by_source as Record<string, number>) ?? {},\n    // Only when the ORG configured the assumption — a platform-supplied number\n    // here would be the platform marking its own homework.\n    estimatedMinutesSaved: timeSavedMinutes && timeSavedMinutes > 0 ? created * timeSavedMinutes : null,\n  };\n}\n\n/** One pipeline's failure streak and last successful day. */\nexport interface PipelineStreakRow {\n  pipelineId: string;\n  /**\n   * Failures in the trailing run of days on which NOTHING succeeded.\n   *\n   * A LOWER BOUND, and deliberately so. The rollup is per day, so within the most\n   * recent day that did have a success there is no way to tell whether the failures\n   * came before or after it — that day is excluded rather than guessed at. What\n   * survives is a run of failures with no success anywhere between them, which is\n   * exactly the claim the finding makes.\n   */\n  consecutiveFailures: number;\n  /** The last day with at least one success, or null within the lookback. */\n  lastSuccessAt: Date | null;\n}\n\n/**\n * Failure streaks and last-success dates, for the needs-attention rules.\n *\n * Reads the daily rollup, not `pipeline_events` — the same reason as everything\n * else here: a streak that ended three weeks ago must still be readable after\n * retention has swept the events that produced it.\n *\n * `lookbackDays` extends PAST the window on purpose. \"Last succeeded 12 days ago\"\n * is the finding a weekly report most needs, and a query bounded by a 7-day window\n * could never produce it.\n */\nexport async function getPipelineStreaks(\n  scope: AnalyticsScope,\n  lookbackDays = 90,\n): Promise<PipelineStreakRow[]> {\n  const since = new Date(new Date(scope.to).getTime() - lookbackDays * 86_400_000).toISOString();\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    WITH days AS (\n      SELECT pipeline_id, day,\n             SUM(succeeded)::int AS succeeded,\n             SUM(failed)::int    AS failed\n      FROM execution_daily_rollups\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND day >= ${since}::timestamptz AND day < ${scope.to}::timestamptz\n      GROUP BY pipeline_id, day\n    ),\n    last_ok AS (\n      SELECT pipeline_id, MAX(day) AS last_success_day\n      FROM days WHERE succeeded > 0\n      GROUP BY pipeline_id\n    )\n    SELECT d.pipeline_id,\n           l.last_success_day,\n           COALESCE(SUM(d.failed) FILTER (\n             WHERE l.last_success_day IS NULL OR d.day > l.last_success_day\n           ), 0)::int AS streak\n    FROM days d\n    LEFT JOIN last_ok l ON l.pipeline_id = d.pipeline_id\n    GROUP BY d.pipeline_id, l.last_success_day\n  `));\n  return rowsOf(rows).map((r) => ({\n    pipelineId: String(r.pipeline_id),\n    consecutiveFailures: num(r.streak),\n    lastSuccessAt: r.last_success_day ? new Date(String(r.last_success_day)) : null,\n  }));\n}\n\n/**\n * Pipelines that RAN in the window but produced no deploy rows.\n *\n * A measurement gap, not a failure, and the reason a deployment-frequency number can\n * be quietly wrong: a pipeline whose synth predates the `pb.deploys` tags deploys\n * perfectly well and is invisible to every DORA aggregate. Nothing else in the\n * report would say so.\n */\nexport async function getUntrackedPipelines(scope: AnalyticsScope): Promise<string[]> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    WITH active AS (\n      SELECT pipeline_id\n      FROM execution_daily_rollups\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND day >= ${scope.from}::timestamptz AND day < ${scope.to}::timestamptz\n        AND stage_name = ''\n      GROUP BY pipeline_id\n      HAVING SUM(runs) > 0\n    ),\n    tracked AS (\n      SELECT DISTINCT pipeline_id\n      FROM dora_deployments\n      WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n        AND deployed_at >= ${scope.from}::timestamptz AND deployed_at < ${scope.to}::timestamptz\n    )\n    SELECT a.pipeline_id FROM active a\n    WHERE NOT EXISTS (SELECT 1 FROM tracked t WHERE t.pipeline_id = a.pipeline_id)\n  `));\n  return rowsOf(rows).map((r) => String(r.pipeline_id));\n}\n\n/**\n * Pipelines running a plugin version with an OPEN Critical exposure.\n *\n * Point-in-time, not windowed: what matters is whether the pipeline is running one\n * NOW. A Critical that was open last Tuesday and is fixed today is not something to\n * put in front of a manager, and `fixed_at` is what says so.\n *\n * An ACCEPTED exposure is excluded. Someone with the authority to accept a risk has\n * already decided about it in writing, with a reason and a deadline; re-raising it\n * weekly is how a report teaches its reader to skip a section. The lapse of that\n * acceptance is a separate finding (`lapsedAcceptances`).\n */\nexport async function getVulnerablePipelines(scope: AnalyticsScope): Promise<string[]> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT DISTINCT pipeline_id\n    FROM plugin_vuln_exposure\n    WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n      AND fixed_at IS NULL\n      AND critical_count > 0\n      AND triage_state <> 'accepted'\n  `));\n  return rowsOf(rows).map((r) => String(r.pipeline_id));\n}\n\n/**\n * When each pipeline in the window was last changed.\n *\n * `pipelines.updated_at`, not an audit query: the audit trail lives in another store\n * with its own retention, and the one fact this needs — \"was this touched shortly\n * before it broke\" — is already on the row, durably, in the same transaction the\n * change was made in.\n *\n * The consequence is stated rather than hidden: `updated_at` moves for ANY write,\n * including a rename. So the finding says \"after a configuration change\", which is\n * true of a rename too, and does not claim to name the change.\n */\nexport async function getPipelineConfigChanges(scope: AnalyticsScope): Promise<Map<string, Date>> {\n  const rows = await withTenantTx((tx) => tx.execute(sql`\n    SELECT id::text AS id, updated_at\n    FROM pipelines\n    WHERE org_id ${scope.orgIds?.length ? sql`= ANY(${scope.orgIds})` : sql`= ${scope.orgId}`}\n      AND deleted_at IS NULL\n      AND updated_at IS NOT NULL\n  `));\n  const out = new Map<string, Date>();\n  for (const r of rowsOf(rows)) {\n    const at = r.updated_at ? new Date(String(r.updated_at)) : null;\n    if (at && !Number.isNaN(at.getTime())) out.set(String(r.id), at);\n  }\n  return out;\n}\n\n// ── Helpers ─────────────────────────────────────────────────────────────────\n\n/** Rows from a raw `execute`, whichever shape the driver returned. */\nfunction rowsOf(result: unknown): Array<Record<string, unknown>> {\n  if (Array.isArray(result)) return result as Array<Record<string, unknown>>;\n  const rows = (result as { rows?: unknown })?.rows;\n  return Array.isArray(rows) ? rows as Array<Record<string, unknown>> : [];\n}\n\n/** A count from a driver that may hand back a string for a bigint. */\nfunction num(v: unknown): number {\n  const n = typeof v === 'number' ? v : Number(v ?? 0);\n  return Number.isFinite(n) ? n : 0;\n}\n\nfunction isoOrNull(v: unknown): string | null {\n  if (!v) return null;\n  const d = v instanceof Date ? v : new Date(String(v));\n  return Number.isNaN(d.getTime()) ? null : d.toISOString();\n}\n"]}