@pipeline-builder/pipeline-data 4.1.1 → 4.1.3

package/lib/api/reporting/dora.js

@@ -0,0 +1,501 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * DORA metrics: the four headline measures, their per-environment breakdown,
+ * the trend series, and per-pipeline build health.
+ *
+ * By far the largest domain in the reporting service (~490 lines of query +
+ * shaping against six row shapes), which is why it lives in its own module.
+ * ReportingService delegates to these; the banding thresholds they apply are in
+ * ./dora-scoring.ts, deliberately separate so they can be tested without a DB.
+ */
+import { sql } from 'drizzle-orm';
+import { HEADLINE_ENV, DORA_INCIDENT_WINDOW_HOURS, resolveIncidentWindowHours, doraLevelForFrequency, doraLevelForChangeFailure, doraLevelForRestore, doraLevelForLeadTime, round, median, } from './dora-scoring.js';
+import { orgScope, runReport } from './query-scope.js';
+import { assertReportInterval, terminalStatusRollup } from './sql-helpers.js';
+import { schema } from '../../database/drizzle-schema.js';
+import { withTenantTx } from '../../database/tenancy.js';
+import { drizzleRows } from '../crud-service.js';
+/**
+ * 1.9 DORA metrics over a [from,to] deploy-completion window, org-scoped +
+ * rollup-aware. DEPLOY-BASIS ONLY — every metric derives from real deploy-stage
+ * executions (`event_type='STAGE'` with a non-null `environment`, set by the
+ * forwarder for the stages a user declared in `pb.deploys`). No run-based
+ * fallback: a pipeline with no deploy stage produces no DORA data.
+ *
+ * Four scoped SQL scans run inside one tx (each org-gated by `p.org_id ${pred}`
+ * / `o.org_id ${pred}` so a rollup passes the org→team subtree and a foreign
+ * org's rows never enter): (1) terminal deploy rows PER (execution, env) — one
+ * "deployment" = one execution reaching an env (D1) — → DF / deploy-time CFR /
+ * measured lead time (lead time joins the execution's earliest commit, D2);
+ * the scan also reaches back `windowHours` before `from` so incidents opened
+ * near the window start can correlate to a just-prior deploy; (2) `deployment_outcomes`
+ * in-window → post-deploy CFR component; (3) production restored/failed
+ * outcomes joined to their deploy → MTTR; (4) registry vs deploying → coverage.
+ * The cross-source medians (lead time, MTTR) are computed in JS from clamped
+ * (≥0) deltas.
+ *
+ * @param opts.pipelineId    restrict to one pipeline (per-pipeline DORA)
+ * @param opts.environment   restrict to one deploy environment
+ */
+export async function getDoraMetrics(orgId, from, to, orgIds, opts = {}) {
+    const { pred, multi } = orgScope(orgId, orgIds);
+    const { pipelineId, environment } = opts;
+    const pipelineClause = pipelineId ? sql `AND e.pipeline_id = ${pipelineId}` : sql ``;
+    const pipelineClauseR = pipelineId ? sql `AND r.pipeline_id = ${pipelineId}` : sql ``;
+    const envClause = environment ? sql `AND e.environment = ${environment}` : sql ``;
+    const outcomeEnvClause = environment ? sql `AND o.environment = ${environment}` : sql ``;
+    const incidentEnvClause = environment ? sql `AND i.environment = ${environment}` : sql ``;
+    // Effective incident-correlation window (per-org override or the global
+    // default). Computed here (not just in shapeDora) because the deploy scan
+    // needs it for BOTH the correlation look-back lower bound AND the cache key.
+    const effectiveWindowHours = resolveIncidentWindowHours(opts.incidentWindowHours);
+    // Correlation look-back: incidents opened just inside `from` can attribute to
+    // a deploy that completed up to `windowHours` BEFORE `from` (mirrors the
+    // LATERAL look-back in listIncidents). Widen the deploy scan's lower bound to
+    // `from − windowHours`; DF/CFR/lead still count only the in-`from`..`to`
+    // subset (flagged by `in_window`), while correlation sees the wider set.
+    const fromMs = Date.parse(from);
+    const lookbackFrom = Number.isFinite(fromMs)
+        ? new Date(fromMs - effectiveWindowHours * 3600 * 1000).toISOString()
+        : from;
+    // (1) Terminal deploy rows: PER-EXECUTION (D1), one row per (environment,
+    // execution) — every deploy STAGE targeting that env within the execution is
+    // rolled up to a terminal status (FAILED wins, then SUCCEEDED). A single
+    // execution with two deploy stages to the same env is ONE deployment, not two.
+    // completed_at = the deploy's completion (MAX over its stages). `commit_ts`
+    // (D2) is the execution's EARLIEST commit time across ALL its events (commit
+    // enrichment rides the PIPELINE/source event where environment IS NULL, never
+    // the deploy STAGE row), joined by execution_id. `in_window` marks whether the
+    // deploy completed inside [from,to] (vs. a look-back-only row kept solely for
+    // incident correlation). execution_id is projected so post-deploy failures
+    // (manual outcomes + correlated incidents) can dedup against their deploy.
+    const deploySql = sql `
+      WITH deploy_stages AS (
+        SELECT
+          e.environment AS environment,
+          e.execution_id AS execution_id,
+          ${terminalStatusRollup} AS status,
+          MAX(e.completed_at) AS completed_at
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.environment IS NOT NULL
+          ${pipelineClause} ${envClause}
+          AND e.completed_at >= ${lookbackFrom}::timestamptz AND e.completed_at <= ${to}::timestamptz
+        GROUP BY e.environment, e.execution_id
+      ),
+      exec_commits AS (
+        SELECT c.execution_id AS execution_id, MIN(c.commit_timestamp) AS commit_ts
+        FROM ${schema.pipelineEvent} c
+        JOIN ${schema.pipeline} p ON p.id = c.pipeline_id
+        WHERE p.org_id ${pred} AND c.commit_timestamp IS NOT NULL
+          AND c.execution_id IN (SELECT execution_id FROM deploy_stages)
+        GROUP BY c.execution_id
+      )
+      SELECT
+        ds.environment AS environment,
+        ds.execution_id AS execution_id,
+        ds.status AS status,
+        ds.completed_at::text AS completed_at,
+        (ds.completed_at >= ${from}::timestamptz) AS in_window,
+        ec.commit_ts::text AS commit_ts
+      FROM deploy_stages ds
+      LEFT JOIN exec_commits ec ON ec.execution_id = ds.execution_id`;
+    // (2) Post-deploy outcome markers in-window (per env). Post-deploy failures
+    // (outcome='failed') add to the CFR numerator without changing attempts.
+    // execution_id lets the CFR dedup a manual failure against an incident that
+    // correlates to the same deploy (no double-count).
+    const outcomeSql = sql `
+      SELECT o.environment AS environment, o.outcome AS outcome, o.execution_id AS execution_id
+      FROM ${schema.deploymentOutcome} o
+      WHERE o.org_id ${pred} ${outcomeEnvClause}
+        AND o.at >= ${from}::timestamptz AND o.at <= ${to}::timestamptz`;
+    // (3) MTTR — PRODUCTION-ONLY, independent of the env filter. Every production
+    // outcome in-window; for a 'restored' one, correlate to its deploy's
+    // completion via execution_id to measure restored.at − deployed.completed_at.
+    // execution_id is projected so an incident-sourced recovery for the same
+    // deploy takes precedence over the manual restored gap.
+    const mttrSql = sql `
+      SELECT
+        o.outcome AS outcome,
+        o.execution_id AS execution_id,
+        o.at::text AS restored_at,
+        (SELECT MAX(d.completed_at) FROM ${schema.pipelineEvent} d
+           JOIN ${schema.pipeline} p2 ON p2.id = d.pipeline_id
+           WHERE p2.org_id ${pred} AND d.execution_id = o.execution_id
+             AND d.event_type = 'STAGE' AND d.environment = ${HEADLINE_ENV})::text AS deployed_at
+      FROM ${schema.deploymentOutcome} o
+      WHERE o.org_id ${pred} AND o.environment = ${HEADLINE_ENV}
+        AND o.at >= ${from}::timestamptz AND o.at <= ${to}::timestamptz`;
+    // (5) Incidents opened in-window (per env). Correlated in JS to the most
+    // recent successful deploy → automated post-deploy failure (CFR) + real
+    // recovery time (resolved_at − opened_at) for MTTR (production).
+    const incidentSql = sql `
+      SELECT i.environment AS environment, i.opened_at::text AS opened_at, i.resolved_at::text AS resolved_at
+      FROM ${schema.incident} i
+      WHERE i.org_id ${pred} ${incidentEnvClause}
+        AND i.opened_at >= ${from}::timestamptz AND i.opened_at <= ${to}::timestamptz`;
+    // (4) Coverage: registered pipelines vs those that actually deployed in-window.
+    const coverageSql = sql `
+      SELECT
+        (SELECT COUNT(*)::int FROM ${schema.pipelineRegistry} r
+           WHERE r.org_id ${pred} ${pipelineClauseR}) AS registered,
+        (SELECT COUNT(DISTINCT e.pipeline_id)::int FROM ${schema.pipelineEvent} e
+           JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+           WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.environment IS NOT NULL
+             ${pipelineClause} ${envClause}
+             AND e.completed_at >= ${from}::timestamptz AND e.completed_at <= ${to}::timestamptz) AS deploying`;
+    const exec = () => withTenantTx(async (tx) => {
+        // Scan order is load-bearing for the generated-SQL tests: 0=deploy,
+        // 1=outcomes, 2=mttr, 3=coverage, 4=incidents (appended last so the
+        // earlier indices stay stable).
+        const deployRows = drizzleRows((await tx.execute(deploySql)).rows);
+        const outcomeRows = drizzleRows((await tx.execute(outcomeSql)).rows);
+        const mttrRows = drizzleRows((await tx.execute(mttrSql)).rows);
+        const coverageRow = drizzleRows((await tx.execute(coverageSql)).rows)[0];
+        const incidentRows = drizzleRows((await tx.execute(incidentSql)).rows);
+        return shapeDora(deployRows, outcomeRows, mttrRows, coverageRow, incidentRows, from, to, {
+            pipelineId, environment,
+        }, effectiveWindowHours);
+    });
+    // Cache key MUST include the effective incident window: the scorecard reads
+    // /dora with the org's default window while an explicit /dora call may pass an
+    // override — different windows yield different CFR/MTTR, so they must not
+    // collide on the same key.
+    const key = `${orgId}:dora:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}:${effectiveWindowHours}`;
+    return runReport(key, multi, exec);
+}
+/**
+ * Shape the raw DORA scan rows into the public {@link DoraMetrics}. Buckets the
+ * terminal deploy rows by environment (DF / deploy-time CFR / measured lead),
+ * folds in the post-deploy failure counts (manual outcomes + webhook-ingested
+ * incidents, deduped by deploy execution), computes production MTTR from both
+ * sources (incident `resolved_at − opened_at` taking precedence over the manual
+ * `restored − deployed`), and reconciles coverage — all cross-source medians
+ * over deltas clamped ≥0.
+ *
+ * Phase 5 incident correlation: each incident is attributed to the most recent
+ * SUCCESSFUL deploy to its environment with `completed_at ≤ opened_at` within
+ * {@link DORA_INCIDENT_WINDOW_HOURS}. That deploy is a post-deploy failure; an
+ * uncorrelated incident (no eligible deploy) contributes nothing.
+ */
+function shapeDora(deployRows, outcomeRows, mttrRows, coverageRow, incidentRows, from, to, filters, windowHours = DORA_INCIDENT_WINDOW_HOURS) {
+    // Window length in days (floored at 1 so a sub-day window yields the count as
+    // the rate, never /0 or an extrapolation). Guard unparseable dates → 1 day.
+    const spanDays = (Date.parse(to) - Date.parse(from)) / 86400000;
+    const days = Number.isFinite(spanDays) ? Math.max(spanDays, 1) : 1;
+    // Window end instant for MTTR right-censoring (a resolution after `to` is
+    // unobserved). +Infinity when `to` is unparseable ⇒ no censoring (fail-open).
+    const toParsed = Date.parse(to);
+    const toMs = Number.isFinite(toParsed) ? toParsed : Number.POSITIVE_INFINITY;
+    const envs = new Map();
+    const accFor = (env) => {
+        let a = envs.get(env);
+        if (!a) {
+            a = { deployments: 0, deployTimeFailures: 0, attempts: 0, leadGaps: [] };
+            envs.set(env, a);
+        }
+        return a;
+    };
+    // A deploy row counts toward DF/CFR/lead only if it completed inside [from,to].
+    // Look-back-only rows (in_window=false, kept for incident correlation) are
+    // skipped here. Absent in a fixture ⇒ in-window (unit tests omit the flag).
+    const isInWindow = (row) => row.in_window == null ? true : (row.in_window === true || row.in_window === 't');
+    for (const row of deployRows) {
+        const env = row.environment;
+        if (!env)
+            continue;
+        if (!isInWindow(row))
+            continue; // look-back-only row → correlation, not DF/CFR
+        const a = accFor(env);
+        if (row.status === 'SUCCEEDED') {
+            a.deployments++;
+            a.attempts++;
+            // Measured lead time: deploy completion − execution's earliest commit time.
+            if (row.commit_ts != null && row.completed_at != null) {
+                const gap = (Date.parse(row.completed_at) - Date.parse(row.commit_ts)) / 1000;
+                if (Number.isFinite(gap))
+                    a.leadGaps.push(Math.max(gap, 0));
+            }
+        }
+        else if (row.status === 'FAILED') {
+            a.deployTimeFailures++;
+            a.attempts++;
+        }
+    }
+    // Incident→deploy correlation (Phase 5). Index the SUCCESSFUL deploys per env
+    // (execution id + completion instant), newest first, so each incident can be
+    // attributed to the most recent deploy that completed within the window
+    // before it opened. That execution is a post-deploy failure.
+    const windowMs = windowHours * 3600 * 1000;
+    const successfulByEnv = new Map();
+    for (const row of deployRows) {
+        if (row.status !== 'SUCCEEDED' || !row.environment || row.execution_id == null || row.completed_at == null)
+            continue;
+        const ms = Date.parse(row.completed_at);
+        if (!Number.isFinite(ms))
+            continue;
+        const list = successfulByEnv.get(row.environment) ?? [];
+        list.push({ exec: row.execution_id, completedMs: ms });
+        successfulByEnv.set(row.environment, list);
+    }
+    for (const list of successfulByEnv.values())
+        list.sort((a, b) => b.completedMs - a.completedMs);
+    /** Correlate an incident to the most recent in-window successful deploy execution. */
+    const correlate = (env, openedMs) => {
+        const list = successfulByEnv.get(env);
+        if (!list)
+            return null;
+        for (const d of list) {
+            if (d.completedMs <= openedMs && openedMs - d.completedMs <= windowMs)
+                return d.exec;
+        }
+        return null;
+    };
+    const correlatedIncidents = [];
+    for (const inc of incidentRows) {
+        if (!inc.environment || inc.opened_at == null)
+            continue;
+        const openedMs = Date.parse(inc.opened_at);
+        if (!Number.isFinite(openedMs))
+            continue;
+        const exec = correlate(inc.environment, openedMs);
+        if (exec == null)
+            continue; // uncorrelated → not attributable to a deploy
+        let resolvedGap = null;
+        if (inc.resolved_at != null) {
+            const resolvedMs = Date.parse(inc.resolved_at);
+            // Right-censoring: a resolution AFTER the window end (`to`) is not observed
+            // within the window — treat the incident as still open (gap stays null) so
+            // MTTR never reads unbounded past `to`. The incident still counts toward the
+            // incident total (unresolved), it just contributes no recovery time.
+            if (Number.isFinite(resolvedMs) && resolvedMs <= toMs) {
+                const g = (resolvedMs - openedMs) / 1000;
+                if (Number.isFinite(g))
+                    resolvedGap = Math.max(g, 0);
+            }
+        }
+        correlatedIncidents.push({ environment: inc.environment, exec, resolvedGap });
+    }
+    // Post-deploy failures per env — the DISTINCT set of deploy executions flagged
+    // by a manual `failed` outcome OR a correlated incident (deduped by execution,
+    // so a deploy flagged by both counts once). A manual outcome without an
+    // execution id (legacy/unresolvable) still counts via a per-row sentinel.
+    const postDeployExecsByEnv = new Map();
+    let sentinel = 0;
+    const flagFor = (env) => {
+        let s = postDeployExecsByEnv.get(env);
+        if (!s) {
+            s = new Set();
+            postDeployExecsByEnv.set(env, s);
+        }
+        return s;
+    };
+    for (const o of outcomeRows) {
+        if (o.outcome !== 'failed' || !o.environment)
+            continue;
+        flagFor(o.environment).add(o.execution_id ?? `manual-${sentinel++}`);
+        accFor(o.environment); // ensure env appears even with no deploy events
+    }
+    for (const ci of correlatedIncidents) {
+        flagFor(ci.environment).add(ci.exec);
+        accFor(ci.environment); // ensure env appears even if the deploy is out-of-window
+    }
+    const postDeployByEnv = new Map();
+    for (const [env, set] of postDeployExecsByEnv)
+        postDeployByEnv.set(env, set.size);
+    const environments = [...envs.entries()]
+        .map(([environment, a]) => {
+        const postDeployFailures = postDeployByEnv.get(environment) ?? 0;
+        const rawPerDay = a.deployments / days;
+        const numerator = a.deployTimeFailures + postDeployFailures;
+        // Clamp to [0,100]: post-deploy failures can correlate to a deploy that
+        // completed just before the window (kept for correlation), so the numerator
+        // can transiently exceed in-window attempts — a CFR > 100% is never valid.
+        const rawRate = a.attempts > 0 ? Math.min(100, (numerator / a.attempts) * 100) : 0;
+        const ltMedian = median(a.leadGaps);
+        return {
+            environment,
+            deploymentFrequency: {
+                deployments: a.deployments,
+                perDay: round(rawPerDay, 2),
+                level: doraLevelForFrequency(rawPerDay, a.deployments),
+            },
+            changeFailureRate: {
+                rate: round(rawRate, 1),
+                deployTimeFailures: a.deployTimeFailures,
+                postDeployFailures,
+                attempts: a.attempts,
+                level: doraLevelForChangeFailure(rawRate, a.attempts),
+            },
+            leadTime: {
+                deployments: a.leadGaps.length,
+                medianSeconds: ltMedian != null ? round(ltMedian, 1) : null,
+                level: doraLevelForLeadTime(ltMedian),
+            },
+        };
+    })
+        .sort((x, y) => {
+        if (x.environment === HEADLINE_ENV)
+            return -1;
+        if (y.environment === HEADLINE_ENV)
+            return 1;
+        return x.environment.localeCompare(y.environment);
+    });
+    // MTTR — PRODUCTION-ONLY, from BOTH sources. Incidents take precedence: a
+    // production incident correlated to a deploy contributes the real recovery
+    // (`resolved_at − opened_at`), and any manual outcome on the SAME deploy is
+    // skipped. Manual outcomes on other deploys keep the Phase-2 behavior
+    // (`failed` → an incident; `restored` → a recovery gap of `restored − deployed`).
+    let incidents = 0, restored = 0;
+    const mttrGaps = [];
+    // Executions already attributed to a production incident (precedence guard).
+    const incidentExecs = new Set();
+    for (const ci of correlatedIncidents) {
+        if (ci.environment !== HEADLINE_ENV)
+            continue; // MTTR is production-only
+        incidents++;
+        incidentExecs.add(ci.exec);
+        if (ci.resolvedGap != null) {
+            restored++;
+            mttrGaps.push(ci.resolvedGap);
+        }
+    }
+    for (const m of mttrRows) {
+        // Incident precedence: don't double-count a deploy already flagged by an incident.
+        if (m.execution_id != null && incidentExecs.has(m.execution_id))
+            continue;
+        if (m.outcome === 'failed') {
+            incidents++;
+            continue;
+        }
+        if (m.outcome === 'restored') {
+            restored++;
+            if (m.restored_at != null && m.deployed_at != null) {
+                const gap = (Date.parse(m.restored_at) - Date.parse(m.deployed_at)) / 1000;
+                if (Number.isFinite(gap))
+                    mttrGaps.push(Math.max(gap, 0));
+            }
+        }
+    }
+    const mttrMedian = median(mttrGaps);
+    const registered = Number(coverageRow?.registered) || 0;
+    const deploying = Number(coverageRow?.deploying) || 0;
+    return {
+        window: { from, to },
+        filters: { pipelineId: filters.pipelineId ?? null, environment: filters.environment ?? null },
+        headline: HEADLINE_ENV,
+        environments,
+        meanTimeToRestore: {
+            incidents,
+            restored,
+            medianSeconds: mttrMedian != null ? round(mttrMedian, 1) : null,
+            level: doraLevelForRestore(mttrMedian),
+        },
+        coverage: {
+            registered,
+            deploying,
+            withoutDeploys: Math.max(registered - deploying, 0),
+        },
+    };
+}
+/**
+ * 1.9b DORA trend — deployment frequency + deploy-time change-failure rate
+ * bucketed by `interval` (day/week/month) for a sparkline. Deploy-basis like
+ * getDoraMetrics: buckets terminal deploy-stage executions on their
+ * `completed_at`. Shares the org/rollup + pipelineId/environment scoping. MTTR,
+ * lead time, and post-deploy CFR are intentionally omitted (too heavy to bucket).
+ */
+export async function getDoraTrend(orgId, interval, from, to, orgIds, opts = {}) {
+    assertReportInterval(interval);
+    const { pred, multi } = orgScope(orgId, orgIds);
+    const { pipelineId, environment } = opts;
+    const pipelineClause = pipelineId ? sql `AND e.pipeline_id = ${pipelineId}` : sql ``;
+    const envClause = environment ? sql `AND e.environment = ${environment}` : sql ``;
+    const exec = () => withTenantTx((tx) => tx.execute(sql `
+      WITH deploys AS (
+        -- PER-EXECUTION deploy unit (D1): one row per (environment, execution),
+        -- every deploy STAGE to that env within the execution rolled up to a
+        -- single terminal status — NOT one row per stage.
+        SELECT
+          ${terminalStatusRollup} AS status,
+          MAX(e.completed_at) AS completed_at
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.environment IS NOT NULL
+          ${pipelineClause} ${envClause}
+          AND e.completed_at >= ${from}::timestamptz AND e.completed_at <= ${to}::timestamptz
+        GROUP BY e.environment, e.execution_id
+      )
+      SELECT
+        DATE_TRUNC(${interval}, completed_at)::text AS period,
+        COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS deployments,
+        COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failed,
+        COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED'))::int AS total,
+        -- quoted alias so the raw row key is exactly the DoraTrendPoint field
+        COALESCE(ROUND(COUNT(*) FILTER (WHERE status = 'FAILED')::numeric
+          / NULLIF(COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED')), 0) * 100, 1), 0)::float AS "changeFailurePct"
+      FROM deploys
+      GROUP BY period ORDER BY period
+    `).then(r => drizzleRows(r.rows)));
+    const key = `${orgId}:dora-trend:${interval}:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}`;
+    return runReport(key, multi, exec);
+}
+/**
+ * 1.10 Per-pipeline BUILD HEALTH (Phase 6) — a standard (NOT `advanced_reporting`)
+ * per-stage breakdown for one pipeline over a [from,to] window. Aggregates the
+ * existing `pipeline_events` STAGE rows: each stage is rolled up per execution
+ * to a terminal status (FAILED wins, then SUCCEEDED) + its max duration, then
+ * grouped per stage into run/success/failure counts, a success rate, and
+ * duration percentiles (p50/p90/p99). Totals sum across stages. Org-scoped via
+ * the pipeline join (`p.org_id ${pred}`) + rollup-aware like the sibling reports;
+ * a pipelineId owned by another org returns an empty breakdown.
+ */
+export async function getBuildHealth(orgId, pipelineId, from, to, orgIds) {
+    const { pred, multi } = orgScope(orgId, orgIds);
+    const exec = () => withTenantTx(async (tx) => {
+        const rows = drizzleRows((await tx.execute(sql `
+      WITH stage_runs AS (
+        SELECT
+          e.stage_name AS stage,
+          ${terminalStatusRollup} AS status,
+          MAX(e.duration_ms) AS duration_ms
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.pipeline_id = ${pipelineId}
+          AND e.event_type = 'STAGE' AND e.stage_name IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY e.stage_name, e.execution_id
+      )
+      SELECT
+        stage,
+        COUNT(*)::int AS runs,
+        COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS successes,
+        COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failures,
+        COALESCE(ROUND(COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::numeric
+          / NULLIF(COUNT(*), 0) * 100, 1), 0)::float AS "successRate",
+        PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY duration_ms)::int AS "p50Ms",
+        PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY duration_ms)::int AS "p90Ms",
+        PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY duration_ms)::int AS "p99Ms"
+      FROM stage_runs
+      WHERE status IN ('SUCCEEDED', 'FAILED')
+      GROUP BY stage
+      ORDER BY runs DESC, stage
+    `)).rows);
+        // Totals sum across stages (total stage-runs / stage-failures in the window).
+        let runs = 0, failures = 0;
+        for (const s of rows) {
+            runs += s.runs;
+            failures += s.failures;
+        }
+        const failureRate = runs > 0 ? round((failures / runs) * 100, 1) : 0;
+        return { stages: rows, totals: { runs, failures, failureRate } };
+    });
+    return runReport(`${orgId}:build-health:${pipelineId}:${from}:${to}`, multi, exec);
+}
+// ── Category 2: Plugin Inventory & Builds ──
+/** 2.1 Plugin summary — counts and breakdowns.
+ *  INTENTIONALLY SINGLE-ORG (no rollup): plugin inventory is an org-owned
+ *  asset count, not an execution/build activity report, so a parent's view is
+ *  its own plugins — teams manage their own inventory. Single `= $org` scope. */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dora.js","sourceRoot":"","sources":["../../../src/api/reporting/dora.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * DORA metrics: the four headline measures, their per-environment breakdown,\n * the trend series, and per-pipeline build health.\n *\n * By far the largest domain in the reporting service (~490 lines of query +\n * shaping against six row shapes), which is why it lives in its own module.\n * ReportingService delegates to these; the banding thresholds they apply are in\n * ./dora-scoring.ts, deliberately separate so they can be tested without a DB.\n */\n\nimport { sql } from 'drizzle-orm';\nimport {\n  HEADLINE_ENV, DORA_INCIDENT_WINDOW_HOURS, resolveIncidentWindowHours,\n  doraLevelForFrequency, doraLevelForChangeFailure, doraLevelForRestore, doraLevelForLeadTime,\n  round, median,\n} from './dora-scoring.js';\nimport { orgScope, runReport } from './query-scope.js';\nimport { assertReportInterval, terminalStatusRollup } from './sql-helpers.js';\nimport type {\n  DoraOptions, DoraMetrics, DoraEnvMetrics, DoraTrendPoint, BuildHealth, BuildHealthStage,\n  DeployRow, OutcomeRow, MttrPairRow, IncidentRow, CoverageRow,\n} from './types.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport { withTenantTx } from '../../database/tenancy.js';\nimport { drizzleRows } from '../crud-service.js';\n\n/**\n * 1.9 DORA metrics over a [from,to] deploy-completion window, org-scoped +\n * rollup-aware. DEPLOY-BASIS ONLY — every metric derives from real deploy-stage\n * executions (`event_type='STAGE'` with a non-null `environment`, set by the\n * forwarder for the stages a user declared in `pb.deploys`). No run-based\n * fallback: a pipeline with no deploy stage produces no DORA data.\n *\n * Four scoped SQL scans run inside one tx (each org-gated by `p.org_id ${pred}`\n * / `o.org_id ${pred}` so a rollup passes the org→team subtree and a foreign\n * org's rows never enter): (1) terminal deploy rows PER (execution, env) — one\n * \"deployment\" = one execution reaching an env (D1) — → DF / deploy-time CFR /\n * measured lead time (lead time joins the execution's earliest commit, D2);\n * the scan also reaches back `windowHours` before `from` so incidents opened\n * near the window start can correlate to a just-prior deploy; (2) `deployment_outcomes`\n * in-window → post-deploy CFR component; (3) production restored/failed\n * outcomes joined to their deploy → MTTR; (4) registry vs deploying → coverage.\n * The cross-source medians (lead time, MTTR) are computed in JS from clamped\n * (≥0) deltas.\n *\n * @param opts.pipelineId    restrict to one pipeline (per-pipeline DORA)\n * @param opts.environment   restrict to one deploy environment\n */\nexport async function getDoraMetrics(\n  orgId: string,\n  from: string,\n  to: string,\n  orgIds?: string[],\n  opts: DoraOptions = {},\n): Promise<DoraMetrics> {\n  const { pred, multi } = orgScope(orgId, orgIds);\n  const { pipelineId, environment } = opts;\n  const pipelineClause = pipelineId ? sql`AND e.pipeline_id = ${pipelineId}` : sql``;\n  const pipelineClauseR = pipelineId ? sql`AND r.pipeline_id = ${pipelineId}` : sql``;\n  const envClause = environment ? sql`AND e.environment = ${environment}` : sql``;\n  const outcomeEnvClause = environment ? sql`AND o.environment = ${environment}` : sql``;\n  const incidentEnvClause = environment ? sql`AND i.environment = ${environment}` : sql``;\n\n  // Effective incident-correlation window (per-org override or the global\n  // default). Computed here (not just in shapeDora) because the deploy scan\n  // needs it for BOTH the correlation look-back lower bound AND the cache key.\n  const effectiveWindowHours = resolveIncidentWindowHours(opts.incidentWindowHours);\n  // Correlation look-back: incidents opened just inside `from` can attribute to\n  // a deploy that completed up to `windowHours` BEFORE `from` (mirrors the\n  // LATERAL look-back in listIncidents). Widen the deploy scan's lower bound to\n  // `from − windowHours`; DF/CFR/lead still count only the in-`from`..`to`\n  // subset (flagged by `in_window`), while correlation sees the wider set.\n  const fromMs = Date.parse(from);\n  const lookbackFrom = Number.isFinite(fromMs)\n    ? new Date(fromMs - effectiveWindowHours * 3600 * 1000).toISOString()\n    : from;\n\n  // (1) Terminal deploy rows: PER-EXECUTION (D1), one row per (environment,\n  // execution) — every deploy STAGE targeting that env within the execution is\n  // rolled up to a terminal status (FAILED wins, then SUCCEEDED). A single\n  // execution with two deploy stages to the same env is ONE deployment, not two.\n  // completed_at = the deploy's completion (MAX over its stages). `commit_ts`\n  // (D2) is the execution's EARLIEST commit time across ALL its events (commit\n  // enrichment rides the PIPELINE/source event where environment IS NULL, never\n  // the deploy STAGE row), joined by execution_id. `in_window` marks whether the\n  // deploy completed inside [from,to] (vs. a look-back-only row kept solely for\n  // incident correlation). execution_id is projected so post-deploy failures\n  // (manual outcomes + correlated incidents) can dedup against their deploy.\n  const deploySql = sql`\n      WITH deploy_stages AS (\n        SELECT\n          e.environment AS environment,\n          e.execution_id AS execution_id,\n          ${terminalStatusRollup} AS status,\n          MAX(e.completed_at) AS completed_at\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.environment IS NOT NULL\n          ${pipelineClause} ${envClause}\n          AND e.completed_at >= ${lookbackFrom}::timestamptz AND e.completed_at <= ${to}::timestamptz\n        GROUP BY e.environment, e.execution_id\n      ),\n      exec_commits AS (\n        SELECT c.execution_id AS execution_id, MIN(c.commit_timestamp) AS commit_ts\n        FROM ${schema.pipelineEvent} c\n        JOIN ${schema.pipeline} p ON p.id = c.pipeline_id\n        WHERE p.org_id ${pred} AND c.commit_timestamp IS NOT NULL\n          AND c.execution_id IN (SELECT execution_id FROM deploy_stages)\n        GROUP BY c.execution_id\n      )\n      SELECT\n        ds.environment AS environment,\n        ds.execution_id AS execution_id,\n        ds.status AS status,\n        ds.completed_at::text AS completed_at,\n        (ds.completed_at >= ${from}::timestamptz) AS in_window,\n        ec.commit_ts::text AS commit_ts\n      FROM deploy_stages ds\n      LEFT JOIN exec_commits ec ON ec.execution_id = ds.execution_id`;\n\n  // (2) Post-deploy outcome markers in-window (per env). Post-deploy failures\n  // (outcome='failed') add to the CFR numerator without changing attempts.\n  // execution_id lets the CFR dedup a manual failure against an incident that\n  // correlates to the same deploy (no double-count).\n  const outcomeSql = sql`\n      SELECT o.environment AS environment, o.outcome AS outcome, o.execution_id AS execution_id\n      FROM ${schema.deploymentOutcome} o\n      WHERE o.org_id ${pred} ${outcomeEnvClause}\n        AND o.at >= ${from}::timestamptz AND o.at <= ${to}::timestamptz`;\n\n  // (3) MTTR — PRODUCTION-ONLY, independent of the env filter. Every production\n  // outcome in-window; for a 'restored' one, correlate to its deploy's\n  // completion via execution_id to measure restored.at − deployed.completed_at.\n  // execution_id is projected so an incident-sourced recovery for the same\n  // deploy takes precedence over the manual restored gap.\n  const mttrSql = sql`\n      SELECT\n        o.outcome AS outcome,\n        o.execution_id AS execution_id,\n        o.at::text AS restored_at,\n        (SELECT MAX(d.completed_at) FROM ${schema.pipelineEvent} d\n           JOIN ${schema.pipeline} p2 ON p2.id = d.pipeline_id\n           WHERE p2.org_id ${pred} AND d.execution_id = o.execution_id\n             AND d.event_type = 'STAGE' AND d.environment = ${HEADLINE_ENV})::text AS deployed_at\n      FROM ${schema.deploymentOutcome} o\n      WHERE o.org_id ${pred} AND o.environment = ${HEADLINE_ENV}\n        AND o.at >= ${from}::timestamptz AND o.at <= ${to}::timestamptz`;\n\n  // (5) Incidents opened in-window (per env). Correlated in JS to the most\n  // recent successful deploy → automated post-deploy failure (CFR) + real\n  // recovery time (resolved_at − opened_at) for MTTR (production).\n  const incidentSql = sql`\n      SELECT i.environment AS environment, i.opened_at::text AS opened_at, i.resolved_at::text AS resolved_at\n      FROM ${schema.incident} i\n      WHERE i.org_id ${pred} ${incidentEnvClause}\n        AND i.opened_at >= ${from}::timestamptz AND i.opened_at <= ${to}::timestamptz`;\n\n  // (4) Coverage: registered pipelines vs those that actually deployed in-window.\n  const coverageSql = sql`\n      SELECT\n        (SELECT COUNT(*)::int FROM ${schema.pipelineRegistry} r\n           WHERE r.org_id ${pred} ${pipelineClauseR}) AS registered,\n        (SELECT COUNT(DISTINCT e.pipeline_id)::int FROM ${schema.pipelineEvent} e\n           JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n           WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.environment IS NOT NULL\n             ${pipelineClause} ${envClause}\n             AND e.completed_at >= ${from}::timestamptz AND e.completed_at <= ${to}::timestamptz) AS deploying`;\n\n  const exec = () => withTenantTx(async (tx) => {\n    // Scan order is load-bearing for the generated-SQL tests: 0=deploy,\n    // 1=outcomes, 2=mttr, 3=coverage, 4=incidents (appended last so the\n    // earlier indices stay stable).\n    const deployRows = drizzleRows<DeployRow>((await tx.execute(deploySql)).rows);\n    const outcomeRows = drizzleRows<OutcomeRow>((await tx.execute(outcomeSql)).rows);\n    const mttrRows = drizzleRows<MttrPairRow & { outcome: string }>((await tx.execute(mttrSql)).rows);\n    const coverageRow = drizzleRows<CoverageRow>((await tx.execute(coverageSql)).rows)[0];\n    const incidentRows = drizzleRows<IncidentRow>((await tx.execute(incidentSql)).rows);\n    return shapeDora(deployRows, outcomeRows, mttrRows, coverageRow, incidentRows, from, to, {\n      pipelineId, environment,\n    }, effectiveWindowHours);\n  });\n  // Cache key MUST include the effective incident window: the scorecard reads\n  // /dora with the org's default window while an explicit /dora call may pass an\n  // override — different windows yield different CFR/MTTR, so they must not\n  // collide on the same key.\n  const key = `${orgId}:dora:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}:${effectiveWindowHours}`;\n  return runReport(key, multi, exec);\n}\n\n/**\n * Shape the raw DORA scan rows into the public {@link DoraMetrics}. Buckets the\n * terminal deploy rows by environment (DF / deploy-time CFR / measured lead),\n * folds in the post-deploy failure counts (manual outcomes + webhook-ingested\n * incidents, deduped by deploy execution), computes production MTTR from both\n * sources (incident `resolved_at − opened_at` taking precedence over the manual\n * `restored − deployed`), and reconciles coverage — all cross-source medians\n * over deltas clamped ≥0.\n *\n * Phase 5 incident correlation: each incident is attributed to the most recent\n * SUCCESSFUL deploy to its environment with `completed_at ≤ opened_at` within\n * {@link DORA_INCIDENT_WINDOW_HOURS}. That deploy is a post-deploy failure; an\n * uncorrelated incident (no eligible deploy) contributes nothing.\n */\nfunction shapeDora(\n  deployRows: DeployRow[],\n  outcomeRows: OutcomeRow[],\n  mttrRows: Array<MttrPairRow & { outcome: string }>,\n  coverageRow: CoverageRow | undefined,\n  incidentRows: IncidentRow[],\n  from: string,\n  to: string,\n  filters: { pipelineId?: string; environment?: string },\n  windowHours: number = DORA_INCIDENT_WINDOW_HOURS,\n): DoraMetrics {\n  // Window length in days (floored at 1 so a sub-day window yields the count as\n  // the rate, never /0 or an extrapolation). Guard unparseable dates → 1 day.\n  const spanDays = (Date.parse(to) - Date.parse(from)) / 86400000;\n  const days = Number.isFinite(spanDays) ? Math.max(spanDays, 1) : 1;\n  // Window end instant for MTTR right-censoring (a resolution after `to` is\n  // unobserved). +Infinity when `to` is unparseable ⇒ no censoring (fail-open).\n  const toParsed = Date.parse(to);\n  const toMs = Number.isFinite(toParsed) ? toParsed : Number.POSITIVE_INFINITY;\n\n  // Per-env accumulator.\n  interface Acc {\n    deployments: number;\n    deployTimeFailures: number;\n    attempts: number;\n    leadGaps: number[];\n  }\n  const envs = new Map<string, Acc>();\n  const accFor = (env: string): Acc => {\n    let a = envs.get(env);\n    if (!a) { a = { deployments: 0, deployTimeFailures: 0, attempts: 0, leadGaps: [] }; envs.set(env, a); }\n    return a;\n  };\n\n  // A deploy row counts toward DF/CFR/lead only if it completed inside [from,to].\n  // Look-back-only rows (in_window=false, kept for incident correlation) are\n  // skipped here. Absent in a fixture ⇒ in-window (unit tests omit the flag).\n  const isInWindow = (row: DeployRow): boolean =>\n    row.in_window == null ? true : (row.in_window === true || row.in_window === 't');\n\n  for (const row of deployRows) {\n    const env = row.environment;\n    if (!env) continue;\n    if (!isInWindow(row)) continue; // look-back-only row → correlation, not DF/CFR\n    const a = accFor(env);\n    if (row.status === 'SUCCEEDED') {\n      a.deployments++;\n      a.attempts++;\n      // Measured lead time: deploy completion − execution's earliest commit time.\n      if (row.commit_ts != null && row.completed_at != null) {\n        const gap = (Date.parse(row.completed_at) - Date.parse(row.commit_ts)) / 1000;\n        if (Number.isFinite(gap)) a.leadGaps.push(Math.max(gap, 0));\n      }\n    } else if (row.status === 'FAILED') {\n      a.deployTimeFailures++;\n      a.attempts++;\n    }\n  }\n\n  // Incident→deploy correlation (Phase 5). Index the SUCCESSFUL deploys per env\n  // (execution id + completion instant), newest first, so each incident can be\n  // attributed to the most recent deploy that completed within the window\n  // before it opened. That execution is a post-deploy failure.\n  const windowMs = windowHours * 3600 * 1000;\n  const successfulByEnv = new Map<string, Array<{ exec: string; completedMs: number }>>();\n  for (const row of deployRows) {\n    if (row.status !== 'SUCCEEDED' || !row.environment || row.execution_id == null || row.completed_at == null) continue;\n    const ms = Date.parse(row.completed_at);\n    if (!Number.isFinite(ms)) continue;\n    const list = successfulByEnv.get(row.environment) ?? [];\n    list.push({ exec: row.execution_id, completedMs: ms });\n    successfulByEnv.set(row.environment, list);\n  }\n  for (const list of successfulByEnv.values()) list.sort((a, b) => b.completedMs - a.completedMs);\n\n  /** Correlate an incident to the most recent in-window successful deploy execution. */\n  const correlate = (env: string, openedMs: number): string | null => {\n    const list = successfulByEnv.get(env);\n    if (!list) return null;\n    for (const d of list) {\n      if (d.completedMs <= openedMs && openedMs - d.completedMs <= windowMs) return d.exec;\n    }\n    return null;\n  };\n\n  // Correlated incidents (all envs → CFR; production subset → MTTR). Each carries\n  // the deploy execution it attributes to + its real recovery gap (when resolved).\n  interface CorrelatedIncident { environment: string; exec: string; resolvedGap: number | null }\n  const correlatedIncidents: CorrelatedIncident[] = [];\n  for (const inc of incidentRows) {\n    if (!inc.environment || inc.opened_at == null) continue;\n    const openedMs = Date.parse(inc.opened_at);\n    if (!Number.isFinite(openedMs)) continue;\n    const exec = correlate(inc.environment, openedMs);\n    if (exec == null) continue; // uncorrelated → not attributable to a deploy\n    let resolvedGap: number | null = null;\n    if (inc.resolved_at != null) {\n      const resolvedMs = Date.parse(inc.resolved_at);\n      // Right-censoring: a resolution AFTER the window end (`to`) is not observed\n      // within the window — treat the incident as still open (gap stays null) so\n      // MTTR never reads unbounded past `to`. The incident still counts toward the\n      // incident total (unresolved), it just contributes no recovery time.\n      if (Number.isFinite(resolvedMs) && resolvedMs <= toMs) {\n        const g = (resolvedMs - openedMs) / 1000;\n        if (Number.isFinite(g)) resolvedGap = Math.max(g, 0);\n      }\n    }\n    correlatedIncidents.push({ environment: inc.environment, exec, resolvedGap });\n  }\n\n  // Post-deploy failures per env — the DISTINCT set of deploy executions flagged\n  // by a manual `failed` outcome OR a correlated incident (deduped by execution,\n  // so a deploy flagged by both counts once). A manual outcome without an\n  // execution id (legacy/unresolvable) still counts via a per-row sentinel.\n  const postDeployExecsByEnv = new Map<string, Set<string>>();\n  let sentinel = 0;\n  const flagFor = (env: string): Set<string> => {\n    let s = postDeployExecsByEnv.get(env);\n    if (!s) { s = new Set<string>(); postDeployExecsByEnv.set(env, s); }\n    return s;\n  };\n  for (const o of outcomeRows) {\n    if (o.outcome !== 'failed' || !o.environment) continue;\n    flagFor(o.environment).add(o.execution_id ?? `manual-${sentinel++}`);\n    accFor(o.environment); // ensure env appears even with no deploy events\n  }\n  for (const ci of correlatedIncidents) {\n    flagFor(ci.environment).add(ci.exec);\n    accFor(ci.environment); // ensure env appears even if the deploy is out-of-window\n  }\n  const postDeployByEnv = new Map<string, number>();\n  for (const [env, set] of postDeployExecsByEnv) postDeployByEnv.set(env, set.size);\n\n  const environments: DoraEnvMetrics[] = [...envs.entries()]\n    .map(([environment, a]) => {\n      const postDeployFailures = postDeployByEnv.get(environment) ?? 0;\n      const rawPerDay = a.deployments / days;\n      const numerator = a.deployTimeFailures + postDeployFailures;\n      // Clamp to [0,100]: post-deploy failures can correlate to a deploy that\n      // completed just before the window (kept for correlation), so the numerator\n      // can transiently exceed in-window attempts — a CFR > 100% is never valid.\n      const rawRate = a.attempts > 0 ? Math.min(100, (numerator / a.attempts) * 100) : 0;\n      const ltMedian = median(a.leadGaps);\n      return {\n        environment,\n        deploymentFrequency: {\n          deployments: a.deployments,\n          perDay: round(rawPerDay, 2),\n          level: doraLevelForFrequency(rawPerDay, a.deployments),\n        },\n        changeFailureRate: {\n          rate: round(rawRate, 1),\n          deployTimeFailures: a.deployTimeFailures,\n          postDeployFailures,\n          attempts: a.attempts,\n          level: doraLevelForChangeFailure(rawRate, a.attempts),\n        },\n        leadTime: {\n          deployments: a.leadGaps.length,\n          medianSeconds: ltMedian != null ? round(ltMedian, 1) : null,\n          level: doraLevelForLeadTime(ltMedian),\n        },\n      };\n    })\n    .sort((x, y) => {\n      if (x.environment === HEADLINE_ENV) return -1;\n      if (y.environment === HEADLINE_ENV) return 1;\n      return x.environment.localeCompare(y.environment);\n    });\n\n  // MTTR — PRODUCTION-ONLY, from BOTH sources. Incidents take precedence: a\n  // production incident correlated to a deploy contributes the real recovery\n  // (`resolved_at − opened_at`), and any manual outcome on the SAME deploy is\n  // skipped. Manual outcomes on other deploys keep the Phase-2 behavior\n  // (`failed` → an incident; `restored` → a recovery gap of `restored − deployed`).\n  let incidents = 0, restored = 0;\n  const mttrGaps: number[] = [];\n  // Executions already attributed to a production incident (precedence guard).\n  const incidentExecs = new Set<string>();\n  for (const ci of correlatedIncidents) {\n    if (ci.environment !== HEADLINE_ENV) continue; // MTTR is production-only\n    incidents++;\n    incidentExecs.add(ci.exec);\n    if (ci.resolvedGap != null) { restored++; mttrGaps.push(ci.resolvedGap); }\n  }\n  for (const m of mttrRows) {\n    // Incident precedence: don't double-count a deploy already flagged by an incident.\n    if (m.execution_id != null && incidentExecs.has(m.execution_id)) continue;\n    if (m.outcome === 'failed') { incidents++; continue; }\n    if (m.outcome === 'restored') {\n      restored++;\n      if (m.restored_at != null && m.deployed_at != null) {\n        const gap = (Date.parse(m.restored_at) - Date.parse(m.deployed_at)) / 1000;\n        if (Number.isFinite(gap)) mttrGaps.push(Math.max(gap, 0));\n      }\n    }\n  }\n  const mttrMedian = median(mttrGaps);\n\n  const registered = Number(coverageRow?.registered) || 0;\n  const deploying = Number(coverageRow?.deploying) || 0;\n\n  return {\n    window: { from, to },\n    filters: { pipelineId: filters.pipelineId ?? null, environment: filters.environment ?? null },\n    headline: HEADLINE_ENV,\n    environments,\n    meanTimeToRestore: {\n      incidents,\n      restored,\n      medianSeconds: mttrMedian != null ? round(mttrMedian, 1) : null,\n      level: doraLevelForRestore(mttrMedian),\n    },\n    coverage: {\n      registered,\n      deploying,\n      withoutDeploys: Math.max(registered - deploying, 0),\n    },\n  };\n}\n\n/**\n * 1.9b DORA trend — deployment frequency + deploy-time change-failure rate\n * bucketed by `interval` (day/week/month) for a sparkline. Deploy-basis like\n * getDoraMetrics: buckets terminal deploy-stage executions on their\n * `completed_at`. Shares the org/rollup + pipelineId/environment scoping. MTTR,\n * lead time, and post-deploy CFR are intentionally omitted (too heavy to bucket).\n */\nexport async function getDoraTrend(\n  orgId: string,\n  interval: string,\n  from: string,\n  to: string,\n  orgIds?: string[],\n  opts: DoraOptions = {},\n): Promise<DoraTrendPoint[]> {\n  assertReportInterval(interval);\n  const { pred, multi } = orgScope(orgId, orgIds);\n  const { pipelineId, environment } = opts;\n  const pipelineClause = pipelineId ? sql`AND e.pipeline_id = ${pipelineId}` : sql``;\n  const envClause = environment ? sql`AND e.environment = ${environment}` : sql``;\n  const exec = () => withTenantTx((tx) => tx.execute(sql`\n      WITH deploys AS (\n        -- PER-EXECUTION deploy unit (D1): one row per (environment, execution),\n        -- every deploy STAGE to that env within the execution rolled up to a\n        -- single terminal status — NOT one row per stage.\n        SELECT\n          ${terminalStatusRollup} AS status,\n          MAX(e.completed_at) AS completed_at\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.event_type = 'STAGE' AND e.environment IS NOT NULL\n          ${pipelineClause} ${envClause}\n          AND e.completed_at >= ${from}::timestamptz AND e.completed_at <= ${to}::timestamptz\n        GROUP BY e.environment, e.execution_id\n      )\n      SELECT\n        DATE_TRUNC(${interval}, completed_at)::text AS period,\n        COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS deployments,\n        COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failed,\n        COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED'))::int AS total,\n        -- quoted alias so the raw row key is exactly the DoraTrendPoint field\n        COALESCE(ROUND(COUNT(*) FILTER (WHERE status = 'FAILED')::numeric\n          / NULLIF(COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'FAILED')), 0) * 100, 1), 0)::float AS \"changeFailurePct\"\n      FROM deploys\n      GROUP BY period ORDER BY period\n    `).then(r => drizzleRows<DoraTrendPoint>(r.rows)));\n  const key = `${orgId}:dora-trend:${interval}:${from}:${to}:${pipelineId ?? ''}:${environment ?? ''}`;\n  return runReport(key, multi, exec);\n}\n\n/**\n * 1.10 Per-pipeline BUILD HEALTH (Phase 6) — a standard (NOT `advanced_reporting`)\n * per-stage breakdown for one pipeline over a [from,to] window. Aggregates the\n * existing `pipeline_events` STAGE rows: each stage is rolled up per execution\n * to a terminal status (FAILED wins, then SUCCEEDED) + its max duration, then\n * grouped per stage into run/success/failure counts, a success rate, and\n * duration percentiles (p50/p90/p99). Totals sum across stages. Org-scoped via\n * the pipeline join (`p.org_id ${pred}`) + rollup-aware like the sibling reports;\n * a pipelineId owned by another org returns an empty breakdown.\n */\nexport async function getBuildHealth(\n  orgId: string,\n  pipelineId: string,\n  from: string,\n  to: string,\n  orgIds?: string[],\n): Promise<BuildHealth> {\n  const { pred, multi } = orgScope(orgId, orgIds);\n  const exec = () => withTenantTx(async (tx) => {\n    const rows = drizzleRows<BuildHealthStage>((await tx.execute(sql`\n      WITH stage_runs AS (\n        SELECT\n          e.stage_name AS stage,\n          ${terminalStatusRollup} AS status,\n          MAX(e.duration_ms) AS duration_ms\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.pipeline_id = ${pipelineId}\n          AND e.event_type = 'STAGE' AND e.stage_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.stage_name, e.execution_id\n      )\n      SELECT\n        stage,\n        COUNT(*)::int AS runs,\n        COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::int AS successes,\n        COUNT(*) FILTER (WHERE status = 'FAILED')::int AS failures,\n        COALESCE(ROUND(COUNT(*) FILTER (WHERE status = 'SUCCEEDED')::numeric\n          / NULLIF(COUNT(*), 0) * 100, 1), 0)::float AS \"successRate\",\n        PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY duration_ms)::int AS \"p50Ms\",\n        PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY duration_ms)::int AS \"p90Ms\",\n        PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY duration_ms)::int AS \"p99Ms\"\n      FROM stage_runs\n      WHERE status IN ('SUCCEEDED', 'FAILED')\n      GROUP BY stage\n      ORDER BY runs DESC, stage\n    `)).rows);\n\n    // Totals sum across stages (total stage-runs / stage-failures in the window).\n    let runs = 0, failures = 0;\n    for (const s of rows) { runs += s.runs; failures += s.failures; }\n    const failureRate = runs > 0 ? round((failures / runs) * 100, 1) : 0;\n    return { stages: rows, totals: { runs, failures, failureRate } };\n  });\n  return runReport(`${orgId}:build-health:${pipelineId}:${from}:${to}`, multi, exec);\n}\n\n// ── Category 2: Plugin Inventory & Builds ──\n\n/** 2.1 Plugin summary — counts and breakdowns.\n *  INTENTIONALLY SINGLE-ORG (no rollup): plugin inventory is an org-owned\n *  asset count, not an execution/build activity report, so a parent's view is\n *  its own plugins — teams manage their own inventory. Single `= $org` scope. */\n"]}

package/lib/api/reporting/query-scope.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Build the org-scope predicate for a report query. With `orgIds` (the
+ * org → team rollup — a parent's `[self, ...descendants]`) it becomes an
+ * `IN (...)` over the subtree; otherwise the single-org `= $org`. Returns a
+ * `multi` flag so callers can run multi-org reads under sysadmin context
+ * (the subtree spans orgs outside the request's RLS scope) and salt the
+ * cache key.
+ */
+export declare function orgScope(orgId: string, orgIds?: string[]): {
+    pred: import("drizzle-orm").SQL<unknown>;
+    multi: boolean;
+};
+/**
+ * Run a report read. Single-org reads use the per-org cache (invalidated on
+ * that org's event ingest). Rollup (multi-org) reads **bypass the cache** and
+ * run under sysadmin context: they're admin-only and lower-frequency, and a
+ * child org's event ingest can't invalidate a parent's rollup entry (reporting
+ * has no org tree), so caching them would serve stale aggregates. Always fresh.
+ */
+export declare function runReport<T>(cacheKey: string, multi: boolean, exec: () => Promise<T>): Promise<T>;
+/** 1.1 Execution count per pipeline with status breakdown. */