@pipeline-builder/pipeline-data 0.0.1

package/lib/api/reporting-service.js

@@ -0,0 +1,1564 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createCacheService, createLogger, errorMessage, REPORT_INTERVALS, scrubAwsIdentifiers, scrubAwsIdentifiersFromString } from '@pipeline-builder/api-core';
+import { inArray, sql } from 'drizzle-orm';
+import { drizzleRows } from './crud-service.js';
+import { schema } from '../database/drizzle-schema.js';
+import { withTenantTx, runWithTenantContext } from '../database/tenancy.js';
+const logger = createLogger('reporting-service');
+/**
+ * Defense-in-depth guard for the `DATE_TRUNC(${interval}, …)` bucket argument.
+ * The route layer (`parseReportInterval`) is the security boundary and already
+ * rejects unknown intervals; this assert makes an invalid value fail fast at the
+ * service boundary with a clear error instead of surfacing a raw Postgres error
+ * if a caller ever bypasses the route validation. Shares api-core's
+ * REPORT_INTERVALS allow-list so the two can't drift.
+ */
+function assertReportInterval(interval) {
+    if (!REPORT_INTERVALS.includes(interval)) {
+        throw new Error(`Invalid report interval: ${interval}. Expected one of: ${REPORT_INTERVALS.join(', ')}`);
+    }
+}
+/**
+ * Scrub AWS identifiers from an optional free-form string, preserving `undefined`
+ * (so an absent field stays absent rather than becoming an empty scrubbed string).
+ * The DURABLE persistence boundary for the ingest paths — every user/AWS-derived
+ * string field is funneled through this before insert.
+ */
+function scrubOptional(value) {
+    return value !== undefined ? scrubAwsIdentifiersFromString(value) : undefined;
+}
+/**
+ * Cache for reporting aggregations. Two tiers:
+ * - Inventory queries (plugin summary/distribution/versions): 5 min TTL — changes on plugin CRUD
+ * - Execution/build queries with date ranges: 2 min TTL — new events arrive continuously
+ */
+const inventoryCache = createCacheService('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));
+const timeseriesCache = createCacheService('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));
+/**
+ * The DORA headline environment. Deployment to this literal env name is the
+ * industry-standard DORA signal; MTTR is measured production-only, and this
+ * environment's card is the summary shown at the top of the panel.
+ */
+const HEADLINE_ENV = 'production';
+/**
+ * Incident→deploy correlation window (Phase 5). An incident is attributed to the
+ * most recent SUCCESSFUL deploy to its environment whose `completed_at` is within
+ * this many hours before the incident's `opened_at`. Default 24h; override via
+ * `DORA_INCIDENT_WINDOW_HOURS`. Guarded to a positive finite number.
+ */
+const DORA_INCIDENT_WINDOW_HOURS = (() => {
+    const raw = Number(process.env.DORA_INCIDENT_WINDOW_HOURS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 24;
+})();
+/**
+ * Resolve the effective incident→deploy correlation window (Phase 5b). A per-org
+ * override (from `dora_settings.incident_window_hours`, surfaced through the
+ * settings endpoint and threaded into {@link DoraOptions.incidentWindowHours})
+ * wins when it is a positive finite number; otherwise the global env default
+ * `DORA_INCIDENT_WINDOW_HOURS` applies. Centralized so the DORA correlation, the
+ * incidents list, and the wiring-test dry-run all agree on the same rule.
+ */
+function resolveIncidentWindowHours(override) {
+    return override != null && Number.isFinite(override) && override > 0 ? override : DORA_INCIDENT_WINDOW_HOURS;
+}
+/**
+ * Reporting retention windows (Phase 7). Records in `pipeline_events`,
+ * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a
+ * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})
+ * hard-deletes rows older than these windows, by `created_at`:
+ *  - **Standard events** — `pipeline_events` with `environment IS NULL`
+ *    (non-deploy STAGE/ACTION/build). High volume → short default (30 days).
+ *  - **DORA source** — `pipeline_events` with `environment IS NOT NULL` (deploy
+ *    stages) plus all of `deployment_outcomes` and `incidents`. Low volume →
+ *    longer default (180 days). DORA history is therefore bounded by this window;
+ *    the report query still hard-caps at 365 days (a longer per-org override only
+ *    retains raw source rows, never widens a report).
+ * `ingest_health` and `dora_settings` are never purged. Env-overridable globals;
+ * a per-org override in `dora_settings` wins (see {@link resolveEventRetentionDays}).
+ */
+const RETENTION_MIN_DAYS = 1;
+const RETENTION_MAX_DAYS = 730;
+/** Parse a positive-int env day-count, clamped to [MIN, MAX], else `fallback`. */
+function retentionEnvDays(name, fallback) {
+    const raw = Number(process.env[name]);
+    if (!Number.isFinite(raw) || !Number.isInteger(raw) || raw < RETENTION_MIN_DAYS)
+        return fallback;
+    return Math.min(raw, RETENTION_MAX_DAYS);
+}
+const REPORTING_EVENT_RETENTION_DAYS = retentionEnvDays('REPORTING_EVENT_RETENTION_DAYS', 30);
+const REPORTING_DORA_RETENTION_DAYS = retentionEnvDays('REPORTING_DORA_RETENTION_DAYS', 180);
+/** Effective standard-event retention (days): a valid per-org override wins,
+ *  else the global env default. Shared by the sweep + the settings surface so
+ *  they can't drift. The `-1` unlimited sentinel (Phase 8) passes straight
+ *  through — the sweep reads it as "keep forever, skip this org's standard
+ *  events". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a
+ *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the
+ *  env default. */
+export function resolveEventRetentionDays(override) {
+    if (override === -1)
+        return -1;
+    return override != null && Number.isInteger(override) && override >= RETENTION_MIN_DAYS
+        ? Math.min(override, RETENTION_MAX_DAYS) : REPORTING_EVENT_RETENTION_DAYS;
+}
+/** Effective DORA-source retention (days): a valid per-org override wins, else
+ *  the global env default. The `-1` unlimited sentinel (Phase 8) passes straight
+ *  through — the sweep reads it as "keep forever, skip this org's DORA-source
+ *  windows". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a
+ *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the
+ *  env default. */
+export function resolveDoraRetentionDays(override) {
+    if (override === -1)
+        return -1;
+    return override != null && Number.isInteger(override) && override >= RETENTION_MIN_DAYS
+        ? Math.min(override, RETENTION_MAX_DAYS) : REPORTING_DORA_RETENTION_DAYS;
+}
+/** The cutoff instant for a retention window: rows with `created_at` strictly
+ *  before this (`< cutoff`) are expired. Deterministic for a fixed `now`. */
+export function retentionCutoff(now, days) {
+    return new Date(now.getTime() - days * 86_400_000);
+}
+// DORA performance bands (thresholds from the DORA/Accelerate reports). Each
+// helper returns `null` when there's no sample to classify.
+/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */
+function doraLevelForFrequency(perDay, deployments) {
+    if (deployments <= 0)
+        return null;
+    if (perDay >= 1)
+        return 'elite';
+    if (perDay >= 1 / 7)
+        return 'high';
+    if (perDay >= 1 / 30)
+        return 'medium';
+    return 'low';
+}
+/** Change failure rate by percent: elite ≤5%, high ≤10%, medium ≤15%. */
+function doraLevelForChangeFailure(pct, total) {
+    if (total <= 0)
+        return null;
+    if (pct <= 5)
+        return 'elite';
+    if (pct <= 10)
+        return 'high';
+    if (pct <= 15)
+        return 'medium';
+    return 'low';
+}
+/** Time to restore by seconds: elite <1h, high <1 day, medium <1 week. */
+function doraLevelForRestore(avgSeconds) {
+    if (avgSeconds == null)
+        return null;
+    if (avgSeconds < 3600)
+        return 'elite';
+    if (avgSeconds < 86400)
+        return 'high';
+    if (avgSeconds < 604800)
+        return 'medium';
+    return 'low';
+}
+/** Lead time by seconds: elite <1 day, high <1 week, medium <1 month. */
+function doraLevelForLeadTime(medianSeconds) {
+    if (medianSeconds == null)
+        return null;
+    if (medianSeconds < 86400)
+        return 'elite';
+    if (medianSeconds < 604800)
+        return 'high';
+    if (medianSeconds < 2592000)
+        return 'medium';
+    return 'low';
+}
+/**
+ * Round `value` to `digits` decimal places, returning a real number. Small
+ * module-private helper so the DORA shaping doesn't repeat the
+ * `Number(Number(x).toFixed(n))` pattern (toFixed alone yields a string).
+ */
+function round(value, digits) {
+    return Number(value.toFixed(digits));
+}
+/**
+ * Median of a numeric sample, or `null` when empty. Used for measured lead time
+ * and MTTR — both are cross-source gaps computed in JS from clamped deltas, so
+ * the median lives here rather than in SQL PERCENTILE_CONT (keeps the golden
+ * fixture tests able to prove the metric math without a live Postgres).
+ */
+function median(values) {
+    if (values.length === 0)
+        return null;
+    const s = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(s.length / 2);
+    return s.length % 2 === 1 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+/**
+ * Roll a group of deploy/stage events (grouped per execution) up to one terminal
+ * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).
+ * Shared by the three per-(env|stage, execution) rollup CTEs — DORA metrics, DORA
+ * trend, and build health — so the precedence can't drift between them. Assumes the
+ * grouped event alias is `e`.
+ */
+const terminalStatusRollup = sql `CASE
+              WHEN bool_or(e.status = 'FAILED') THEN 'FAILED'
+              WHEN bool_or(e.status = 'SUCCEEDED') THEN 'SUCCEEDED'
+              ELSE 'OTHER'
+            END`;
+/** Optional `[from,to]` window on `e.started_at` for the execution reports —
+ *  a no-op `sql` fragment when either bound is absent (all-time). Shared by the
+ *  execution-count and per-pipeline-execution reports so they narrow identically. */
+function optionalStartedAtRange(range) {
+    return range?.from && range?.to
+        ? sql `AND e.started_at >= ${range.from}::timestamptz AND e.started_at <= ${range.to}::timestamptz`
+        : sql ``;
+}
+// ─── Service ────────────────────────────────────────────
+/**
+ * Read-only reporting service for pipeline execution and plugin inventory aggregations.
+ * Does not extend CrudService — reports are aggregate queries, not entity CRUD.
+ *
+ * All queries are cached in-memory to avoid repeated expensive SQL aggregations:
+ * - Inventory queries (plugin summary/distribution/versions): 5 min TTL
+ * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL
+ */
+export class ReportingService {
+    /** Invalidate all cached reports for an org (call after event ingest). */
+    async invalidateOrg(orgId) {
+        await Promise.all([
+            inventoryCache.invalidatePattern(`${orgId}:*`),
+            timeseriesCache.invalidatePattern(`${orgId}:*`),
+        ]);
+    }
+    /**
+     * Resolve incoming events against the pipeline registry, batch-insert the
+     * matched ones, and invalidate reporting caches for affected orgs.
+     * Events for unregistered pipeline ids are dropped (and logged at WARN
+     * with sample ids so an operator can see when EventBridge is delivering
+     * events for pipelines that haven't called POST /pipelines/registry yet).
+     *
+     * Returns counts + a sample of unregistered pipeline ids for observability.
+     */
+    async ingestEvents(events, onMetric) {
+        // Multi-org batch insert: the caller resolves to multiple orgs via the
+        // pipeline-registry lookup below, so the route layer MUST establish a
+        // `runWithTenantContext({ isSuperAdmin: true }, ...)` scope before calling
+        // this method. Under FORCE'd RLS, a single tx with `app.org_id = <one
+        // org>` could only write events for that org; bypass via sysadmin is
+        // the right gate for this server-internal cross-tenant endpoint. See
+        // api/reporting/src/routes/event-ingest.ts for the wrapper.
+        // Run insert inside the tx, but COLLECT affected orgs and invalidate
+        // caches AFTER the tx resolves. Keeping invalidation inside the tx held
+        // the pg locks open for the duration of the cache round-trips (Redis or
+        // in-memory invalidations are unrelated to the tx but still serialized
+        // its commit). Cache TTL is 2-5 min so fire-and-forget post-commit is
+        // an acceptable trade for tighter lock windows.
+        const { inserted, skipped, unregisteredPipelineIds, affectedOrgs } = await withTenantTx(async (tx) => {
+            // Batch-resolve all unique pipeline ids in one query
+            const uniqueIds = [...new Set(events.map(e => e.pipelineId))];
+            const registryRows = await tx
+                .select({
+                pipelineId: schema.pipelineRegistry.pipelineId,
+                orgId: schema.pipelineRegistry.orgId,
+            })
+                .from(schema.pipelineRegistry)
+                .where(inArray(schema.pipelineRegistry.pipelineId, uniqueIds));
+            const idMap = new Map(registryRows.map(r => [r.pipelineId, r]));
+            // Build insert batch (skip events whose pipeline isn't registered)
+            const rows = [];
+            let skippedLocal = 0;
+            const unregisteredLocal = [];
+            for (const event of events) {
+                const registry = idMap.get(event.pipelineId);
+                if (!registry) {
+                    skippedLocal++;
+                    unregisteredLocal.push(event.pipelineId);
+                    continue;
+                }
+                rows.push({
+                    // registry.pipelineId === event.pipelineId; use the registry's so the
+                    // FK is always a row that exists, and pull orgId from the registry for
+                    // tenancy (never trust the caller's claimed org).
+                    pipelineId: registry.pipelineId,
+                    orgId: registry.orgId,
+                    eventSource: event.eventSource,
+                    eventType: event.eventType,
+                    status: event.status,
+                    // executionId is an AWS-ASSIGNED identifier (a UUID), not free-form
+                    // user text, so it can't carry an account id — and scrubbing a UUID
+                    // that happens to contain a 12-digit run would corrupt the correlation
+                    // key. Left intact by design.
+                    executionId: event.executionId,
+                    // stageName/actionName are USER-AUTHORED pipeline-structure names
+                    // promoted from the CodePipeline detail — same untrusted-AWS-derived
+                    // origin as errorMessage below, so scrub them at this persistence
+                    // boundary too (a stage named with an ARN/12-digit id must not persist).
+                    stageName: scrubOptional(event.stageName),
+                    actionName: scrubOptional(event.actionName),
+                    // HARD CONSTRAINT: an AWS account id must NEVER be persisted. This is
+                    // the DURABLE persistence boundary and must not trust upstream:
+                    // CodePipeline/CodeBuild failure detail & messages routinely carry
+                    // ARNs (arn:aws:…:<account-id>:…) and bare 12-digit account ids. Scrub
+                    // both free-form fields here before insert (per-event, non-mutating).
+                    errorMessage: scrubOptional(event.errorMessage),
+                    startedAt: event.startedAt ? new Date(event.startedAt) : undefined,
+                    completedAt: event.completedAt ? new Date(event.completedAt) : undefined,
+                    durationMs: event.durationMs,
+                    // Deploy-attribution fields — scrubbed like the other free-form strings
+                    // so an ARN/account id can never enter via a ref or environment name.
+                    commitSha: scrubOptional(event.commitSha),
+                    commitRef: scrubOptional(event.commitRef),
+                    environment: scrubOptional(event.environment),
+                    // Measured lead time (Phase 4): oldest unshipped commit time + count.
+                    // commitTimestamp is an AWS/SCM-derived instant (never account-id
+                    // shaped); commitCount is a plain integer. Neither needs scrubbing.
+                    commitTimestamp: event.commitTimestamp ? new Date(event.commitTimestamp) : undefined,
+                    commitCount: event.commitCount,
+                    detail: event.detail !== undefined
+                        ? scrubAwsIdentifiers(event.detail)
+                        : undefined,
+                });
+                // Phase 3b: fan terminal STAGE outcomes into Prometheus counters via the
+                // route's hook (pipeline-data can't import api-server's registry). Emit
+                // per registered stage event with a terminal succeeded/failed result;
+                // a non-null environment additionally marks it a deploy result.
+                if (onMetric && event.eventType === 'STAGE' && (event.status === 'SUCCEEDED' || event.status === 'FAILED')) {
+                    onMetric({
+                        pipelineId: registry.pipelineId,
+                        orgId: registry.orgId,
+                        stage: scrubOptional(event.stageName) ?? '',
+                        environment: scrubOptional(event.environment) ?? null,
+                        result: event.status === 'SUCCEEDED' ? 'succeeded' : 'failed',
+                    });
+                }
+            }
+            // SQS is at-least-once, so EventBridge can deliver the same state-change
+            // twice. `onConflictDoNothing` + the partial unique index on
+            // (pipeline_id, execution_id, event_type, status, stage_name, action_name)
+            // makes re-delivery idempotent. `returning` gives the REAL inserted set so
+            // counts + cache invalidation ignore duplicates.
+            const insertedRows = rows.length > 0
+                ? await tx.insert(schema.pipelineEvent).values(rows)
+                    .onConflictDoNothing()
+                    .returning({ orgId: schema.pipelineEvent.orgId })
+                : [];
+            return {
+                inserted: insertedRows.length,
+                skipped: skippedLocal,
+                unregisteredPipelineIds: unregisteredLocal,
+                affectedOrgs: [...new Set(insertedRows.map(r => r.orgId))],
+            };
+        });
+        // Surface the silent skip: an unregistered pipeline id usually means the
+        // pipeline hasn't called POST /pipelines/registry yet (or its
+        // pb.pipeline-id tag is missing/unreadable by the Lambda). Logging it
+        // makes a broken join visible instead of looking like "no activity".
+        if (unregisteredPipelineIds.length > 0) {
+            logger.warn('Pipeline events skipped: pipeline id not found in registry', {
+                count: unregisteredPipelineIds.length,
+                sample: unregisteredPipelineIds.slice(0, 3),
+            });
+        }
+        // Post-commit cache invalidation. Fire-and-forget with logging — TTL is
+        // short enough that a missed invalidation self-heals.
+        if (affectedOrgs.length > 0) {
+            void Promise.all(affectedOrgs.map((org) => this.invalidateOrg(org).catch((err) => {
+                logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });
+            })));
+        }
+        return { inserted, skipped, unregisteredPipelineIds };
+    }
+    // ── Category 1: Pipeline Execution & Performance ──
+    /**
+     * 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.
+     */
+    orgScope(orgId, orgIds) {
+        // Defense-in-depth: the multi-org rollup runs under sysadmin context (RLS
+        // OFF, see runReport), so `orgIds` is the ONLY tenancy gate on the read. The
+        // route resolves it from the platform's authoritative descendants endpoint as
+        // `[self, ...descendants]`, but validate the subtree defensively here before
+        // the bypass: the requesting (anchor) org MUST appear in the set. A set that
+        // omits the caller's own org is a malformed/spoofed rollup — collapse to the
+        // safe single-org scope rather than reading an arbitrary org under sysadmin.
+        // (Full descendant-membership validation needs the org tree, which this
+        // service does not hold — see the report FLAG.)
+        const anchor = orgId.toLowerCase();
+        const provided = (orgIds ?? []).filter((id) => typeof id === 'string' && id.length > 0);
+        const anchored = provided.some((id) => id.toLowerCase() === anchor);
+        if (provided.length > 0 && !anchored) {
+            logger.warn('Reporting rollup rejected: requesting org absent from resolved subtree; using single-org scope', {
+                orgId: anchor, subtreeSize: provided.length,
+            });
+        }
+        const ids = provided.length > 0 && anchored ? provided : [orgId];
+        const multi = ids.length > 1;
+        const pred = multi
+            ? sql `IN (${sql.join(ids.map((id) => sql `${id}`), sql `, `)})`
+            : sql `= ${ids[0]}`;
+        return { pred, multi };
+    }
+    /**
+     * 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.
+     */
+    runReport(cacheKey, multi, exec) {
+        return multi
+            ? runWithTenantContext({ isSuperAdmin: true }, exec)
+            : timeseriesCache.getOrSet(cacheKey, exec);
+    }
+    /** 1.1 Execution count per pipeline with status breakdown. */
+    async getExecutionCount(orgId, orgIds, range) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        // Optional [from,to] window on the execution's started_at, mirroring the
+        // sibling timeseries reports so the dashboard date-range picker narrows the
+        // count too (an empty range = all-time, preserving the prior behavior). The
+        // range rides the JOIN so pipelines with no in-window events still list
+        // (LEFT semantics preserved via the inner-join filter — a pipeline with zero
+        // matching events drops from the count, same as before for its window).
+        const rangeClause = optionalStartedAtRange(range);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          p.id, p.project, p.organization, p.pipeline_name,
+          COUNT(*)::int AS total,
+          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,
+          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,
+          MIN(e.started_at)::text AS first_execution,
+          MAX(e.started_at)::text AS last_execution
+        FROM ${schema.pipeline} p
+        JOIN ${schema.pipelineEvent} e ON e.pipeline_id = p.id
+          AND e.event_type = 'PIPELINE' AND e.status != 'STARTED'
+          ${rangeClause}
+        WHERE p.org_id ${pred} AND p.is_active = true
+        GROUP BY p.id
+        ORDER BY total DESC
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:exec-count:${range?.from ?? ''}:${range?.to ?? ''}`, multi, exec);
+    }
+    /**
+     * 1.1b Per-pipeline execution history — DISTINCT executions for one pipeline,
+     * newest first. Groups all events by `execution_id` in a single scan and
+     * rolls each execution up to one row:
+     *   - status: derived from the PIPELINE-type events. FAILED wins, then
+     *     SUCCEEDED, then CANCELED; an execution with no terminal PIPELINE event
+     *     is still `in-progress`.
+     *   - startedAt/endedAt/durationMs: from the PIPELINE lifecycle events.
+     *   - failingStage/failingAction: the first FAILED STAGE/ACTION event (cheap —
+     *     same scan, no extra query).
+     *
+     * ORG-SCOPING: identical to the sibling execution reports — joins the pipeline
+     * registry table (`pipeline`) and gates on `p.org_id ${pred}`, where `pred` is
+     * the single-org `= $org` or (with a rollup) an `IN (...)` over the org→team
+     * subtree. A pipelineId belonging to another org yields zero rows.
+     */
+    async listPipelineExecutions(orgId, pipelineId, orgIds, range, limit = 50) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const rangeClause = optionalStartedAtRange(range);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          e.execution_id,
+          CASE
+            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'FAILED') THEN 'failed'
+            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'SUCCEEDED') THEN 'succeeded'
+            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'CANCELED') THEN 'canceled'
+            ELSE 'in-progress'
+          END AS status,
+          MIN(e.started_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS started_at,
+          MAX(e.completed_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS ended_at,
+          MAX(e.duration_ms) FILTER (WHERE e.event_type = 'PIPELINE')::int AS duration_ms,
+          (ARRAY_AGG(e.stage_name) FILTER (WHERE e.event_type = 'STAGE' AND e.status = 'FAILED'))[1] AS failing_stage,
+          (ARRAY_AGG(e.action_name) FILTER (WHERE e.event_type = 'ACTION' AND e.status = 'FAILED'))[1] AS failing_action
+        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.execution_id IS NOT NULL
+          ${rangeClause}
+        GROUP BY e.execution_id
+        ORDER BY MAX(e.created_at) DESC
+        LIMIT ${limit}
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:pipeline-executions:${pipelineId}:${range?.from ?? ''}:${range?.to ?? ''}:${limit}`, multi, exec);
+    }
+    /** 1.2 Success rate over time for an org. */
+    async getSuccessRate(orgId, interval, from, to, orgIds) {
+        assertReportInterval(interval);
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          DATE_TRUNC(${interval}, e.started_at)::text AS period,
+          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,
+          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE'
+          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED')
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY period ORDER BY period
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:success-rate:${interval}:${from}:${to}`, multi, exec);
+    }
+    /** 1.3 Average duration per pipeline. */
+    async getAverageDuration(orgId, from, to, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          p.id, p.project, p.pipeline_name,
+          AVG(e.duration_ms)::int AS avg_ms,
+          MIN(e.duration_ms)::int AS min_ms,
+          MAX(e.duration_ms)::int AS max_ms,
+          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS p95_ms,
+          COUNT(*)::int AS executions
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.event_type = 'PIPELINE' AND e.duration_ms IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY p.id ORDER BY avg_ms DESC
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:avg-duration:${from}:${to}`, multi, exec);
+    }
+    /** 1.5 Stage failure heatmap — which stages fail most. */
+    async getStageFailures(orgId, from, to, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          e.stage_name,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,
+          COUNT(*)::int AS total,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct
+        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.stage_name IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY e.stage_name ORDER BY failures DESC
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:stage-failures:${from}:${to}`, multi, exec);
+    }
+    /**
+     * Distinct deploy `environment` values observed in the window — powers the
+     * DORA environment-scope datalist. Org-scoped + rollup-aware like the sibling
+     * reports; only non-null environments (i.e. deploy-attributed executions).
+     */
+    async getReportEnvironments(orgId, from, to, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT DISTINCT e.environment AS environment
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.environment IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        ORDER BY environment
+      `).then(r => drizzleRows(r.rows).map((row) => row.environment)));
+        return this.runReport(`${orgId}:report-envs:${from}:${to}`, multi, exec);
+    }
+    /** 1.6 Stage bottlenecks — slowest stages per pipeline. */
+    async getStageBottlenecks(orgId, from, to, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          p.id, p.pipeline_name, e.stage_name,
+          AVG(e.duration_ms)::int AS avg_ms,
+          MAX(e.duration_ms)::int AS max_ms
+        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.duration_ms IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:stage-bottlenecks:${from}:${to}`, multi, exec);
+    }
+    /** 1.7 Action failure rate — which plugin steps fail most. */
+    async getActionFailures(orgId, from, to, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          e.action_name,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,
+          COUNT(*)::int AS total,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.event_type = 'ACTION' AND e.action_name IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY e.action_name ORDER BY failures DESC
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:action-failures:${from}:${to}`, multi, exec);
+    }
+    /**
+     * 1.8 Error categorization — group failure messages. Execution report, so
+     * rollup-aware exactly like the sibling execution reports: with `orgIds`
+     * (the org→team subtree) the org gate becomes an `IN (...)` and the read runs
+     * fresh under sysadmin via `runReport`; single-org reads keep the per-org cache.
+     */
+    async getErrors(orgId, from, to, limit = 20, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          SUBSTRING(e.error_message FROM 1 FOR 200) AS error_pattern,
+          COUNT(*)::int AS occurrences,
+          COUNT(DISTINCT e.pipeline_id)::int AS affected_pipelines,
+          MAX(e.started_at)::text AS last_seen
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id ${pred} AND e.status = 'FAILED' AND e.error_message IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY error_pattern ORDER BY occurrences DESC
+        LIMIT ${limit}
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:errors:${from}:${to}:${limit}`, multi, exec);
+    }
+    /**
+     * 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
+     */
+    async getDoraMetrics(orgId, from, to, orgIds, opts = {}) {
+        const { pred, multi } = this.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 this.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 this.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.
+     */
+    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).
+     */
+    async getDoraTrend(orgId, interval, from, to, orgIds, opts = {}) {
+        assertReportInterval(interval);
+        const { pred, multi } = this.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 this.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.
+     */
+    async getBuildHealth(orgId, pipelineId, from, to, orgIds) {
+        const { pred, multi } = this.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 this.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. */
+    async getPluginSummary(orgId) {
+        return inventoryCache.getOrSet(`${orgId}:plugin-summary`, async () => {
+            const rows = await withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          COUNT(*)::int AS total,
+          COUNT(*) FILTER (WHERE ${schema.plugin.isActive})::int AS active,
+          COUNT(*) FILTER (WHERE NOT ${schema.plugin.isActive})::int AS inactive,
+          COUNT(*) FILTER (WHERE ${schema.plugin.visibility} = 'public')::int AS public,
+          COUNT(*) FILTER (WHERE ${schema.plugin.visibility} = 'org')::int AS org,
+          COUNT(*) FILTER (WHERE ${schema.plugin.visibility} = 'private')::int AS private,
+          COUNT(DISTINCT ${schema.plugin.name})::int AS unique_names
+        FROM ${schema.plugin}
+        WHERE ${schema.plugin.orgId} = ${orgId}
+      `));
+            return (drizzleRows(rows.rows)[0] || { total: 0, active: 0, inactive: 0, public: 0, org: 0, private: 0, uniqueNames: 0 });
+        });
+    }
+    /** 2.2 Type & compute distribution.
+     *  INTENTIONALLY SINGLE-ORG (no rollup): plugin inventory is per-org (see
+     *  getPluginSummary). Single `= $org` scope. */
+    async getPluginDistribution(orgId) {
+        return inventoryCache.getOrSet(`${orgId}:plugin-distribution`, () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          ${schema.plugin.pluginType} AS plugin_type,
+          ${schema.plugin.computeType} AS compute_type,
+          COUNT(*)::int AS count
+        FROM ${schema.plugin}
+        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true
+        GROUP BY ${schema.plugin.pluginType}, ${schema.plugin.computeType}
+        ORDER BY count DESC
+      `).then(r => drizzleRows(r.rows))));
+    }
+    /** 2.3 Version counts per plugin name.
+     *  INTENTIONALLY SINGLE-ORG (no rollup): plugin inventory is per-org (see
+     *  getPluginSummary). Single `= $org` scope. */
+    async getPluginVersions(orgId) {
+        return inventoryCache.getOrSet(`${orgId}:plugin-versions`, () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          ${schema.plugin.name},
+          COUNT(*)::int AS version_count,
+          -- Highest version by NUMERIC semver core (not lexical: '10.0.0' > '9.0.0').
+          -- Strip any -prerelease/+build suffix before the int[] cast so it can't
+          -- error on valid semver; keep the original string for display.
+          -- GUARD: a non-numeric-dotted version ('latest', '', 'v1') would make the
+          -- ::int[] cast throw and blow up the WHOLE org summary. Only cast rows
+          -- whose stripped core matches a numeric-dotted shape; sort everything
+          -- else to the bottom via a sentinel ARRAY[-1] so the row still counts.
+          (array_agg(${schema.plugin.version}
+             ORDER BY CASE
+               WHEN regexp_replace(${schema.plugin.version}, '[-+].*$', '') ~ '^[0-9]+([.][0-9]+)*$'
+                 THEN string_to_array(regexp_replace(${schema.plugin.version}, '[-+].*$', ''), '.')::int[]
+               ELSE ARRAY[-1]
+             END DESC
+          ))[1] AS latest_version,
+          bool_or(${schema.plugin.isDefault}) AS has_default
+        FROM ${schema.plugin}
+        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true
+        GROUP BY ${schema.plugin.name}
+        ORDER BY version_count DESC
+      `).then(r => drizzleRows(r.rows))));
+    }
+    /**
+     * 2.4 Build success rate over time.
+     *
+     * STATUS CASING NOTE: This query filters by `event_source = 'plugin-build'`
+     * and uses lowercase status values (`'completed'`, `'failed'`), while
+     * `getSuccessRate` (1.2) filters by `event_type = 'PIPELINE'` with
+     * uppercase AWS-style statuses (`'SUCCEEDED'`, `'FAILED'`, `'CANCELED'`).
+     * The casing drift is intentional and tracks the producer:
+     *   - `plugin-build` events come from our own build pipeline (lowercase)
+     *   - `PIPELINE` events come from AWS CodePipeline (uppercase)
+     * The ingest Zod schema at api/reporting/src/routes/event-ingest.ts
+     * SHOULD enum these per-eventSource so we catch drift at ingest rather
+     * than silently producing zero rows here. See findings N71.
+     */
+    async getBuildSuccessRate(orgId, interval, from, to, orgIds) {
+        assertReportInterval(interval);
+        // Build activity report — rollup-aware like the execution reports. These
+        // rows are gated on the pipeline_event `org_id` directly (no pipeline join),
+        // so `pred` applies to `e.org_id`.
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          DATE_TRUNC(${interval}, e.started_at)::text AS period,
+          COUNT(*) FILTER (WHERE e.status = 'completed')::int AS succeeded,
+          COUNT(*) FILTER (WHERE e.status = 'failed')::int AS failed,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'completed')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct
+        FROM ${schema.pipelineEvent} e
+        WHERE e.org_id ${pred} AND e.event_source = 'plugin-build'
+          AND e.status IN ('completed', 'failed')
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY period ORDER BY period
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:build-success:${interval}:${from}:${to}`, multi, exec);
+    }
+    /** 2.5 Build duration per plugin. Build activity report — rollup-aware. */
+    async getBuildDuration(orgId, from, to, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          e.detail->>'pluginName' AS plugin_name,
+          AVG(e.duration_ms)::int AS avg_ms,
+          MAX(e.duration_ms)::int AS max_ms,
+          COUNT(*)::int AS builds
+        FROM ${schema.pipelineEvent} e
+        WHERE e.org_id ${pred} AND e.event_source = 'plugin-build' AND e.duration_ms IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY plugin_name ORDER BY avg_ms DESC
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:build-duration:${from}:${to}`, multi, exec);
+    }
+    /** 2.6 Build failures — top error messages. Build activity report — rollup-aware. */
+    async getBuildFailures(orgId, from, to, limit = 20, orgIds) {
+        const { pred, multi } = this.orgScope(orgId, orgIds);
+        const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          e.detail->>'pluginName' AS plugin_name,
+          e.error_message,
+          COUNT(*)::int AS occurrences,
+          MAX(e.started_at)::text AS last_seen
+        FROM ${schema.pipelineEvent} e
+        WHERE e.org_id ${pred} AND e.event_source = 'plugin-build' AND e.status = 'failed'
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY plugin_name, e.error_message
+        ORDER BY occurrences DESC
+        LIMIT ${limit}
+      `).then(r => drizzleRows(r.rows)));
+        return this.runReport(`${orgId}:build-failures:${from}:${to}:${limit}`, multi, exec);
+    }
+    // ── Category 3: DORA write paths (post-deploy outcomes + ingest health) ──
+    /**
+     * Record a manual post-deploy outcome marker (Phase 2): a user marks a
+     * deployment `failed` (a production incident linked to the deploy) or
+     * `restored` (recovered). Idempotent — keyed on (execution_id, outcome) so a
+     * duplicate POST refreshes `at` rather than double-counting, while a
+     * failed→restored pair stays two rows. Feeds the post-deploy CFR component and
+     * the real MTTR. Runs under the caller's org context (RLS WITH CHECK).
+     */
+    async recordDeploymentOutcome(orgId, executionId, input) {
+        await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.insert(schema.deploymentOutcome).values({
+            executionId,
+            orgId,
+            environment: scrubOptional(input.environment),
+            outcome: input.outcome,
+            at: new Date(input.at),
+        }).onConflictDoUpdate({
+            target: [schema.deploymentOutcome.executionId, schema.deploymentOutcome.outcome],
+            set: {
+                at: new Date(input.at),
+                environment: scrubOptional(input.environment) ?? null,
+            },
+        })));
+        // Outcome changes the DORA aggregate — drop the org's cached reports.
+        await this.invalidateOrg(orgId).catch((err) => {
+            logger.warn('Reporting cache invalidation failed', { orgId, error: errorMessage(err) });
+        });
+    }
+    /**
+     * Ingest a production incident (Phase 5) from the org's incident tooling
+     * (PagerDuty / Datadog / Alertmanager webhook). Idempotent — keyed on
+     * (org_id, incident_id) so a later resolve re-post upserts `resolved_at`
+     * (and refreshes the other mutable fields) instead of inserting a duplicate.
+     * DORA correlates each incident to the most recent successful deploy to its
+     * `environment`, producing an automated post-deploy failure + a real MTTR.
+     * Runs under the caller's org context (RLS WITH CHECK); free-form fields are
+     * AWS-id scrubbed at this persistence boundary like the other ingest paths.
+     */
+    async recordIncident(orgId, input) {
+        const incidentId = scrubAwsIdentifiersFromString(input.incidentId);
+        const environment = scrubAwsIdentifiersFromString(input.environment);
+        const severity = scrubAwsIdentifiersFromString(input.severity);
+        const openedAt = new Date(input.openedAt);
+        const resolvedAt = input.resolvedAt ? new Date(input.resolvedAt) : null;
+        await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.insert(schema.incident).values({
+            incidentId,
+            orgId,
+            environment,
+            openedAt,
+            resolvedAt,
+            severity,
+        }).onConflictDoUpdate({
+            target: [schema.incident.orgId, schema.incident.incidentId],
+            set: { environment, openedAt, resolvedAt, severity },
+        })));
+        // A new/updated incident changes the DORA aggregate — drop cached reports.
+        await this.invalidateOrg(orgId).catch((err) => {
+            logger.warn('Reporting cache invalidation failed', { orgId, error: errorMessage(err) });
+        });
+    }
+    /**
+     * Read the per-org DORA settings (Phase 5b). Returns the stored
+     * `incidentWindowHours` override (or `null` when unset) plus the global env
+     * default, so the settings UI can show both. Runs under the caller's tenant
+     * context (RLS-scoped); a single-org read.
+     */
+    async getIncidentSettings(orgId) {
+        const rows = drizzleRows((await withTenantTx((tx) => tx.execute(sql `
+        SELECT ${schema.doraSettings.incidentWindowHours} AS incident_window_hours,
+               ${schema.doraSettings.eventRetentionDays} AS event_retention_days,
+               ${schema.doraSettings.doraRetentionDays} AS dora_retention_days
+        FROM ${schema.doraSettings}
+        WHERE ${schema.doraSettings.orgId} = ${orgId}
+        LIMIT 1
+      `))).rows);
+        const row = rows[0];
+        return {
+            incidentWindowHours: row?.incident_window_hours != null ? Number(row.incident_window_hours) : null,
+            defaultWindowHours: DORA_INCIDENT_WINDOW_HOURS,
+            eventRetentionDays: row?.event_retention_days != null ? Number(row.event_retention_days) : null,
+            doraRetentionDays: row?.dora_retention_days != null ? Number(row.dora_retention_days) : null,
+            defaultEventRetentionDays: REPORTING_EVENT_RETENTION_DAYS,
+            defaultDoraRetentionDays: REPORTING_DORA_RETENTION_DAYS,
+        };
+    }
+    /**
+     * Upsert per-org reporting settings (Phase 5b incident window + Phase 7
+     * retention overrides), idempotent on `org_id`. A partial write — only the
+     * fields present in `patch` are set (so updating retention never clears the
+     * incident window, and vice-versa). Set self-serve by an org admin via
+     * `PUT /api/reports/settings/incidents`. Runs under the caller's org context
+     * (RLS WITH CHECK); a changed value affects DORA aggregates so the org's
+     * cached reports are dropped.
+     */
+    async setReportingSettings(orgId, patch) {
+        const set = { updatedAt: new Date() };
+        if (patch.incidentWindowHours !== undefined)
+            set.incidentWindowHours = patch.incidentWindowHours;
+        if (patch.eventRetentionDays !== undefined)
+            set.eventRetentionDays = patch.eventRetentionDays;
+        if (patch.doraRetentionDays !== undefined)
+            set.doraRetentionDays = patch.doraRetentionDays;
+        await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.insert(schema.doraSettings).values({
+            orgId,
+            incidentWindowHours: patch.incidentWindowHours,
+            eventRetentionDays: patch.eventRetentionDays,
+            doraRetentionDays: patch.doraRetentionDays,
+            updatedAt: new Date(),
+        }).onConflictDoUpdate({
+            target: schema.doraSettings.orgId,
+            set,
+        })));
+        await this.invalidateOrg(orgId).catch((err) => {
+            logger.warn('Reporting cache invalidation failed', { orgId, error: errorMessage(err) });
+        });
+    }
+    /**
+     * List recent incidents for an org (Phase 5b org-admin surface), newest first,
+     * paginated. Each row carries its resolved state and its deploy correlation —
+     * the most recent SUCCESSFUL deploy to the incident's `environment` whose
+     * `completed_at` falls within the effective per-org correlation window before
+     * `opened_at` (the same rule DORA's CFR/MTTR correlation applies). Single-org
+     * (no rollup) — an org admin views their own org's incidents. RLS-scoped via
+     * the `p.org_id`/`i.org_id` predicates + the tenant context.
+     */
+    async listIncidents(orgId, opts) {
+        const { incidentWindowHours } = await this.getIncidentSettings(orgId);
+        const windowHours = resolveIncidentWindowHours(incidentWindowHours);
+        const limit = Math.max(1, Math.min(opts.limit, 200));
+        const offset = Math.max(0, opts.offset);
+        return withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          i.incident_id AS "incidentId",
+          i.environment AS environment,
+          i.severity AS severity,
+          i.opened_at::text AS "openedAt",
+          i.resolved_at::text AS "resolvedAt",
+          i.created_at::text AS "createdAt",
+          (i.resolved_at IS NOT NULL) AS resolved,
+          corr.execution_id AS "correlatedExecutionId",
+          corr.completed_at::text AS "deployCompletedAt"
+        FROM ${schema.incident} i
+        LEFT JOIN LATERAL (
+          SELECT e.execution_id, e.completed_at
+          FROM ${schema.pipelineEvent} e
+          JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+          WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE'
+            AND e.environment = i.environment AND e.status = 'SUCCEEDED'
+            AND e.completed_at <= i.opened_at
+            AND e.completed_at >= i.opened_at - make_interval(hours => ${windowHours}::int)
+          ORDER BY e.completed_at DESC
+          LIMIT 1
+        ) corr ON true
+        WHERE i.org_id = ${orgId}
+        ORDER BY i.opened_at DESC
+        LIMIT ${limit} OFFSET ${offset}
+      `).then((r) => drizzleRows(r.rows).map((row) => ({
+            ...row,
+            resolved: row.resolved === true || row.resolved === 't',
+            correlatedExecutionId: row.correlatedExecutionId ?? null,
+            deployCompletedAt: row.deployCompletedAt ?? null,
+        }))));
+    }
+    /**
+     * Wiring-test dry-run (Phase 5b): would a synthetic incident opening NOW for
+     * `environment` correlate to a recent successful deploy under the org's
+     * effective window? This is a NON-persisting correlation check — it verifies
+     * the admin's environment naming + window line up with real deploy events
+     * WITHOUT writing an incident (so a "test" never pollutes CFR/MTTR). RLS-scoped.
+     */
+    async testIncidentCorrelation(orgId, environment) {
+        const env = scrubAwsIdentifiersFromString(environment);
+        const openedAt = new Date().toISOString();
+        const { incidentWindowHours } = await this.getIncidentSettings(orgId);
+        const windowHours = resolveIncidentWindowHours(incidentWindowHours);
+        const rows = drizzleRows((await withTenantTx((tx) => tx.execute(sql `
+        SELECT e.execution_id AS execution_id, e.completed_at::text AS completed_at
+        FROM ${schema.pipelineEvent} e
+        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE'
+          AND e.environment = ${env} AND e.status = 'SUCCEEDED'
+          AND e.completed_at <= ${openedAt}::timestamptz
+          AND e.completed_at >= ${openedAt}::timestamptz - make_interval(hours => ${windowHours}::int)
+        ORDER BY e.completed_at DESC
+        LIMIT 1
+      `))).rows);
+        const hit = rows[0];
+        return {
+            environment: env,
+            openedAt,
+            windowHours,
+            correlated: hit?.execution_id != null,
+            executionId: hit?.execution_id ?? null,
+            deployCompletedAt: hit?.completed_at ?? null,
+        };
+    }
+    /**
+     * Upsert per-org ingestion health (Phase 3): the AWS events Lambda periodically
+     * reports forwarded/dropped counters + the last event timestamp so the Reports
+     * UI can show flowing / stale / dropping. One row per org (upsert on org_id).
+     */
+    async recordIngestHealth(orgId, input) {
+        const lastEventAt = input.lastEventAt ? new Date(input.lastEventAt) : undefined;
+        await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.insert(schema.ingestHealth).values({
+            orgId,
+            forwarded: input.forwarded,
+            dropped: input.dropped,
+            lastEventAt,
+            updatedAt: new Date(),
+        }).onConflictDoUpdate({
+            target: schema.ingestHealth.orgId,
+            set: {
+                forwarded: input.forwarded,
+                dropped: input.dropped,
+                lastEventAt,
+                updatedAt: new Date(),
+            },
+        })));
+    }
+    /**
+     * Batched hard-DELETE of one reporting table's rows expired past a `created_at`
+     * cutoff, scoped to an org and an optional row predicate (Phase 7). Uses a
+     * `ctid`-in-subquery LIMIT so each statement touches at most `batchSize` rows
+     * (short lock windows, no long table scan under lock); `RETURNING 1` lets us
+     * count via `.rows.length` without depending on the driver's `rowCount`. Loops
+     * until a short batch (drained) or the per-tick cap, then defers the rest.
+     * MUST run inside a sysadmin tenant scope (see purgeExpiredReportingData) so it
+     * bypasses RLS and can delete across the org's rows.
+     */
+    async #purgeReportingTableBatched(tableSql, predicate, batchSize, maxBatches) {
+        let total = 0;
+        for (let i = 0; i < maxBatches; i++) {
+            const res = await withTenantTx((tx) => tx.execute(sql `
+        DELETE FROM ${tableSql}
+        WHERE ctid IN (
+          SELECT ctid FROM ${tableSql}
+          WHERE ${predicate}
+          LIMIT ${batchSize}
+        )
+        RETURNING 1
+      `));
+            const purged = drizzleRows(res.rows).length;
+            total += purged;
+            if (purged < batchSize)
+                break; // drained
+            if (i === maxBatches - 1) {
+                logger.warn('Reporting retention hit per-tick cap; remaining rows deferred', {
+                    purgedThisTick: total,
+                });
+            }
+        }
+        return total;
+    }
+    /**
+     * Reporting retention sweep (Phase 7). Hard-deletes rows older than their
+     * retention window, by `created_at`, across every org that has reporting data —
+     * a **split** policy so high-volume standard events expire faster than the
+     * low-volume DORA source:
+     *  - `pipeline_events WHERE environment IS NULL` → standard-event window.
+     *  - `pipeline_events WHERE environment IS NOT NULL` (deploy stages),
+     *    `deployment_outcomes`, and `incidents` → DORA-source window.
+     * Each org's windows come from its `dora_settings` override, else the global
+     * env defaults (see {@link resolveEventRetentionDays} / {@link resolveDoraRetentionDays}).
+     * `ingest_health` and `dora_settings` are never purged. One `now` for the whole
+     * tick (rows crossing the boundary mid-sweep wait for the next). Establishes a
+     * sysadmin tenant scope so the deletes span all orgs / bypass RLS — this is a
+     * cross-tenant housekeeping job. Returns (and logs) per-window purge tallies.
+     */
+    async purgeExpiredReportingData(opts = {}) {
+        const batchSize = Math.max(1, opts.batchSize ?? 1000);
+        const maxBatches = Math.max(1, opts.maxBatchesPerTable ?? 50);
+        const now = opts.now ?? new Date();
+        const counts = {
+            orgs: 0, standardEvents: 0, doraEvents: 0, deploymentOutcomes: 0, incidents: 0,
+        };
+        return runWithTenantContext({ isSuperAdmin: true }, async () => {
+            // Enumerate every org with reporting data (union across the three tables).
+            const orgRows = drizzleRows((await withTenantTx((tx) => tx.execute(sql `
+        SELECT DISTINCT org_id FROM (
+          SELECT ${schema.pipelineEvent.orgId} AS org_id FROM ${schema.pipelineEvent}
+          UNION
+          SELECT ${schema.deploymentOutcome.orgId} AS org_id FROM ${schema.deploymentOutcome}
+          UNION
+          SELECT ${schema.incident.orgId} AS org_id FROM ${schema.incident}
+        ) AS orgs
+      `))).rows);
+            if (orgRows.length === 0)
+                return counts;
+            // Per-org retention overrides (a single read; orgs without a row use defaults).
+            const overrideRows = drizzleRows((await withTenantTx((tx) => tx.execute(sql `
+        SELECT ${schema.doraSettings.orgId} AS org_id,
+               ${schema.doraSettings.eventRetentionDays} AS event_retention_days,
+               ${schema.doraSettings.doraRetentionDays} AS dora_retention_days
+        FROM ${schema.doraSettings}
+      `))).rows);
+            const overrides = new Map(overrideRows.map((r) => [r.org_id, r]));
+            const eventsTable = sql `${schema.pipelineEvent}`;
+            const outcomesTable = sql `${schema.deploymentOutcome}`;
+            const incidentsTable = sql `${schema.incident}`;
+            for (const { org_id: orgId } of orgRows) {
+                const ov = overrides.get(orgId);
+                const eventDays = resolveEventRetentionDays(ov?.event_retention_days);
+                const doraDays = resolveDoraRetentionDays(ov?.dora_retention_days);
+                // `-1` = unlimited (Phase 8): keep forever, skip that window's deletes for
+                // this org. Standard-event and DORA-source windows are independent; an org
+                // with both `-1` is fully skipped. Log the skip so it's observable.
+                const skipEvents = eventDays === -1;
+                const skipDora = doraDays === -1;
+                if (skipEvents || skipDora) {
+                    logger.info('Reporting retention sweep skipping unlimited window(s)', {
+                        orgId,
+                        standardEvents: skipEvents ? 'unlimited' : eventDays,
+                        doraSource: skipDora ? 'unlimited' : doraDays,
+                    });
+                }
+                if (!skipEvents) {
+                    const eventCutoff = retentionCutoff(now, eventDays);
+                    counts.standardEvents += await this.#purgeReportingTableBatched(eventsTable, sql `org_id = ${orgId} AND environment IS NULL AND created_at < ${eventCutoff}`, batchSize, maxBatches);
+                }
+                if (!skipDora) {
+                    const doraCutoff = retentionCutoff(now, doraDays);
+                    counts.doraEvents += await this.#purgeReportingTableBatched(eventsTable, sql `org_id = ${orgId} AND environment IS NOT NULL AND created_at < ${doraCutoff}`, batchSize, maxBatches);
+                    counts.deploymentOutcomes += await this.#purgeReportingTableBatched(outcomesTable, sql `org_id = ${orgId} AND created_at < ${doraCutoff}`, batchSize, maxBatches);
+                    counts.incidents += await this.#purgeReportingTableBatched(incidentsTable, sql `org_id = ${orgId} AND created_at < ${doraCutoff}`, batchSize, maxBatches);
+                }
+                counts.orgs += 1;
+            }
+            const purgedAny = counts.standardEvents + counts.doraEvents + counts.deploymentOutcomes + counts.incidents;
+            if (purgedAny > 0)
+                logger.info('Reporting retention sweep purged expired rows', { ...counts });
+            return counts;
+        });
+    }
+}
+export const reportingService = new ReportingService();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reporting-service.js","sourceRoot":"","sources":["../../src/api/reporting-service.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createCacheService, createLogger, errorMessage, REPORT_INTERVALS, scrubAwsIdentifiers, scrubAwsIdentifiersFromString } from '@pipeline-builder/api-core';\nimport { inArray, sql } from 'drizzle-orm';\nimport { drizzleRows } from './crud-service.js';\nimport { schema } from '../database/drizzle-schema.js';\nimport { withTenantTx, runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('reporting-service');\n\n/**\n * Defense-in-depth guard for the `DATE_TRUNC(${interval}, …)` bucket argument.\n * The route layer (`parseReportInterval`) is the security boundary and already\n * rejects unknown intervals; this assert makes an invalid value fail fast at the\n * service boundary with a clear error instead of surfacing a raw Postgres error\n * if a caller ever bypasses the route validation. Shares api-core's\n * REPORT_INTERVALS allow-list so the two can't drift.\n */\nfunction assertReportInterval(interval: string): void {\n  if (!(REPORT_INTERVALS as readonly string[]).includes(interval)) {\n    throw new Error(`Invalid report interval: ${interval}. Expected one of: ${REPORT_INTERVALS.join(', ')}`);\n  }\n}\n\n/**\n * Scrub AWS identifiers from an optional free-form string, preserving `undefined`\n * (so an absent field stays absent rather than becoming an empty scrubbed string).\n * The DURABLE persistence boundary for the ingest paths — every user/AWS-derived\n * string field is funneled through this before insert.\n */\nfunction scrubOptional(value: string | undefined): string | undefined {\n  return value !== undefined ? scrubAwsIdentifiersFromString(value) : undefined;\n}\n\n/**\n * Cache for reporting aggregations. Two tiers:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL — changes on plugin CRUD\n * - Execution/build queries with date ranges: 2 min TTL — new events arrive continuously\n */\nconst inventoryCache = createCacheService('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));\nconst timeseriesCache = createCacheService('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));\n\n// ─── Types ──────────────────────────────────────────────\n\ninterface ExecutionCount {\n  id: string;\n  project: string;\n  organization: string;\n  pipelineName: string | null;\n  total: number;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  firstExecution: string | null;\n  lastExecution: string | null;\n}\n\ninterface TimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  successPct: number;\n}\n\ninterface DurationStats {\n  id: string;\n  project: string;\n  pipelineName: string | null;\n  avgMs: number;\n  minMs: number;\n  maxMs: number;\n  p95Ms: number;\n  executions: number;\n}\n\ninterface PipelineExecution {\n  executionId: string;\n  /** Rolled-up terminal status: succeeded | failed | canceled | in-progress. */\n  status: string;\n  startedAt: string | null;\n  endedAt: string | null;\n  durationMs: number | null;\n  /** First failing stage/action for the execution (null when it didn't fail). */\n  failingStage: string | null;\n  failingAction: string | null;\n}\n\ninterface StageFailure {\n  stageName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface StageBottleneck {\n  id: string;\n  pipelineName: string | null;\n  stageName: string;\n  avgMs: number;\n  maxMs: number;\n}\n\ninterface ActionFailure {\n  actionName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface ErrorEntry {\n  errorPattern: string;\n  occurrences: number;\n  affectedPipelines: number;\n  lastSeen: string;\n}\n\ninterface PluginSummary {\n  total: number;\n  active: number;\n  inactive: number;\n  /** Counts per sharing rung — one bucket per `visibility` value. */\n  public: number;\n  org: number;\n  private: number;\n  uniqueNames: number;\n}\n\ninterface TypeComputeDistribution {\n  pluginType: string;\n  computeType: string;\n  count: number;\n}\n\ninterface VersionCount {\n  name: string;\n  versionCount: number;\n  latestVersion: string;\n  hasDefault: boolean;\n}\n\ninterface BuildTimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  successPct: number;\n}\n\ninterface BuildDuration {\n  pluginName: string;\n  avgMs: number;\n  maxMs: number;\n  builds: number;\n}\n\ninterface BuildFailure {\n  pluginName: string;\n  errorMessage: string;\n  occurrences: number;\n  lastSeen: string;\n}\n\n/**\n * The DORA headline environment. Deployment to this literal env name is the\n * industry-standard DORA signal; MTTR is measured production-only, and this\n * environment's card is the summary shown at the top of the panel.\n */\nconst HEADLINE_ENV = 'production';\n\n/**\n * Incident→deploy correlation window (Phase 5). An incident is attributed to the\n * most recent SUCCESSFUL deploy to its environment whose `completed_at` is within\n * this many hours before the incident's `opened_at`. Default 24h; override via\n * `DORA_INCIDENT_WINDOW_HOURS`. Guarded to a positive finite number.\n */\nconst DORA_INCIDENT_WINDOW_HOURS = (() => {\n  const raw = Number(process.env.DORA_INCIDENT_WINDOW_HOURS);\n  return Number.isFinite(raw) && raw > 0 ? raw : 24;\n})();\n\n/**\n * Resolve the effective incident→deploy correlation window (Phase 5b). A per-org\n * override (from `dora_settings.incident_window_hours`, surfaced through the\n * settings endpoint and threaded into {@link DoraOptions.incidentWindowHours})\n * wins when it is a positive finite number; otherwise the global env default\n * `DORA_INCIDENT_WINDOW_HOURS` applies. Centralized so the DORA correlation, the\n * incidents list, and the wiring-test dry-run all agree on the same rule.\n */\nfunction resolveIncidentWindowHours(override?: number | null): number {\n  return override != null && Number.isFinite(override) && override > 0 ? override : DORA_INCIDENT_WINDOW_HOURS;\n}\n\n/**\n * Reporting retention windows (Phase 7). Records in `pipeline_events`,\n * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a\n * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})\n * hard-deletes rows older than these windows, by `created_at`:\n *  - **Standard events** — `pipeline_events` with `environment IS NULL`\n *    (non-deploy STAGE/ACTION/build). High volume → short default (30 days).\n *  - **DORA source** — `pipeline_events` with `environment IS NOT NULL` (deploy\n *    stages) plus all of `deployment_outcomes` and `incidents`. Low volume →\n *    longer default (180 days). DORA history is therefore bounded by this window;\n *    the report query still hard-caps at 365 days (a longer per-org override only\n *    retains raw source rows, never widens a report).\n * `ingest_health` and `dora_settings` are never purged. Env-overridable globals;\n * a per-org override in `dora_settings` wins (see {@link resolveEventRetentionDays}).\n */\nconst RETENTION_MIN_DAYS = 1;\nconst RETENTION_MAX_DAYS = 730;\n\n/** Parse a positive-int env day-count, clamped to [MIN, MAX], else `fallback`. */\nfunction retentionEnvDays(name: string, fallback: number): number {\n  const raw = Number(process.env[name]);\n  if (!Number.isFinite(raw) || !Number.isInteger(raw) || raw < RETENTION_MIN_DAYS) return fallback;\n  return Math.min(raw, RETENTION_MAX_DAYS);\n}\n\nconst REPORTING_EVENT_RETENTION_DAYS = retentionEnvDays('REPORTING_EVENT_RETENTION_DAYS', 30);\nconst REPORTING_DORA_RETENTION_DAYS = retentionEnvDays('REPORTING_DORA_RETENTION_DAYS', 180);\n\n/** Effective standard-event retention (days): a valid per-org override wins,\n *  else the global env default. Shared by the sweep + the settings surface so\n *  they can't drift. The `-1` unlimited sentinel (Phase 8) passes straight\n *  through — the sweep reads it as \"keep forever, skip this org's standard\n *  events\". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a\n *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the\n *  env default. */\nexport function resolveEventRetentionDays(override?: number | null): number {\n  if (override === -1) return -1;\n  return override != null && Number.isInteger(override) && override >= RETENTION_MIN_DAYS\n    ? Math.min(override, RETENTION_MAX_DAYS) : REPORTING_EVENT_RETENTION_DAYS;\n}\n\n/** Effective DORA-source retention (days): a valid per-org override wins, else\n *  the global env default. The `-1` unlimited sentinel (Phase 8) passes straight\n *  through — the sweep reads it as \"keep forever, skip this org's DORA-source\n *  windows\". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a\n *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the\n *  env default. */\nexport function resolveDoraRetentionDays(override?: number | null): number {\n  if (override === -1) return -1;\n  return override != null && Number.isInteger(override) && override >= RETENTION_MIN_DAYS\n    ? Math.min(override, RETENTION_MAX_DAYS) : REPORTING_DORA_RETENTION_DAYS;\n}\n\n/** The cutoff instant for a retention window: rows with `created_at` strictly\n *  before this (`< cutoff`) are expired. Deterministic for a fixed `now`. */\nexport function retentionCutoff(now: Date, days: number): Date {\n  return new Date(now.getTime() - days * 86_400_000);\n}\n\n/** Per-org retention override row (Phase 7). Both nullable ⇒ global defaults. */\nexport interface ReportingRetentionSettings {\n  eventRetentionDays: number | null;\n  doraRetentionDays: number | null;\n  defaultEventRetentionDays: number;\n  defaultDoraRetentionDays: number;\n}\n\n/** Options for the reporting retention sweep. */\nexport interface ReportingRetentionOptions {\n  /** Rows deleted per statement (default 1000). */\n  batchSize?: number;\n  /** Max batches per table per org per tick (default 50); the rest defers to\n   *  the next tick so a huge backlog can't hold locks too long. */\n  maxBatchesPerTable?: number;\n  /** Fixed \"now\" for the whole sweep (default `new Date()`). */\n  now?: Date;\n}\n\n/** Per-run purge tallies (also logged). */\nexport interface ReportingRetentionCounts {\n  /** Orgs swept this run. */\n  orgs: number;\n  /** Standard `pipeline_events` (environment IS NULL) rows purged. */\n  standardEvents: number;\n  /** DORA-source `pipeline_events` (environment IS NOT NULL) rows purged. */\n  doraEvents: number;\n  /** `deployment_outcomes` rows purged. */\n  deploymentOutcomes: number;\n  /** `incidents` rows purged. */\n  incidents: number;\n}\n\n/**\n * DORA performance band. `null` = insufficient data to classify (no\n * deployments/failures/lead-time sample in the window), so the UI shows a\n * neutral state rather than mislabeling an empty window as \"low\".\n */\nexport type DoraLevel = 'elite' | 'high' | 'medium' | 'low' | null;\n\n/** Optional scoping for {@link ReportingService.getDoraMetrics}. */\nexport interface DoraOptions {\n  /** Restrict to a single pipeline (per-pipeline DORA). */\n  pipelineId?: string;\n  /** Restrict to a single deploy environment (else all deploy environments). */\n  environment?: string;\n  /**\n   * Per-org incident→deploy correlation window override (hours). When set (a\n   * positive finite number), the incident correlation uses it instead of the\n   * global `DORA_INCIDENT_WINDOW_HOURS`. The route resolves this from the org's\n   * `dora_settings` row (see {@link ReportingService.getIncidentSettings}) and\n   * passes it in; unset falls back to the env default.\n   */\n  incidentWindowHours?: number;\n}\n\n/**\n * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`\n * (Phase 5b) is the incident→deploy correlation window; `eventRetentionDays` /\n * `doraRetentionDays` (Phase 7) are the two retention-sweep windows. Each override\n * is `null` when unset (the paired `default*` field shows the env fallback applied).\n */\nexport interface IncidentSettings {\n  /** The org's stored correlation-window override in hours, or `null` when unset. */\n  incidentWindowHours: number | null;\n  /** The global env default applied when no override is stored. */\n  defaultWindowHours: number;\n  /** Standard-event retention override in days, or `null` when unset (Phase 7). */\n  eventRetentionDays: number | null;\n  /** DORA-source retention override in days, or `null` when unset (Phase 7). */\n  doraRetentionDays: number | null;\n  /** Global standard-event retention default applied when unset (days). */\n  defaultEventRetentionDays: number;\n  /** Global DORA-source retention default applied when unset (days). */\n  defaultDoraRetentionDays: number;\n}\n\n/** A partial reporting-settings write (Phase 5b + 7). Only provided fields are\n *  upserted; omitted fields are left unchanged (an omitted retention field keeps\n *  its stored override / the global default). */\nexport interface ReportingSettingsPatch {\n  incidentWindowHours?: number;\n  eventRetentionDays?: number;\n  doraRetentionDays?: number;\n}\n\n/** One row of the org-admin incidents list (recent incidents + deploy correlation). */\nexport interface IncidentListItem {\n  incidentId: string;\n  environment: string;\n  severity: string;\n  openedAt: string | null;\n  resolvedAt: string | null;\n  createdAt: string | null;\n  /** True once the incident has a `resolved_at`. */\n  resolved: boolean;\n  /** The correlated deploy execution id (most recent successful deploy in-window), or null. */\n  correlatedExecutionId: string | null;\n  /** That deploy's completion instant, or null when uncorrelated. */\n  deployCompletedAt: string | null;\n}\n\n/** Result of the wiring-test dry-run correlation ({@link ReportingService.testIncidentCorrelation}). */\nexport interface IncidentTestResult {\n  environment: string;\n  /** The synthetic incident's openedAt (now, ISO). */\n  openedAt: string;\n  /** The effective correlation window used. */\n  windowHours: number;\n  /** Whether a recent successful deploy to `environment` correlated. */\n  correlated: boolean;\n  /** The correlated deploy execution id, or null. */\n  executionId: string | null;\n  /** That deploy's completion instant, or null. */\n  deployCompletedAt: string | null;\n}\n\n// DORA performance bands (thresholds from the DORA/Accelerate reports). Each\n// helper returns `null` when there's no sample to classify.\n/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */\nfunction doraLevelForFrequency(perDay: number, deployments: number): DoraLevel {\n  if (deployments <= 0) return null;\n  if (perDay >= 1) return 'elite';\n  if (perDay >= 1 / 7) return 'high';\n  if (perDay >= 1 / 30) return 'medium';\n  return 'low';\n}\n/** Change failure rate by percent: elite ≤5%, high ≤10%, medium ≤15%. */\nfunction doraLevelForChangeFailure(pct: number, total: number): DoraLevel {\n  if (total <= 0) return null;\n  if (pct <= 5) return 'elite';\n  if (pct <= 10) return 'high';\n  if (pct <= 15) return 'medium';\n  return 'low';\n}\n/** Time to restore by seconds: elite <1h, high <1 day, medium <1 week. */\nfunction doraLevelForRestore(avgSeconds: number | null): DoraLevel {\n  if (avgSeconds == null) return null;\n  if (avgSeconds < 3600) return 'elite';\n  if (avgSeconds < 86400) return 'high';\n  if (avgSeconds < 604800) return 'medium';\n  return 'low';\n}\n/** Lead time by seconds: elite <1 day, high <1 week, medium <1 month. */\nfunction doraLevelForLeadTime(medianSeconds: number | null): DoraLevel {\n  if (medianSeconds == null) return null;\n  if (medianSeconds < 86400) return 'elite';\n  if (medianSeconds < 604800) return 'high';\n  if (medianSeconds < 2592000) return 'medium';\n  return 'low';\n}\n\n/**\n * Round `value` to `digits` decimal places, returning a real number. Small\n * module-private helper so the DORA shaping doesn't repeat the\n * `Number(Number(x).toFixed(n))` pattern (toFixed alone yields a string).\n */\nfunction round(value: number, digits: number): number {\n  return Number(value.toFixed(digits));\n}\n\n/**\n * Median of a numeric sample, or `null` when empty. Used for measured lead time\n * and MTTR — both are cross-source gaps computed in JS from clamped deltas, so\n * the median lives here rather than in SQL PERCENTILE_CONT (keeps the golden\n * fixture tests able to prove the metric math without a live Postgres).\n */\nfunction median(values: number[]): number | null {\n  if (values.length === 0) return null;\n  const s = [...values].sort((a, b) => a - b);\n  const mid = Math.floor(s.length / 2);\n  return s.length % 2 === 1 ? s[mid] : (s[mid - 1] + s[mid]) / 2;\n}\n\n/**\n * Roll a group of deploy/stage events (grouped per execution) up to one terminal\n * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).\n * Shared by the three per-(env|stage, execution) rollup CTEs — DORA metrics, DORA\n * trend, and build health — so the precedence can't drift between them. Assumes the\n * grouped event alias is `e`.\n */\nconst terminalStatusRollup = sql`CASE\n              WHEN bool_or(e.status = 'FAILED') THEN 'FAILED'\n              WHEN bool_or(e.status = 'SUCCEEDED') THEN 'SUCCEEDED'\n              ELSE 'OTHER'\n            END`;\n\n/** Optional `[from,to]` window on `e.started_at` for the execution reports —\n *  a no-op `sql` fragment when either bound is absent (all-time). Shared by the\n *  execution-count and per-pipeline-execution reports so they narrow identically. */\nfunction optionalStartedAtRange(range?: { from?: string; to?: string }): ReturnType<typeof sql> {\n  return range?.from && range?.to\n    ? sql`AND e.started_at >= ${range.from}::timestamptz AND e.started_at <= ${range.to}::timestamptz`\n    : sql``;\n}\n\n/**\n * Per-execution terminal deploy row (D1 — one row per (environment, execution),\n * NOT per stage). The SQL rolls every deploy STAGE targeting an env within an\n * execution up to a single terminal status; the JS shaping buckets these by\n * environment. `commit_ts` (D2) is the execution's EARLIEST commit time across\n * all its events — commit enrichment rides the PIPELINE/source event, not the\n * deploy STAGE — joined by execution_id (null when unresolved → lead `unknown`).\n * `in_window` is false for a look-back-only row kept solely so incidents opened\n * near `from` can correlate to a deploy that completed just before the window.\n */\ninterface DeployRow {\n  environment: string;\n  status: 'SUCCEEDED' | 'FAILED' | string;\n  /** Deploy execution id — the attribution key for dedup against outcomes/incidents. */\n  execution_id: string | null;\n  completed_at: string | null;\n  commit_ts: string | null;\n  /**\n   * Whether the deploy completed inside [from,to]. Absent (undefined) in unit\n   * fixtures ⇒ treated as in-window. `t`/`f` tolerated (pg boolean text form).\n   */\n  in_window?: boolean | string | null;\n}\n\n/** Raw post-deploy outcome marker row (from `deployment_outcomes`, in-window). */\ninterface OutcomeRow {\n  environment: string | null;\n  outcome: 'failed' | 'restored' | string;\n  /** Execution the user marked — dedup key against incident-correlated deploys. */\n  execution_id: string | null;\n}\n\n/** Production restored-incident pair: recovery time + the deploy's completion. */\ninterface MttrPairRow {\n  restored_at: string | null;\n  deployed_at: string | null;\n  /** Execution id — lets incident precedence override the manual outcome per deploy. */\n  execution_id: string | null;\n}\n\n/**\n * Raw incident row (from `incidents`, opened in-window). Correlated in JS to the\n * most recent successful deploy to `environment` within DORA_INCIDENT_WINDOW_HOURS\n * → an automated post-deploy failure (CFR) + real recovery time (MTTR).\n */\ninterface IncidentRow {\n  environment: string;\n  opened_at: string | null;\n  resolved_at: string | null;\n}\n\n/** Coverage counts: registered pipelines vs those that actually deployed. */\ninterface CoverageRow {\n  registered: number | string | null;\n  deploying: number | string | null;\n}\n\n/**\n * DORA metrics over a [from,to] window, org-scoped (single-org or rollup subtree).\n *\n * DEPLOY-BASIS — every metric derives from real DEPLOY-STAGE executions, i.e.\n * `pipeline_events` rows with `event_type='STAGE'` and a non-null `environment`\n * (the forwarder sets `environment` only for the stages a user declared in\n * `pb.deploys`). A CI-only build/test pipeline with no deploy stage produces NO\n * DORA data — there is no run-based fallback. The panel is empty until deployed\n * pipelines re-synth with the new deploy tags and start emitting deploy events.\n *\n * `production` is the headline environment; MTTR is measured production-only.\n */\nexport interface DoraMetrics {\n  /** The [from,to] window echoed back (deploy `completed_at` range). */\n  window: { from: string; to: string };\n  /** The scoping applied (echoed for the UI); `null` when unscoped. */\n  filters: { pipelineId: string | null; environment: string | null };\n  /** The headline environment name (`production`). */\n  headline: string;\n  /** Per-environment DF / CFR / lead time. Sorted headline-first, then A→Z. */\n  environments: DoraEnvMetrics[];\n  /**\n   * Mean Time To Restore — PRODUCTION-ONLY, from `deployment_outcomes`.\n   * `median(restored.at − deployed.completed_at)` over restored production\n   * incidents (deltas clamped ≥0). `incidents` counts production deploys marked\n   * failed; `restored` counts those that recovered; `medianSeconds` is null when\n   * no restored incident has a resolvable deploy time.\n   */\n  meanTimeToRestore: {\n    incidents: number;\n    restored: number;\n    medianSeconds: number | null;\n    level: DoraLevel;\n  };\n  /**\n   * Coverage reconciliation — registered pipelines with no observed deploy in\n   * the window. A high `withoutDeploys` count means DORA is blind to most of the\n   * fleet (pipelines that haven't re-synthed with deploy tags, or don't deploy).\n   */\n  coverage: {\n    /** Pipelines in the registry (org-scoped). */\n    registered: number;\n    /** Registered pipelines with ≥1 deploy-stage execution in the window. */\n    deploying: number;\n    /** registered − deploying (clamped ≥0). */\n    withoutDeploys: number;\n  };\n}\n\n/** Per-environment DORA metrics (deployment frequency, CFR, lead time). */\nexport interface DoraEnvMetrics {\n  environment: string;\n  /** Deployment Frequency — successful deploy-stage executions for this env. */\n  deploymentFrequency: {\n    deployments: number;\n    perDay: number;\n    level: DoraLevel;\n  };\n  /**\n   * Change Failure Rate — two-class:\n   * `(deployTimeFailures + postDeployFailures) / attempts`.\n   * - `deployTimeFailures` — deploy stage `result=failed` (from events).\n   * - `postDeployFailures` — a successful deploy later marked failed in prod\n   *   (from `deployment_outcomes`).\n   * - `attempts` — all terminal deploy-stage attempts (succeeded + failed).\n   */\n  changeFailureRate: {\n    rate: number;\n    deployTimeFailures: number;\n    postDeployFailures: number;\n    attempts: number;\n    level: DoraLevel;\n  };\n  /**\n   * Lead Time — MEASURED: `median(deploy_completed − oldest_commit_time)` over\n   * successful deploys with a resolvable commit timestamp (deltas clamped ≥0).\n   * `medianSeconds` is `null` (= unknown) when no successful deploy in this env\n   * carried a `commit_timestamp`. The old median-run-duration proxy is removed.\n   */\n  leadTime: {\n    /** Successful deploys with a resolvable commit time (the median sample). */\n    deployments: number;\n    medianSeconds: number | null;\n    level: DoraLevel;\n  };\n}\n\n/** One interval bucket of the DORA trend (deploy frequency + change failure). */\nexport interface DoraTrendPoint {\n  /** Bucket start (DATE_TRUNC of the deploy `completed_at`), ISO text. */\n  period: string;\n  /** Successful deploy-stage executions in the bucket. */\n  deployments: number;\n  /** Failed deploy-stage executions in the bucket. */\n  failed: number;\n  /** succeeded + failed in the bucket (deploy attempts). */\n  total: number;\n  /** failed/total as a percent (0 when total is 0). Deploy-time CFR only. */\n  changeFailurePct: number;\n}\n\n/** Per-stage build-health metrics (Phase 6) for one pipeline over a window. */\nexport interface BuildHealthStage {\n  stage: string;\n  /** Terminal stage runs (succeeded + failed) in the window. */\n  runs: number;\n  successes: number;\n  failures: number;\n  /** successes / runs as a percent (0 when runs is 0). */\n  successRate: number;\n  /** Duration percentiles over the stage's terminal runs; null when no durations. */\n  p50Ms: number | null;\n  p90Ms: number | null;\n  p99Ms: number | null;\n}\n\n/**\n * Per-pipeline build-health breakdown (Phase 6). Standard reporting (NOT\n * `advanced_reporting`-gated) — per-stage success rate + timing percentiles, with\n * totals summed across stages.\n */\nexport interface BuildHealth {\n  stages: BuildHealthStage[];\n  totals: { runs: number; failures: number; failureRate: number };\n}\n\n/** Post-deploy incident marker (Phase 5) accepted by `ReportingService.recordIncident`. */\nexport interface IncidentInput {\n  incidentId: string;\n  environment: string;\n  openedAt: string;\n  resolvedAt?: string;\n  severity: string;\n}\n\n/** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */\nexport interface IngestEvent {\n  /** Stable pipeline id the events Lambda read from the `pb.pipeline-id`\n   *  tag (= the platform pipelineId). The registry join key. */\n  pipelineId: string;\n  eventSource: 'codepipeline' | 'codebuild' | 'plugin-build';\n  eventType: 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason (Action events). */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  /** Source commit id of the change being shipped (DORA deploy attribution). */\n  commitSha?: string;\n  /** Source ref/branch (DORA deploy attribution). */\n  commitRef?: string;\n  /** Deploy target (e.g. \"production\"). Its presence on a STAGE/ACTION event\n   *  marks a real deployment (derived server-side — there is no `isDeploy`). */\n  environment?: string;\n  /** Oldest unshipped commit timestamp (ISO 8601) for measured lead time. */\n  commitTimestamp?: string;\n  /** Number of commits shipped in this change (≥1). */\n  commitCount?: number;\n  detail?: Record<string, unknown>;\n}\n\n/**\n * Per-event metric descriptor emitted (via the {@link ReportingService.ingestEvents}\n * `onMetric` hook) for each REGISTERED terminal deploy/stage event, so the route\n * layer can fan them into Prometheus counters without pipeline-data importing\n * api-server's metrics registry. `result` is the terminal outcome; `environment`\n * is non-null only for a deploy-stage event.\n */\nexport interface IngestMetric {\n  pipelineId: string;\n  orgId: string;\n  stage: string;\n  environment: string | null;\n  result: 'succeeded' | 'failed';\n}\n\n/** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */\nexport interface IngestResult {\n  inserted: number;\n  skipped: number;\n  unregisteredPipelineIds: string[];\n}\n\n// ─── Service ────────────────────────────────────────────\n\n/**\n * Read-only reporting service for pipeline execution and plugin inventory aggregations.\n * Does not extend CrudService — reports are aggregate queries, not entity CRUD.\n *\n * All queries are cached in-memory to avoid repeated expensive SQL aggregations:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL\n * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL\n */\nexport class ReportingService {\n\n  /** Invalidate all cached reports for an org (call after event ingest). */\n  async invalidateOrg(orgId: string): Promise<void> {\n    await Promise.all([\n      inventoryCache.invalidatePattern(`${orgId}:*`),\n      timeseriesCache.invalidatePattern(`${orgId}:*`),\n    ]);\n  }\n\n  /**\n   * Resolve incoming events against the pipeline registry, batch-insert the\n   * matched ones, and invalidate reporting caches for affected orgs.\n   * Events for unregistered pipeline ids are dropped (and logged at WARN\n   * with sample ids so an operator can see when EventBridge is delivering\n   * events for pipelines that haven't called POST /pipelines/registry yet).\n   *\n   * Returns counts + a sample of unregistered pipeline ids for observability.\n   */\n  async ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void): Promise<IngestResult> {\n    // Multi-org batch insert: the caller resolves to multiple orgs via the\n    // pipeline-registry lookup below, so the route layer MUST establish a\n    // `runWithTenantContext({ isSuperAdmin: true }, ...)` scope before calling\n    // this method. Under FORCE'd RLS, a single tx with `app.org_id = <one\n    // org>` could only write events for that org; bypass via sysadmin is\n    // the right gate for this server-internal cross-tenant endpoint. See\n    // api/reporting/src/routes/event-ingest.ts for the wrapper.\n    // Run insert inside the tx, but COLLECT affected orgs and invalidate\n    // caches AFTER the tx resolves. Keeping invalidation inside the tx held\n    // the pg locks open for the duration of the cache round-trips (Redis or\n    // in-memory invalidations are unrelated to the tx but still serialized\n    // its commit). Cache TTL is 2-5 min so fire-and-forget post-commit is\n    // an acceptable trade for tighter lock windows.\n    const { inserted, skipped, unregisteredPipelineIds, affectedOrgs } = await withTenantTx(async (tx) => {\n      // Batch-resolve all unique pipeline ids in one query\n      const uniqueIds = [...new Set(events.map(e => e.pipelineId))];\n      const registryRows = await tx\n        .select({\n          pipelineId: schema.pipelineRegistry.pipelineId,\n          orgId: schema.pipelineRegistry.orgId,\n        })\n        .from(schema.pipelineRegistry)\n        .where(inArray(schema.pipelineRegistry.pipelineId, uniqueIds));\n\n      const idMap = new Map(registryRows.map(r => [r.pipelineId, r]));\n\n      // Build insert batch (skip events whose pipeline isn't registered)\n      const rows: Array<typeof schema.pipelineEvent.$inferInsert> = [];\n      let skippedLocal = 0;\n      const unregisteredLocal: string[] = [];\n\n      for (const event of events) {\n        const registry = idMap.get(event.pipelineId);\n        if (!registry) {\n          skippedLocal++;\n          unregisteredLocal.push(event.pipelineId);\n          continue;\n        }\n\n        rows.push({\n          // registry.pipelineId === event.pipelineId; use the registry's so the\n          // FK is always a row that exists, and pull orgId from the registry for\n          // tenancy (never trust the caller's claimed org).\n          pipelineId: registry.pipelineId,\n          orgId: registry.orgId,\n          eventSource: event.eventSource,\n          eventType: event.eventType,\n          status: event.status,\n          // executionId is an AWS-ASSIGNED identifier (a UUID), not free-form\n          // user text, so it can't carry an account id — and scrubbing a UUID\n          // that happens to contain a 12-digit run would corrupt the correlation\n          // key. Left intact by design.\n          executionId: event.executionId,\n          // stageName/actionName are USER-AUTHORED pipeline-structure names\n          // promoted from the CodePipeline detail — same untrusted-AWS-derived\n          // origin as errorMessage below, so scrub them at this persistence\n          // boundary too (a stage named with an ARN/12-digit id must not persist).\n          stageName: scrubOptional(event.stageName),\n          actionName: scrubOptional(event.actionName),\n          // HARD CONSTRAINT: an AWS account id must NEVER be persisted. This is\n          // the DURABLE persistence boundary and must not trust upstream:\n          // CodePipeline/CodeBuild failure detail & messages routinely carry\n          // ARNs (arn:aws:…:<account-id>:…) and bare 12-digit account ids. Scrub\n          // both free-form fields here before insert (per-event, non-mutating).\n          errorMessage: scrubOptional(event.errorMessage),\n          startedAt: event.startedAt ? new Date(event.startedAt) : undefined,\n          completedAt: event.completedAt ? new Date(event.completedAt) : undefined,\n          durationMs: event.durationMs,\n          // Deploy-attribution fields — scrubbed like the other free-form strings\n          // so an ARN/account id can never enter via a ref or environment name.\n          commitSha: scrubOptional(event.commitSha),\n          commitRef: scrubOptional(event.commitRef),\n          environment: scrubOptional(event.environment),\n          // Measured lead time (Phase 4): oldest unshipped commit time + count.\n          // commitTimestamp is an AWS/SCM-derived instant (never account-id\n          // shaped); commitCount is a plain integer. Neither needs scrubbing.\n          commitTimestamp: event.commitTimestamp ? new Date(event.commitTimestamp) : undefined,\n          commitCount: event.commitCount,\n          detail: event.detail !== undefined\n            ? scrubAwsIdentifiers(event.detail)\n            : undefined,\n        });\n\n        // Phase 3b: fan terminal STAGE outcomes into Prometheus counters via the\n        // route's hook (pipeline-data can't import api-server's registry). Emit\n        // per registered stage event with a terminal succeeded/failed result;\n        // a non-null environment additionally marks it a deploy result.\n        if (onMetric && event.eventType === 'STAGE' && (event.status === 'SUCCEEDED' || event.status === 'FAILED')) {\n          onMetric({\n            pipelineId: registry.pipelineId,\n            orgId: registry.orgId,\n            stage: scrubOptional(event.stageName) ?? '',\n            environment: scrubOptional(event.environment) ?? null,\n            result: event.status === 'SUCCEEDED' ? 'succeeded' : 'failed',\n          });\n        }\n      }\n\n      // SQS is at-least-once, so EventBridge can deliver the same state-change\n      // twice. `onConflictDoNothing` + the partial unique index on\n      // (pipeline_id, execution_id, event_type, status, stage_name, action_name)\n      // makes re-delivery idempotent. `returning` gives the REAL inserted set so\n      // counts + cache invalidation ignore duplicates.\n      const insertedRows = rows.length > 0\n        ? await tx.insert(schema.pipelineEvent).values(rows)\n          .onConflictDoNothing()\n          .returning({ orgId: schema.pipelineEvent.orgId })\n        : [];\n\n      return {\n        inserted: insertedRows.length,\n        skipped: skippedLocal,\n        unregisteredPipelineIds: unregisteredLocal,\n        affectedOrgs: [...new Set(insertedRows.map(r => r.orgId))],\n      };\n    });\n\n    // Surface the silent skip: an unregistered pipeline id usually means the\n    // pipeline hasn't called POST /pipelines/registry yet (or its\n    // pb.pipeline-id tag is missing/unreadable by the Lambda). Logging it\n    // makes a broken join visible instead of looking like \"no activity\".\n    if (unregisteredPipelineIds.length > 0) {\n      logger.warn('Pipeline events skipped: pipeline id not found in registry', {\n        count: unregisteredPipelineIds.length,\n        sample: unregisteredPipelineIds.slice(0, 3),\n      });\n    }\n\n    // Post-commit cache invalidation. Fire-and-forget with logging — TTL is\n    // short enough that a missed invalidation self-heals.\n    if (affectedOrgs.length > 0) {\n      void Promise.all(affectedOrgs.map((org) =>\n        this.invalidateOrg(org).catch((err) => {\n          logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });\n        }),\n      ));\n    }\n\n    return { inserted, skipped, unregisteredPipelineIds };\n  }\n\n  // ── Category 1: Pipeline Execution & Performance ──\n\n  /**\n   * Build the org-scope predicate for a report query. With `orgIds` (the\n   * org → team rollup — a parent's `[self, ...descendants]`) it becomes an\n   * `IN (...)` over the subtree; otherwise the single-org `= $org`. Returns a\n   * `multi` flag so callers can run multi-org reads under sysadmin context\n   * (the subtree spans orgs outside the request's RLS scope) and salt the\n   * cache key.\n   */\n  private orgScope(orgId: string, orgIds?: string[]) {\n    // Defense-in-depth: the multi-org rollup runs under sysadmin context (RLS\n    // OFF, see runReport), so `orgIds` is the ONLY tenancy gate on the read. The\n    // route resolves it from the platform's authoritative descendants endpoint as\n    // `[self, ...descendants]`, but validate the subtree defensively here before\n    // the bypass: the requesting (anchor) org MUST appear in the set. A set that\n    // omits the caller's own org is a malformed/spoofed rollup — collapse to the\n    // safe single-org scope rather than reading an arbitrary org under sysadmin.\n    // (Full descendant-membership validation needs the org tree, which this\n    // service does not hold — see the report FLAG.)\n    const anchor = orgId.toLowerCase();\n    const provided = (orgIds ?? []).filter((id) => typeof id === 'string' && id.length > 0);\n    const anchored = provided.some((id) => id.toLowerCase() === anchor);\n    if (provided.length > 0 && !anchored) {\n      logger.warn('Reporting rollup rejected: requesting org absent from resolved subtree; using single-org scope', {\n        orgId: anchor, subtreeSize: provided.length,\n      });\n    }\n    const ids = provided.length > 0 && anchored ? provided : [orgId];\n    const multi = ids.length > 1;\n    const pred = multi\n      ? sql`IN (${sql.join(ids.map((id) => sql`${id}`), sql`, `)})`\n      : sql`= ${ids[0]}`;\n    return { pred, multi };\n  }\n\n  /**\n   * Run a report read. Single-org reads use the per-org cache (invalidated on\n   * that org's event ingest). Rollup (multi-org) reads **bypass the cache** and\n   * run under sysadmin context: they're admin-only and lower-frequency, and a\n   * child org's event ingest can't invalidate a parent's rollup entry (reporting\n   * has no org tree), so caching them would serve stale aggregates. Always fresh.\n   */\n  private runReport<T>(cacheKey: string, multi: boolean, exec: () => Promise<T>): Promise<T> {\n    return multi\n      ? runWithTenantContext({ isSuperAdmin: true }, exec)\n      : timeseriesCache.getOrSet(cacheKey, exec);\n  }\n\n  /** 1.1 Execution count per pipeline with status breakdown. */\n  async getExecutionCount(orgId: string, orgIds?: string[], range?: { from?: string; to?: string }): Promise<ExecutionCount[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    // Optional [from,to] window on the execution's started_at, mirroring the\n    // sibling timeseries reports so the dashboard date-range picker narrows the\n    // count too (an empty range = all-time, preserving the prior behavior). The\n    // range rides the JOIN so pipelines with no in-window events still list\n    // (LEFT semantics preserved via the inner-join filter — a pipeline with zero\n    // matching events drops from the count, same as before for its window).\n    const rangeClause = optionalStartedAtRange(range);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.project, p.organization, p.pipeline_name,\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          MIN(e.started_at)::text AS first_execution,\n          MAX(e.started_at)::text AS last_execution\n        FROM ${schema.pipeline} p\n        JOIN ${schema.pipelineEvent} e ON e.pipeline_id = p.id\n          AND e.event_type = 'PIPELINE' AND e.status != 'STARTED'\n          ${rangeClause}\n        WHERE p.org_id ${pred} AND p.is_active = true\n        GROUP BY p.id\n        ORDER BY total DESC\n      `).then(r => drizzleRows<ExecutionCount>(r.rows)));\n    return this.runReport(`${orgId}:exec-count:${range?.from ?? ''}:${range?.to ?? ''}`, multi, exec);\n  }\n\n  /**\n   * 1.1b Per-pipeline execution history — DISTINCT executions for one pipeline,\n   * newest first. Groups all events by `execution_id` in a single scan and\n   * rolls each execution up to one row:\n   *   - status: derived from the PIPELINE-type events. FAILED wins, then\n   *     SUCCEEDED, then CANCELED; an execution with no terminal PIPELINE event\n   *     is still `in-progress`.\n   *   - startedAt/endedAt/durationMs: from the PIPELINE lifecycle events.\n   *   - failingStage/failingAction: the first FAILED STAGE/ACTION event (cheap —\n   *     same scan, no extra query).\n   *\n   * ORG-SCOPING: identical to the sibling execution reports — joins the pipeline\n   * registry table (`pipeline`) and gates on `p.org_id ${pred}`, where `pred` is\n   * the single-org `= $org` or (with a rollup) an `IN (...)` over the org→team\n   * subtree. A pipelineId belonging to another org yields zero rows.\n   */\n  async listPipelineExecutions(\n    orgId: string,\n    pipelineId: string,\n    orgIds?: string[],\n    range?: { from?: string; to?: string },\n    limit: number = 50,\n  ): Promise<PipelineExecution[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const rangeClause = optionalStartedAtRange(range);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.execution_id,\n          CASE\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'FAILED') THEN 'failed'\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'SUCCEEDED') THEN 'succeeded'\n            WHEN bool_or(e.event_type = 'PIPELINE' AND e.status = 'CANCELED') THEN 'canceled'\n            ELSE 'in-progress'\n          END AS status,\n          MIN(e.started_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS started_at,\n          MAX(e.completed_at) FILTER (WHERE e.event_type = 'PIPELINE')::text AS ended_at,\n          MAX(e.duration_ms) FILTER (WHERE e.event_type = 'PIPELINE')::int AS duration_ms,\n          (ARRAY_AGG(e.stage_name) FILTER (WHERE e.event_type = 'STAGE' AND e.status = 'FAILED'))[1] AS failing_stage,\n          (ARRAY_AGG(e.action_name) FILTER (WHERE e.event_type = 'ACTION' AND e.status = 'FAILED'))[1] AS failing_action\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} AND e.execution_id IS NOT NULL\n          ${rangeClause}\n        GROUP BY e.execution_id\n        ORDER BY MAX(e.created_at) DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<PipelineExecution>(r.rows)));\n    return this.runReport(`${orgId}:pipeline-executions:${pipelineId}:${range?.from ?? ''}:${range?.to ?? ''}:${limit}`, multi, exec);\n  }\n\n  /** 1.2 Success rate over time for an org. */\n  async getSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[]): Promise<TimeSeriesEntry[]> {\n    assertReportInterval(interval);\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\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 = 'PIPELINE'\n          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => drizzleRows<TimeSeriesEntry>(r.rows)));\n    return this.runReport(`${orgId}:success-rate:${interval}:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.3 Average duration per pipeline. */\n  async getAverageDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<DurationStats[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.project, p.pipeline_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MIN(e.duration_ms)::int AS min_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS p95_ms,\n          COUNT(*)::int AS executions\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 = 'PIPELINE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<DurationStats>(r.rows)));\n    return this.runReport(`${orgId}:avg-duration:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.5 Stage failure heatmap — which stages fail most. */\n  async getStageFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageFailure[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.stage_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\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.stage_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.stage_name ORDER BY failures DESC\n      `).then(r => drizzleRows<StageFailure>(r.rows)));\n    return this.runReport(`${orgId}:stage-failures:${from}:${to}`, multi, exec);\n  }\n\n  /**\n   * Distinct deploy `environment` values observed in the window — powers the\n   * DORA environment-scope datalist. Org-scoped + rollup-aware like the sibling\n   * reports; only non-null environments (i.e. deploy-attributed executions).\n   */\n  async getReportEnvironments(orgId: string, from: string, to: string, orgIds?: string[]): Promise<string[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT DISTINCT e.environment AS environment\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.environment IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        ORDER BY environment\n      `).then(r => drizzleRows<{ environment: string }>(r.rows).map((row) => row.environment)));\n    return this.runReport(`${orgId}:report-envs:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.6 Stage bottlenecks — slowest stages per pipeline. */\n  async getStageBottlenecks(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageBottleneck[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          p.id, p.pipeline_name, e.stage_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_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.event_type = 'STAGE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<StageBottleneck>(r.rows)));\n    return this.runReport(`${orgId}:stage-bottlenecks:${from}:${to}`, multi, exec);\n  }\n\n  /** 1.7 Action failure rate — which plugin steps fail most. */\n  async getActionFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<ActionFailure[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.action_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\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 = 'ACTION' AND e.action_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.action_name ORDER BY failures DESC\n      `).then(r => drizzleRows<ActionFailure>(r.rows)));\n    return this.runReport(`${orgId}:action-failures:${from}:${to}`, multi, exec);\n  }\n\n  /**\n   * 1.8 Error categorization — group failure messages. Execution report, so\n   * rollup-aware exactly like the sibling execution reports: with `orgIds`\n   * (the org→team subtree) the org gate becomes an `IN (...)` and the read runs\n   * fresh under sysadmin via `runReport`; single-org reads keep the per-org cache.\n   */\n  async getErrors(orgId: string, from: string, to: string, limit: number = 20, orgIds?: string[]): Promise<ErrorEntry[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          SUBSTRING(e.error_message FROM 1 FOR 200) AS error_pattern,\n          COUNT(*)::int AS occurrences,\n          COUNT(DISTINCT e.pipeline_id)::int AS affected_pipelines,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id ${pred} AND e.status = 'FAILED' AND e.error_message IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY error_pattern ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<ErrorEntry>(r.rows)));\n    return this.runReport(`${orgId}:errors:${from}:${to}:${limit}`, multi, exec);\n  }\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   */\n  async getDoraMetrics(\n    orgId: string,\n    from: string,\n    to: string,\n    orgIds?: string[],\n    opts: DoraOptions = {},\n  ): Promise<DoraMetrics> {\n    const { pred, multi } = this.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 this.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 this.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   */\n  private 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   */\n  async 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 } = this.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 this.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   */\n  async getBuildHealth(\n    orgId: string,\n    pipelineId: string,\n    from: string,\n    to: string,\n    orgIds?: string[],\n  ): Promise<BuildHealth> {\n    const { pred, multi } = this.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 this.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  async getPluginSummary(orgId: string): Promise<PluginSummary> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-summary`, async () => {\n      const rows = await withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE ${schema.plugin.isActive})::int AS active,\n          COUNT(*) FILTER (WHERE NOT ${schema.plugin.isActive})::int AS inactive,\n          COUNT(*) FILTER (WHERE ${schema.plugin.visibility} = 'public')::int AS public,\n          COUNT(*) FILTER (WHERE ${schema.plugin.visibility} = 'org')::int AS org,\n          COUNT(*) FILTER (WHERE ${schema.plugin.visibility} = 'private')::int AS private,\n          COUNT(DISTINCT ${schema.plugin.name})::int AS unique_names\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId}\n      `));\n      return (drizzleRows<PluginSummary>(rows.rows)[0] || { total: 0, active: 0, inactive: 0, public: 0, org: 0, private: 0, uniqueNames: 0 });\n    });\n  }\n\n  /** 2.2 Type & compute distribution.\n   *  INTENTIONALLY SINGLE-ORG (no rollup): plugin inventory is per-org (see\n   *  getPluginSummary). Single `= $org` scope. */\n  async getPluginDistribution(orgId: string): Promise<TypeComputeDistribution[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-distribution`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          ${schema.plugin.pluginType} AS plugin_type,\n          ${schema.plugin.computeType} AS compute_type,\n          COUNT(*)::int AS count\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.pluginType}, ${schema.plugin.computeType}\n        ORDER BY count DESC\n      `).then(r => drizzleRows<TypeComputeDistribution>(r.rows))),\n    );\n  }\n\n  /** 2.3 Version counts per plugin name.\n   *  INTENTIONALLY SINGLE-ORG (no rollup): plugin inventory is per-org (see\n   *  getPluginSummary). Single `= $org` scope. */\n  async getPluginVersions(orgId: string): Promise<VersionCount[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-versions`, () =>\n      withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          ${schema.plugin.name},\n          COUNT(*)::int AS version_count,\n          -- Highest version by NUMERIC semver core (not lexical: '10.0.0' > '9.0.0').\n          -- Strip any -prerelease/+build suffix before the int[] cast so it can't\n          -- error on valid semver; keep the original string for display.\n          -- GUARD: a non-numeric-dotted version ('latest', '', 'v1') would make the\n          -- ::int[] cast throw and blow up the WHOLE org summary. Only cast rows\n          -- whose stripped core matches a numeric-dotted shape; sort everything\n          -- else to the bottom via a sentinel ARRAY[-1] so the row still counts.\n          (array_agg(${schema.plugin.version}\n             ORDER BY CASE\n               WHEN regexp_replace(${schema.plugin.version}, '[-+].*$', '') ~ '^[0-9]+([.][0-9]+)*$'\n                 THEN string_to_array(regexp_replace(${schema.plugin.version}, '[-+].*$', ''), '.')::int[]\n               ELSE ARRAY[-1]\n             END DESC\n          ))[1] AS latest_version,\n          bool_or(${schema.plugin.isDefault}) AS has_default\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.name}\n        ORDER BY version_count DESC\n      `).then(r => drizzleRows<VersionCount>(r.rows))),\n    );\n  }\n\n  /**\n   * 2.4 Build success rate over time.\n   *\n   * STATUS CASING NOTE: This query filters by `event_source = 'plugin-build'`\n   * and uses lowercase status values (`'completed'`, `'failed'`), while\n   * `getSuccessRate` (1.2) filters by `event_type = 'PIPELINE'` with\n   * uppercase AWS-style statuses (`'SUCCEEDED'`, `'FAILED'`, `'CANCELED'`).\n   * The casing drift is intentional and tracks the producer:\n   *   - `plugin-build` events come from our own build pipeline (lowercase)\n   *   - `PIPELINE` events come from AWS CodePipeline (uppercase)\n   * The ingest Zod schema at api/reporting/src/routes/event-ingest.ts\n   * SHOULD enum these per-eventSource so we catch drift at ingest rather\n   * than silently producing zero rows here. See findings N71.\n   */\n  async getBuildSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[]): Promise<BuildTimeSeriesEntry[]> {\n    assertReportInterval(interval);\n    // Build activity report — rollup-aware like the execution reports. These\n    // rows are gated on the pipeline_event `org_id` directly (no pipeline join),\n    // so `pred` applies to `e.org_id`.\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'completed')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'failed')::int AS failed,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'completed')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id ${pred} AND e.event_source = 'plugin-build'\n          AND e.status IN ('completed', 'failed')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => drizzleRows<BuildTimeSeriesEntry>(r.rows)));\n    return this.runReport(`${orgId}:build-success:${interval}:${from}:${to}`, multi, exec);\n  }\n\n  /** 2.5 Build duration per plugin. Build activity report — rollup-aware. */\n  async getBuildDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<BuildDuration[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          COUNT(*)::int AS builds\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id ${pred} AND e.event_source = 'plugin-build' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name ORDER BY avg_ms DESC\n      `).then(r => drizzleRows<BuildDuration>(r.rows)));\n    return this.runReport(`${orgId}:build-duration:${from}:${to}`, multi, exec);\n  }\n\n  /** 2.6 Build failures — top error messages. Build activity report — rollup-aware. */\n  async getBuildFailures(orgId: string, from: string, to: string, limit: number = 20, orgIds?: string[]): Promise<BuildFailure[]> {\n    const { pred, multi } = this.orgScope(orgId, orgIds);\n    const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          e.error_message,\n          COUNT(*)::int AS occurrences,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id ${pred} AND e.event_source = 'plugin-build' AND e.status = 'failed'\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name, e.error_message\n        ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => drizzleRows<BuildFailure>(r.rows)));\n    return this.runReport(`${orgId}:build-failures:${from}:${to}:${limit}`, multi, exec);\n  }\n\n  // ── Category 3: DORA write paths (post-deploy outcomes + ingest health) ──\n\n  /**\n   * Record a manual post-deploy outcome marker (Phase 2): a user marks a\n   * deployment `failed` (a production incident linked to the deploy) or\n   * `restored` (recovered). Idempotent — keyed on (execution_id, outcome) so a\n   * duplicate POST refreshes `at` rather than double-counting, while a\n   * failed→restored pair stays two rows. Feeds the post-deploy CFR component and\n   * the real MTTR. Runs under the caller's org context (RLS WITH CHECK).\n   */\n  async recordDeploymentOutcome(\n    orgId: string,\n    executionId: string,\n    input: { outcome: 'failed' | 'restored'; at: string; environment?: string },\n  ): Promise<void> {\n    await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.insert(schema.deploymentOutcome).values({\n        executionId,\n        orgId,\n        environment: scrubOptional(input.environment),\n        outcome: input.outcome,\n        at: new Date(input.at),\n      }).onConflictDoUpdate({\n        target: [schema.deploymentOutcome.executionId, schema.deploymentOutcome.outcome],\n        set: {\n          at: new Date(input.at),\n          environment: scrubOptional(input.environment) ?? null,\n        },\n      })),\n    );\n    // Outcome changes the DORA aggregate — drop the org's cached reports.\n    await this.invalidateOrg(orgId).catch((err) => {\n      logger.warn('Reporting cache invalidation failed', { orgId, error: errorMessage(err) });\n    });\n  }\n\n  /**\n   * Ingest a production incident (Phase 5) from the org's incident tooling\n   * (PagerDuty / Datadog / Alertmanager webhook). Idempotent — keyed on\n   * (org_id, incident_id) so a later resolve re-post upserts `resolved_at`\n   * (and refreshes the other mutable fields) instead of inserting a duplicate.\n   * DORA correlates each incident to the most recent successful deploy to its\n   * `environment`, producing an automated post-deploy failure + a real MTTR.\n   * Runs under the caller's org context (RLS WITH CHECK); free-form fields are\n   * AWS-id scrubbed at this persistence boundary like the other ingest paths.\n   */\n  async recordIncident(orgId: string, input: IncidentInput): Promise<void> {\n    const incidentId = scrubAwsIdentifiersFromString(input.incidentId);\n    const environment = scrubAwsIdentifiersFromString(input.environment);\n    const severity = scrubAwsIdentifiersFromString(input.severity);\n    const openedAt = new Date(input.openedAt);\n    const resolvedAt = input.resolvedAt ? new Date(input.resolvedAt) : null;\n    await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.insert(schema.incident).values({\n        incidentId,\n        orgId,\n        environment,\n        openedAt,\n        resolvedAt,\n        severity,\n      }).onConflictDoUpdate({\n        target: [schema.incident.orgId, schema.incident.incidentId],\n        set: { environment, openedAt, resolvedAt, severity },\n      })),\n    );\n    // A new/updated incident changes the DORA aggregate — drop cached reports.\n    await this.invalidateOrg(orgId).catch((err) => {\n      logger.warn('Reporting cache invalidation failed', { orgId, error: errorMessage(err) });\n    });\n  }\n\n  /**\n   * Read the per-org DORA settings (Phase 5b). Returns the stored\n   * `incidentWindowHours` override (or `null` when unset) plus the global env\n   * default, so the settings UI can show both. Runs under the caller's tenant\n   * context (RLS-scoped); a single-org read.\n   */\n  async getIncidentSettings(orgId: string): Promise<IncidentSettings> {\n    const rows = drizzleRows<{\n      incident_window_hours: number | null;\n      event_retention_days: number | null;\n      dora_retention_days: number | null;\n    }>((await withTenantTx((tx) => tx.execute(sql`\n        SELECT ${schema.doraSettings.incidentWindowHours} AS incident_window_hours,\n               ${schema.doraSettings.eventRetentionDays} AS event_retention_days,\n               ${schema.doraSettings.doraRetentionDays} AS dora_retention_days\n        FROM ${schema.doraSettings}\n        WHERE ${schema.doraSettings.orgId} = ${orgId}\n        LIMIT 1\n      `))).rows);\n    const row = rows[0];\n    return {\n      incidentWindowHours: row?.incident_window_hours != null ? Number(row.incident_window_hours) : null,\n      defaultWindowHours: DORA_INCIDENT_WINDOW_HOURS,\n      eventRetentionDays: row?.event_retention_days != null ? Number(row.event_retention_days) : null,\n      doraRetentionDays: row?.dora_retention_days != null ? Number(row.dora_retention_days) : null,\n      defaultEventRetentionDays: REPORTING_EVENT_RETENTION_DAYS,\n      defaultDoraRetentionDays: REPORTING_DORA_RETENTION_DAYS,\n    };\n  }\n\n  /**\n   * Upsert per-org reporting settings (Phase 5b incident window + Phase 7\n   * retention overrides), idempotent on `org_id`. A partial write — only the\n   * fields present in `patch` are set (so updating retention never clears the\n   * incident window, and vice-versa). Set self-serve by an org admin via\n   * `PUT /api/reports/settings/incidents`. Runs under the caller's org context\n   * (RLS WITH CHECK); a changed value affects DORA aggregates so the org's\n   * cached reports are dropped.\n   */\n  async setReportingSettings(orgId: string, patch: ReportingSettingsPatch): Promise<void> {\n    const set: Record<string, unknown> = { updatedAt: new Date() };\n    if (patch.incidentWindowHours !== undefined) set.incidentWindowHours = patch.incidentWindowHours;\n    if (patch.eventRetentionDays !== undefined) set.eventRetentionDays = patch.eventRetentionDays;\n    if (patch.doraRetentionDays !== undefined) set.doraRetentionDays = patch.doraRetentionDays;\n    await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.insert(schema.doraSettings).values({\n        orgId,\n        incidentWindowHours: patch.incidentWindowHours,\n        eventRetentionDays: patch.eventRetentionDays,\n        doraRetentionDays: patch.doraRetentionDays,\n        updatedAt: new Date(),\n      }).onConflictDoUpdate({\n        target: schema.doraSettings.orgId,\n        set,\n      })),\n    );\n    await this.invalidateOrg(orgId).catch((err) => {\n      logger.warn('Reporting cache invalidation failed', { orgId, error: errorMessage(err) });\n    });\n  }\n\n  /**\n   * List recent incidents for an org (Phase 5b org-admin surface), newest first,\n   * paginated. Each row carries its resolved state and its deploy correlation —\n   * the most recent SUCCESSFUL deploy to the incident's `environment` whose\n   * `completed_at` falls within the effective per-org correlation window before\n   * `opened_at` (the same rule DORA's CFR/MTTR correlation applies). Single-org\n   * (no rollup) — an org admin views their own org's incidents. RLS-scoped via\n   * the `p.org_id`/`i.org_id` predicates + the tenant context.\n   */\n  async listIncidents(orgId: string, opts: { limit: number; offset: number }): Promise<IncidentListItem[]> {\n    const { incidentWindowHours } = await this.getIncidentSettings(orgId);\n    const windowHours = resolveIncidentWindowHours(incidentWindowHours);\n    const limit = Math.max(1, Math.min(opts.limit, 200));\n    const offset = Math.max(0, opts.offset);\n    return withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          i.incident_id AS \"incidentId\",\n          i.environment AS environment,\n          i.severity AS severity,\n          i.opened_at::text AS \"openedAt\",\n          i.resolved_at::text AS \"resolvedAt\",\n          i.created_at::text AS \"createdAt\",\n          (i.resolved_at IS NOT NULL) AS resolved,\n          corr.execution_id AS \"correlatedExecutionId\",\n          corr.completed_at::text AS \"deployCompletedAt\"\n        FROM ${schema.incident} i\n        LEFT JOIN LATERAL (\n          SELECT e.execution_id, e.completed_at\n          FROM ${schema.pipelineEvent} e\n          JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n          WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE'\n            AND e.environment = i.environment AND e.status = 'SUCCEEDED'\n            AND e.completed_at <= i.opened_at\n            AND e.completed_at >= i.opened_at - make_interval(hours => ${windowHours}::int)\n          ORDER BY e.completed_at DESC\n          LIMIT 1\n        ) corr ON true\n        WHERE i.org_id = ${orgId}\n        ORDER BY i.opened_at DESC\n        LIMIT ${limit} OFFSET ${offset}\n      `).then((r) => drizzleRows<IncidentListItem>(r.rows).map((row) => ({\n      ...row,\n      resolved: row.resolved === true || (row.resolved as unknown) === 't',\n      correlatedExecutionId: row.correlatedExecutionId ?? null,\n      deployCompletedAt: row.deployCompletedAt ?? null,\n    }))));\n  }\n\n  /**\n   * Wiring-test dry-run (Phase 5b): would a synthetic incident opening NOW for\n   * `environment` correlate to a recent successful deploy under the org's\n   * effective window? This is a NON-persisting correlation check — it verifies\n   * the admin's environment naming + window line up with real deploy events\n   * WITHOUT writing an incident (so a \"test\" never pollutes CFR/MTTR). RLS-scoped.\n   */\n  async testIncidentCorrelation(orgId: string, environment: string): Promise<IncidentTestResult> {\n    const env = scrubAwsIdentifiersFromString(environment);\n    const openedAt = new Date().toISOString();\n    const { incidentWindowHours } = await this.getIncidentSettings(orgId);\n    const windowHours = resolveIncidentWindowHours(incidentWindowHours);\n    const rows = drizzleRows<{ execution_id: string | null; completed_at: string | null }>((await withTenantTx((tx) => tx.execute(sql`\n        SELECT e.execution_id AS execution_id, e.completed_at::text AS completed_at\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE'\n          AND e.environment = ${env} AND e.status = 'SUCCEEDED'\n          AND e.completed_at <= ${openedAt}::timestamptz\n          AND e.completed_at >= ${openedAt}::timestamptz - make_interval(hours => ${windowHours}::int)\n        ORDER BY e.completed_at DESC\n        LIMIT 1\n      `))).rows);\n    const hit = rows[0];\n    return {\n      environment: env,\n      openedAt,\n      windowHours,\n      correlated: hit?.execution_id != null,\n      executionId: hit?.execution_id ?? null,\n      deployCompletedAt: hit?.completed_at ?? null,\n    };\n  }\n\n  /**\n   * Upsert per-org ingestion health (Phase 3): the AWS events Lambda periodically\n   * reports forwarded/dropped counters + the last event timestamp so the Reports\n   * UI can show flowing / stale / dropping. One row per org (upsert on org_id).\n   */\n  async recordIngestHealth(\n    orgId: string,\n    input: { forwarded?: number; dropped?: number; lastEventAt?: string },\n  ): Promise<void> {\n    const lastEventAt = input.lastEventAt ? new Date(input.lastEventAt) : undefined;\n    await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.insert(schema.ingestHealth).values({\n        orgId,\n        forwarded: input.forwarded,\n        dropped: input.dropped,\n        lastEventAt,\n        updatedAt: new Date(),\n      }).onConflictDoUpdate({\n        target: schema.ingestHealth.orgId,\n        set: {\n          forwarded: input.forwarded,\n          dropped: input.dropped,\n          lastEventAt,\n          updatedAt: new Date(),\n        },\n      })),\n    );\n  }\n\n  /**\n   * Batched hard-DELETE of one reporting table's rows expired past a `created_at`\n   * cutoff, scoped to an org and an optional row predicate (Phase 7). Uses a\n   * `ctid`-in-subquery LIMIT so each statement touches at most `batchSize` rows\n   * (short lock windows, no long table scan under lock); `RETURNING 1` lets us\n   * count via `.rows.length` without depending on the driver's `rowCount`. Loops\n   * until a short batch (drained) or the per-tick cap, then defers the rest.\n   * MUST run inside a sysadmin tenant scope (see purgeExpiredReportingData) so it\n   * bypasses RLS and can delete across the org's rows.\n   */\n  async #purgeReportingTableBatched(\n    tableSql: ReturnType<typeof sql>,\n    predicate: ReturnType<typeof sql>,\n    batchSize: number,\n    maxBatches: number,\n  ): Promise<number> {\n    let total = 0;\n    for (let i = 0; i < maxBatches; i++) {\n      const res = await withTenantTx((tx) => tx.execute(sql`\n        DELETE FROM ${tableSql}\n        WHERE ctid IN (\n          SELECT ctid FROM ${tableSql}\n          WHERE ${predicate}\n          LIMIT ${batchSize}\n        )\n        RETURNING 1\n      `));\n      const purged = drizzleRows<unknown>(res.rows).length;\n      total += purged;\n      if (purged < batchSize) break; // drained\n      if (i === maxBatches - 1) {\n        logger.warn('Reporting retention hit per-tick cap; remaining rows deferred', {\n          purgedThisTick: total,\n        });\n      }\n    }\n    return total;\n  }\n\n  /**\n   * Reporting retention sweep (Phase 7). Hard-deletes rows older than their\n   * retention window, by `created_at`, across every org that has reporting data —\n   * a **split** policy so high-volume standard events expire faster than the\n   * low-volume DORA source:\n   *  - `pipeline_events WHERE environment IS NULL` → standard-event window.\n   *  - `pipeline_events WHERE environment IS NOT NULL` (deploy stages),\n   *    `deployment_outcomes`, and `incidents` → DORA-source window.\n   * Each org's windows come from its `dora_settings` override, else the global\n   * env defaults (see {@link resolveEventRetentionDays} / {@link resolveDoraRetentionDays}).\n   * `ingest_health` and `dora_settings` are never purged. One `now` for the whole\n   * tick (rows crossing the boundary mid-sweep wait for the next). Establishes a\n   * sysadmin tenant scope so the deletes span all orgs / bypass RLS — this is a\n   * cross-tenant housekeeping job. Returns (and logs) per-window purge tallies.\n   */\n  async purgeExpiredReportingData(opts: ReportingRetentionOptions = {}): Promise<ReportingRetentionCounts> {\n    const batchSize = Math.max(1, opts.batchSize ?? 1000);\n    const maxBatches = Math.max(1, opts.maxBatchesPerTable ?? 50);\n    const now = opts.now ?? new Date();\n    const counts: ReportingRetentionCounts = {\n      orgs: 0, standardEvents: 0, doraEvents: 0, deploymentOutcomes: 0, incidents: 0,\n    };\n\n    return runWithTenantContext({ isSuperAdmin: true }, async () => {\n      // Enumerate every org with reporting data (union across the three tables).\n      const orgRows = drizzleRows<{ org_id: string }>((await withTenantTx((tx) => tx.execute(sql`\n        SELECT DISTINCT org_id FROM (\n          SELECT ${schema.pipelineEvent.orgId} AS org_id FROM ${schema.pipelineEvent}\n          UNION\n          SELECT ${schema.deploymentOutcome.orgId} AS org_id FROM ${schema.deploymentOutcome}\n          UNION\n          SELECT ${schema.incident.orgId} AS org_id FROM ${schema.incident}\n        ) AS orgs\n      `))).rows);\n      if (orgRows.length === 0) return counts;\n\n      // Per-org retention overrides (a single read; orgs without a row use defaults).\n      const overrideRows = drizzleRows<{\n        org_id: string;\n        event_retention_days: number | null;\n        dora_retention_days: number | null;\n      }>((await withTenantTx((tx) => tx.execute(sql`\n        SELECT ${schema.doraSettings.orgId} AS org_id,\n               ${schema.doraSettings.eventRetentionDays} AS event_retention_days,\n               ${schema.doraSettings.doraRetentionDays} AS dora_retention_days\n        FROM ${schema.doraSettings}\n      `))).rows);\n      const overrides = new Map(overrideRows.map((r) => [r.org_id, r]));\n\n      const eventsTable = sql`${schema.pipelineEvent}`;\n      const outcomesTable = sql`${schema.deploymentOutcome}`;\n      const incidentsTable = sql`${schema.incident}`;\n\n      for (const { org_id: orgId } of orgRows) {\n        const ov = overrides.get(orgId);\n        const eventDays = resolveEventRetentionDays(ov?.event_retention_days);\n        const doraDays = resolveDoraRetentionDays(ov?.dora_retention_days);\n        // `-1` = unlimited (Phase 8): keep forever, skip that window's deletes for\n        // this org. Standard-event and DORA-source windows are independent; an org\n        // with both `-1` is fully skipped. Log the skip so it's observable.\n        const skipEvents = eventDays === -1;\n        const skipDora = doraDays === -1;\n        if (skipEvents || skipDora) {\n          logger.info('Reporting retention sweep skipping unlimited window(s)', {\n            orgId,\n            standardEvents: skipEvents ? 'unlimited' : eventDays,\n            doraSource: skipDora ? 'unlimited' : doraDays,\n          });\n        }\n\n        if (!skipEvents) {\n          const eventCutoff = retentionCutoff(now, eventDays);\n          counts.standardEvents += await this.#purgeReportingTableBatched(\n            eventsTable,\n            sql`org_id = ${orgId} AND environment IS NULL AND created_at < ${eventCutoff}`,\n            batchSize, maxBatches,\n          );\n        }\n\n        if (!skipDora) {\n          const doraCutoff = retentionCutoff(now, doraDays);\n          counts.doraEvents += await this.#purgeReportingTableBatched(\n            eventsTable,\n            sql`org_id = ${orgId} AND environment IS NOT NULL AND created_at < ${doraCutoff}`,\n            batchSize, maxBatches,\n          );\n          counts.deploymentOutcomes += await this.#purgeReportingTableBatched(\n            outcomesTable,\n            sql`org_id = ${orgId} AND created_at < ${doraCutoff}`,\n            batchSize, maxBatches,\n          );\n          counts.incidents += await this.#purgeReportingTableBatched(\n            incidentsTable,\n            sql`org_id = ${orgId} AND created_at < ${doraCutoff}`,\n            batchSize, maxBatches,\n          );\n        }\n        counts.orgs += 1;\n      }\n\n      const purgedAny = counts.standardEvents + counts.doraEvents + counts.deploymentOutcomes + counts.incidents;\n      if (purgedAny > 0) logger.info('Reporting retention sweep purged expired rows', { ...counts });\n      return counts;\n    });\n  }\n}\n\nexport const reportingService = new ReportingService();\n"]}