@pipeline-builder/pipeline-data 4.1.24 → 4.1.25

package/lib/api/reporting-service.js

@@ -7,16 +7,19 @@ import { schema } from '../database/drizzle-schema.js';
 import { withTenantTx, runWithTenantContext } from '../database/tenancy.js';
 // Extracted for size — see ./reporting/. Everything public is re-exported below
 // so `@pipeline-builder/pipeline-data`'s surface is unchanged by the split.
+import { getAdoption, getFailureAnalysis, getOutdatedPlugins, getPipelineBreakdown, getPipelineConfigChanges, getPipelineStreaks, getPluginVulnerabilities, getPromotionView, getResourceConsumption, getStagePerformance, getUntrackedPipelines, getVulnerablePipelines, } from './reporting/analytics-queries.js';
 import { inventoryCache, invalidateOrgReports } from './reporting/caches.js';
 import { DORA_INCIDENT_WINDOW_HOURS, resolveIncidentWindowHours } from './reporting/dora-scoring.js';
 import { getDoraMetrics as doraMetrics, getDoraTrend as doraTrend, getBuildHealth as buildHealth, } from './reporting/dora.js';
 // Aliased: the module functions and the delegating methods below share names.
 import { ingestEvents as ingest } from './reporting/ingest.js';
+import { getLastDeployedCommit as lastDeployedCommit } from './reporting/last-deploy.js';
+import { evaluateNeedsAttention, thresholdsFrom } from './reporting/needs-attention.js';
 import { getPluginRuntime as pluginRuntime, getPluginRuntimeAggregate as pluginRuntimeAggregate, hasVerifiedPluginUse as verifiedPluginUse, } from './reporting/plugin-runtime.js';
 import { report } from './reporting/query-scope.js';
 import { purgeExpiredReportingData as purgeReportingRetention } from './reporting/retention-sweep.js';
 import { REPORTING_EVENT_RETENTION_DAYS, REPORTING_DORA_RETENTION_DAYS } from './reporting/retention.js';
-import { assertReportInterval, scrubOptional, optionalStartedAtRange, startedAtWindow } from './reporting/sql-helpers.js';
+import { assertReportInterval, bucketKey, periodBucket, scrubOptional, optionalStartedAtRange, startedAtWindow } from './reporting/sql-helpers.js';
 const logger = createLogger('reporting-service');
 export class ReportingService {
     /** Invalidate all cached reports for an org (call after event ingest). */
@@ -29,8 +32,17 @@ export class ReportingService {
      * See ./reporting/ingest.ts — the caller must already hold a sysadmin
      * tenant scope, because a batch spans whatever orgs the registry resolves to.
      */
-    async ingestEvents(events, onMetric) {
-        return ingest(events, onMetric);
+    async ingestEvents(events, onMetric, caller) {
+        return ingest(events, onMetric, caller);
+    }
+    /**
+     * The commit sha of this pipeline's last successful deploy — to `environment`
+     * when given, to anywhere otherwise. The exclusive lower bound for "commits
+     * since the last deploy". Tenancy is enforced from `caller` exactly as
+     * {@link ingestEvents} does it.
+     */
+    async getLastDeployedCommit(pipelineId, environment, caller) {
+        return lastDeployedCommit(pipelineId, environment, caller);
     }
     // ── Category 1: Pipeline Execution & Performance ──
     /** Execution count per pipeline with status breakdown. */
@@ -102,11 +114,14 @@ export class ReportingService {
       `);
     }
     /** Success rate over time for an org. */
-    async getSuccessRate(orgId, interval, from, to, orgIds) {
+    async getSuccessRate(orgId, interval, from, to, orgIds, bucket = {}) {
         assertReportInterval(interval);
-        return report(`success-rate:${interval}:${from}:${to}`, orgId, orgIds, (pred) => sql `
+        const { tz = 'UTC', weekStart = 'monday' } = bucket;
+        // The bucketing settings are part of the cache KEY: without them a Chicago
+        // request and a UTC request share an entry and one of them gets the other's weeks.
+        return report(`success-rate:${interval}:${from}:${to}:${bucketKey(tz, weekStart)}`, orgId, orgIds, (pred) => sql `
         SELECT
-          DATE_TRUNC(${interval}, e.started_at)::text AS period,
+          ${periodBucket(interval, sql `e.started_at`, tz, weekStart)}::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,
@@ -310,14 +325,15 @@ export class ReportingService {
      * 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) {
+    async getBuildSuccessRate(orgId, interval, from, to, orgIds, bucket = {}) {
         assertReportInterval(interval);
+        const { tz = 'UTC', weekStart = 'monday' } = bucket;
         // 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`.
-        return report(`build-success:${interval}:${from}:${to}`, orgId, orgIds, (pred) => sql `
+        return report(`build-success:${interval}:${from}:${to}:${bucketKey(tz, weekStart)}`, orgId, orgIds, (pred) => sql `
         SELECT
-          DATE_TRUNC(${interval}, e.started_at)::text AS period,
+          ${periodBucket(interval, sql `e.started_at`, tz, weekStart)}::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
@@ -663,6 +679,149 @@ export class ReportingService {
     async purgeExpiredReportingData(opts = {}) {
         return purgeReportingRetention(opts);
     }
+    // ── Category 5: the ANALYTICS reads ──────────────────────────────────────
+    //
+    // Thin delegations to ./reporting/analytics-queries.ts, so `reportingService`
+    // satisfies the report engine's `SectionDataSource` in full and a section never
+    // reaches past the service for its data. Every one of these reads a
+    // pre-aggregated table (`execution_daily_rollups`, `dora_deployments`,
+    // `pipeline_plugin_resolution`, `plugin_vuln_exposure`) rather than raw events —
+    // which is what makes a quarterly report affordable AND what makes it still
+    // answerable after retention has swept the events it came from.
+    /** Per-pipeline delivery, worst first. */
+    async getPipelineBreakdown(scope, limit = 10) {
+        return getPipelineBreakdown(scope, limit);
+    }
+    /** Failures by category, with the previous period's counts for the trend. */
+    async getFailureAnalysis(scope, previous) {
+        return getFailureAnalysis(scope, previous);
+    }
+    /** Per-stage timings for one pipeline, slowest first. */
+    async getStagePerformance(scope, pipelineId, previous) {
+        return getStagePerformance(scope, pipelineId, previous);
+    }
+    /** Build time by project and pipeline. Seconds, never money. */
+    async getResourceConsumption(scope, limit = 20) {
+        return getResourceConsumption(scope, limit);
+    }
+    /** Each commit's path across environments, and which ones stopped short. */
+    async getPromotionView(scope, productionEnv = 'production', limit = 25) {
+        return getPromotionView(scope, productionEnv, limit);
+    }
+    /** Pipelines behind on a plugin, worst gap first (the DECLARED side). */
+    async getOutdatedPlugins(scope, limit = 50) {
+        return getOutdatedPlugins(scope, limit);
+    }
+    /** Open plugin vulnerabilities per pipeline (says declared vs deployed). */
+    async getPluginVulnerabilities(scope, limit = 50) {
+        return getPluginVulnerabilities(scope, limit);
+    }
+    /** Adoption, creation source, and the deploy-tracking coverage denominator. */
+    async getAdoption(scope, timeSavedMinutes) {
+        return getAdoption(scope, timeSavedMinutes ?? (await this.timeSavedAssumption(scope.orgId)));
+    }
+    /**
+     * The needs-attention findings for the period.
+     *
+     * Assembled HERE rather than in the section, because the rules need six reads that
+     * must all describe the same window: this period's breakdown, the previous one's,
+     * failure streaks, config-change times, pipelines with an open Critical, and
+     * pipelines DORA cannot see. A section that fetched them itself would be the only
+     * place in the report where the window could drift between panels.
+     *
+     * Every input except the current breakdown is OPTIONAL to the evaluator, and each
+     * one's failure is absorbed: a rule with no data to run on is skipped, which is
+     * why one unavailable read costs one finding rather than the whole section. The
+     * alternative — a section that fails because the streak query timed out — replaces
+     * six findings with none.
+     */
+    async getNeedsAttention(scope, previous) {
+        const current = await getPipelineBreakdown(scope, ATTENTION_PIPELINE_LIMIT);
+        const prior = previous
+            ? await soften(getPipelineBreakdown({ ...scope, ...previous }, ATTENTION_PIPELINE_LIMIT), [])
+            : [];
+        const [streakRows, configChanges, vulnerable, untracked, thresholds] = await Promise.all([
+            soften(getPipelineStreaks(scope), []),
+            soften(getPipelineConfigChanges(scope), new Map()),
+            soften(getVulnerablePipelines(scope), []),
+            soften(getUntrackedPipelines(scope), []),
+            soften(this.attentionThresholds(scope.orgId), {}),
+        ]);
+        const items = evaluateNeedsAttention({
+            current,
+            previous: prior,
+            streaks: new Map(streakRows.map((r) => [r.pipelineId, {
+                    consecutiveFailures: r.consecutiveFailures,
+                    lastSuccessAt: r.lastSuccessAt,
+                }])),
+            configChanges,
+            vulnerablePipelines: new Set(vulnerable),
+            untrackedPipelines: new Set(untracked),
+            thresholds: thresholdsFrom(thresholds),
+            now: new Date(scope.to),
+        });
+        return {
+            items,
+            thresholds: thresholdsFrom(thresholds),
+            // What the rules were evaluated over, so a reader can tell an empty list
+            // ("nothing tripped") from an empty input ("nothing ran").
+            pipelinesEvaluated: current.length,
+        };
+    }
+    /**
+     * The org's stored needs-attention thresholds, or `{}`.
+     *
+     * Returned as a partial on purpose: `thresholdsFrom` fills the rest per field, so
+     * an org that configured one number keeps the defaults for the others instead of
+     * silently disabling four rules by setting one.
+     */
+    async attentionThresholds(orgId) {
+        const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.select({ t: schema.doraSettings.reportAttentionThresholds })
+            .from(schema.doraSettings)
+            .where(eq(schema.doraSettings.orgId, orgId))
+            .limit(1)));
+        const stored = rows[0]?.t;
+        return stored && typeof stored === 'object' ? stored : {};
+    }
+    /**
+     * The org's own minutes-saved-per-pipeline assumption, or null.
+     *
+     * Read here so the adoption section cannot accidentally be handed a
+     * platform-chosen default: the number only means something when the customer
+     * picked it, and `null` renders as "not estimated" rather than as zero.
+     */
+    async timeSavedAssumption(orgId) {
+        const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.select({ minutes: schema.doraSettings.timeSavedMinutesPerPipeline })
+            .from(schema.doraSettings)
+            .where(eq(schema.doraSettings.orgId, orgId))
+            .limit(1)));
+        return rows[0]?.minutes ?? null;
+    }
+}
+/**
+ * How many pipelines the needs-attention rules consider.
+ *
+ * The section is a short list of things to do, not a table of everything, so the
+ * evaluator sees the same worst-first slice the breakdown section shows. A pipeline
+ * outside the worst 25 by the breakdown's own ordering is not the one a lead should
+ * be told about first.
+ */
+const ATTENTION_PIPELINE_LIMIT = 25;
+/**
+ * Run a read, or fall back.
+ *
+ * Only for the needs-attention inputs, where an absent input SKIPS a rule and the
+ * evaluator says so. Never used for a number the report presents: a query that fails
+ * and silently reads as zero is how a report states something false.
+ */
+async function soften(p, fallback) {
+    try {
+        return await p;
+    }
+    catch (err) {
+        logger.warn('Needs-attention input unavailable; its rule is skipped', { error: errorMessage(err) });
+        return fallback;
+    }
 }
 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 { createLogger, errorMessage, isoOrNull, scrubAwsIdentifiersFromString } from '@pipeline-builder/api-core';\nimport { eq, 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\n// Extracted for size — see ./reporting/. Everything public is re-exported below\n// so `@pipeline-builder/pipeline-data`'s surface is unchanged by the split.\nimport { inventoryCache, invalidateOrgReports } from './reporting/caches.js';\nimport { DORA_INCIDENT_WINDOW_HOURS, resolveIncidentWindowHours } from './reporting/dora-scoring.js';\nimport {\n  getDoraMetrics as doraMetrics,\n  getDoraTrend as doraTrend,\n  getBuildHealth as buildHealth,\n} from './reporting/dora.js';\n// Aliased: the module functions and the delegating methods below share names.\nimport { ingestEvents as ingest } from './reporting/ingest.js';\nimport {\n  getPluginRuntime as pluginRuntime,\n  getPluginRuntimeAggregate as pluginRuntimeAggregate,\n  hasVerifiedPluginUse as verifiedPluginUse,\n} from './reporting/plugin-runtime.js';\nimport { report } from './reporting/query-scope.js';\nimport { purgeExpiredReportingData as purgeReportingRetention } from './reporting/retention-sweep.js';\nimport { REPORTING_EVENT_RETENTION_DAYS, REPORTING_DORA_RETENTION_DAYS } from './reporting/retention.js';\nimport { assertReportInterval, scrubOptional, optionalStartedAtRange, startedAtWindow } from './reporting/sql-helpers.js';\nimport type {\n  ExecutionCount, TimeSeriesEntry, DurationStats, PipelineExecution, StageFailure, StageBottleneck,\n  ActionFailure, ErrorEntry, PluginSummary, TypeComputeDistribution, VersionCount,\n  BuildTimeSeriesEntry, BuildDuration, BuildFailure,\n  PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats,\n  ReportingRetentionOptions, ReportingRetentionCounts,\n  DoraOptions, ReportingSettings, ReportingSettingsPatch, IncidentListItem, IncidentTestResult,\n  DoraMetrics, DoraTrendPoint, BuildHealth, IncidentInput,\n  IngestEvent, IngestMetric, IngestResult, IngestHealthStatus,\n} from './reporting/types.js';\n\n// The reporting types that are part of the package API. Enumerated rather than\n// `export *` because the reporting modules also export internals (orgScope,\n// runReport, the caches, the DORA row shapes) that must stay private.\nexport type {\n  BuildHealth, BuildHealthStage, DoraEnvMetrics, DoraLevel, DoraMetrics, DoraOptions, DoraTrendPoint,\n  IncidentInput, IncidentListItem, ReportingSettings, IncidentTestResult,\n  IngestEvent, IngestHealthStatus, IngestMetric, IngestResult,\n  PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats,\n  ReportingRetentionCounts, ReportingRetentionOptions, ReportingRetentionSettings,\n  ReportingSettingsPatch,\n} from './reporting/types.js';\n\n\nconst logger = createLogger('reporting-service');\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 invalidateOrgReports(orgId);\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   * See ./reporting/ingest.ts — the caller must already hold a sysadmin\n   * tenant scope, because a batch spans whatever orgs the registry resolves to.\n   */\n  async ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void): Promise<IngestResult> {\n    return ingest(events, onMetric);\n  }\n\n  // ── Category 1: Pipeline Execution & Performance ──\n\n\n  /** Execution count per pipeline with status breakdown. */\n  async getExecutionCount(orgId: string, orgIds?: string[], range?: { from?: string; to?: string }): Promise<ExecutionCount[]> {\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    return report<ExecutionCount>(`exec-count:${range?.from ?? ''}:${range?.to ?? ''}`, orgId, orgIds, (pred) => 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      `);\n  }\n\n  /**\n   * 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 rangeClause = optionalStartedAtRange(range);\n    return report<PipelineExecution>(`pipeline-executions:${pipelineId}:${range?.from ?? ''}:${range?.to ?? ''}:${limit}`, orgId, orgIds, (pred) => 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      `);\n  }\n\n  /** 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    return report<TimeSeriesEntry>(`success-rate:${interval}:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY period ORDER BY period\n      `);\n  }\n\n  /** Average duration per pipeline. */\n  async getAverageDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<DurationStats[]> {\n    return report<DurationStats>(`avg-duration:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY p.id ORDER BY avg_ms DESC\n      `);\n  }\n\n  /** Stage failure heatmap — which stages fail most. */\n  async getStageFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageFailure[]> {\n    return report<StageFailure>(`stage-failures:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY e.stage_name ORDER BY failures DESC\n      `);\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 rows = await report<{ environment: string }>(`report-envs:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        ORDER BY environment\n      `);\n    return rows.map((row) => row.environment);\n  }\n\n  /** Stage bottlenecks — slowest stages per pipeline. */\n  async getStageBottlenecks(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageBottleneck[]> {\n    return report<StageBottleneck>(`stage-bottlenecks:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC\n      `);\n  }\n\n  /** Action failure rate — which plugin steps fail most. */\n  async getActionFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<ActionFailure[]> {\n    return report<ActionFailure>(`action-failures:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY e.action_name ORDER BY failures DESC\n      `);\n  }\n\n  /**\n   * 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    return report<ErrorEntry>(`errors:${from}:${to}:${limit}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY error_pattern ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `);\n  }\n\n  /**\n   * The four DORA measures plus their per-environment breakdown.\n   * Implementation in ./reporting/dora.ts — see that file's header for why.\n   */\n  getDoraMetrics(\n    orgId: string, from: string, to: string, orgIds?: string[], opts: DoraOptions = {},\n  ): Promise<DoraMetrics> {\n    return doraMetrics(orgId, from, to, orgIds, opts);\n  }\n\n  /** DORA measures bucketed over time. */\n  getDoraTrend(\n    orgId: string, interval: string, from: string, to: string, orgIds?: string[], opts: DoraOptions = {},\n  ): Promise<DoraTrendPoint[]> {\n    return doraTrend(orgId, interval, from, to, orgIds, opts);\n  }\n\n  /** Per-pipeline build health (stage pass rates over a window). */\n  getBuildHealth(\n    orgId: string, pipelineId: string, from: string, to: string, orgIds?: string[],\n  ): Promise<BuildHealth> {\n    return buildHealth(orgId, pipelineId, from, to, orgIds);\n  }\n\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  /** 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  /** 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   * 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    return report<BuildTimeSeriesEntry>(`build-success:${interval}:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY period ORDER BY period\n      `);\n  }\n\n  /** Build duration per plugin. Build activity report — rollup-aware. */\n  async getBuildDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<BuildDuration[]> {\n    return report<BuildDuration>(`build-duration:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY plugin_name ORDER BY avg_ms DESC\n      `);\n  }\n\n  /** 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    return report<BuildFailure>(`build-failures:${from}:${to}:${limit}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY plugin_name, e.error_message\n        ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `);\n  }\n\n  // ── Plugin runtime telemetry — see ./reporting/plugin-runtime.ts ──\n\n  /**\n   * Plugin runtime: per plugin version runs, success rate and p50/p95\n   * duration over `[from, to]`, from the manifest-attributed ACTION events.\n   * Rollup-aware.\n   */\n  async getPluginRuntime(orgId: string, from: string, to: string, filter?: PluginRuntimeFilter, orgIds?: string[]): Promise<PluginRuntimeStats[]> {\n    return pluginRuntime(orgId, from, to, filter, orgIds);\n  }\n\n  /** Cross-org 30-day runtime aggregate for a `(publisher, name)` listing (plugin_stats input). Service callers only. */\n  async getPluginRuntimeAggregate(publisher: string, name: string): Promise<PluginRuntimeAggregate> {\n    return pluginRuntimeAggregate(publisher, name);\n  }\n\n  /** Review \"verified use\": `orgId` ran `(publisher, name)` successfully within 90 days. Service callers only. */\n  async hasVerifiedPluginUse(orgId: string, publisher: string, name: string): Promise<boolean> {\n    return verifiedPluginUse(orgId, publisher, name);\n  }\n\n  // ── Category 3: DORA write paths (post-deploy outcomes + ingest health) ──\n\n  /**\n   * Record a manual post-deploy outcome marker: 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 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        // A redelivered FIRING post (no resolvedAt) must not wipe a recorded\n        // resolve — senders re-post firing alerts on every repeat interval, and\n        // delivery order isn't guaranteed. Keep the stored resolve unless the\n        // post carries its own, or the incident was RE-OPENED (a different\n        // openedAt means a new occurrence, whose resolve state is the post's).\n        set: {\n          environment,\n          openedAt,\n          resolvedAt: sql`CASE WHEN ${schema.incident.openedAt} = excluded.opened_at\n            THEN COALESCE(excluded.resolved_at, ${schema.incident.resolvedAt})\n            ELSE excluded.resolved_at END`,\n          severity,\n        },\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. 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 getReportingSettings(orgId: string, retentionOrgId: string = orgId): Promise<ReportingSettings> {\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    // Retention is a billing entitlement synced onto the account ROOT only; a\n    // team reads its root's window (the incident window stays the team's own).\n    const retention = retentionOrgId === orgId\n      ? row\n      : await this.#readRetentionOverride(retentionOrgId);\n    return {\n      incidentWindowHours: row?.incident_window_hours != null ? Number(row.incident_window_hours) : null,\n      defaultWindowHours: DORA_INCIDENT_WINDOW_HOURS,\n      eventRetentionDays: retention?.event_retention_days != null ? Number(retention.event_retention_days) : null,\n      doraRetentionDays: retention?.dora_retention_days != null ? Number(retention.dora_retention_days) : null,\n      defaultEventRetentionDays: REPORTING_EVENT_RETENTION_DAYS,\n      defaultDoraRetentionDays: REPORTING_DORA_RETENTION_DAYS,\n    };\n  }\n\n  /**\n   * The ROOT org's stored retention override. The caller (a team) can't see the\n   * root's `dora_settings` row under its own RLS scope, so this narrow read of\n   * two integer columns — keyed by the explicit, JWT-derived root id — runs in a\n   * sysadmin scope.\n   */\n  async #readRetentionOverride(orgId: string): Promise<{ event_retention_days: number | null; dora_retention_days: number | null } | undefined> {\n    const rows = await runWithTenantContext({ isSuperAdmin: true }, async () => drizzleRows<{\n      event_retention_days: number | null;\n      dora_retention_days: number | null;\n    }>((await withTenantTx((tx) => tx.execute(sql`\n        SELECT ${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    return rows[0];\n  }\n\n  /**\n   * Upsert per-org reporting settings (incident window +\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 (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.getReportingSettings(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    // The correlation window is expressed in SECONDS as a double, not as\n    // `make_interval(hours => N::int)`. The window is validated as any positive\n    // number (0.5h is legal) and the in-memory DORA correlation uses it exactly;\n    // the int cast made Postgres reject a fractional value, so a 0.5h window\n    // returned 500 from this endpoint and from the correlation lookup below.\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(secs => ${windowHours * 3600}::double precision)\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: 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.getReportingSettings(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(secs => ${windowHours * 3600}::double precision)\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: 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   * Read back one org's ingestion health for the Reports UI freshness\n   * indicator. Returns `null` when the org has NO row — i.e. the deployment has\n   * never ingested anything — which the UI must render as \"no ingest reported\n   * yet\", never as \"stale\". RLS-scoped to the org like every other read.\n   */\n  async getIngestHealth(orgId: string): Promise<IngestHealthStatus | null> {\n    const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx\n        .select()\n        .from(schema.ingestHealth)\n        .where(eq(schema.ingestHealth.orgId, orgId))\n        .limit(1)),\n    );\n    const row = rows[0];\n    if (!row) return null;\n    return {\n      updatedAt: row.updatedAt.toISOString(),\n      lastEventAt: isoOrNull(row.lastEventAt),\n      forwarded: row.forwarded ?? null,\n      dropped: row.dropped ?? null,\n    };\n  }\n\n  /**\n   * Reporting retention sweep: hard-deletes rows past their per-org retention\n   * window (split standard-event vs DORA-source). Cross-tenant housekeeping —\n   * it establishes its own sysadmin scope. See ./reporting/retention-sweep.ts.\n   */\n  async purgeExpiredReportingData(opts: ReportingRetentionOptions = {}): Promise<ReportingRetentionCounts> {\n    return purgeReportingRetention(opts);\n  }\n}\n\nexport const reportingService = new ReportingService();\n"]}
+//# 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 { createLogger, errorMessage, isoOrNull, scrubAwsIdentifiersFromString } from '@pipeline-builder/api-core';\nimport { eq, 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\n// Extracted for size — see ./reporting/. Everything public is re-exported below\n// so `@pipeline-builder/pipeline-data`'s surface is unchanged by the split.\nimport {\n  getAdoption,\n  getFailureAnalysis,\n  getOutdatedPlugins,\n  getPipelineBreakdown,\n  getPipelineConfigChanges,\n  getPipelineStreaks,\n  getPluginVulnerabilities,\n  getPromotionView,\n  getResourceConsumption,\n  getStagePerformance,\n  getUntrackedPipelines,\n  getVulnerablePipelines,\n  type AnalyticsScope,\n} from './reporting/analytics-queries.js';\nimport { inventoryCache, invalidateOrgReports } from './reporting/caches.js';\nimport { DORA_INCIDENT_WINDOW_HOURS, resolveIncidentWindowHours } from './reporting/dora-scoring.js';\nimport {\n  getDoraMetrics as doraMetrics,\n  getDoraTrend as doraTrend,\n  getBuildHealth as buildHealth,\n} from './reporting/dora.js';\n// Aliased: the module functions and the delegating methods below share names.\nimport { ingestEvents as ingest } from './reporting/ingest.js';\nimport { getLastDeployedCommit as lastDeployedCommit } from './reporting/last-deploy.js';\nimport type { LastDeployedCommit } from './reporting/last-deploy.js';\nimport { evaluateNeedsAttention, thresholdsFrom } from './reporting/needs-attention.js';\nimport {\n  getPluginRuntime as pluginRuntime,\n  getPluginRuntimeAggregate as pluginRuntimeAggregate,\n  hasVerifiedPluginUse as verifiedPluginUse,\n} from './reporting/plugin-runtime.js';\nimport { report } from './reporting/query-scope.js';\nimport { purgeExpiredReportingData as purgeReportingRetention } from './reporting/retention-sweep.js';\nimport { REPORTING_EVENT_RETENTION_DAYS, REPORTING_DORA_RETENTION_DAYS } from './reporting/retention.js';\nimport { assertReportInterval, bucketKey, periodBucket, scrubOptional, optionalStartedAtRange, startedAtWindow } from './reporting/sql-helpers.js';\nimport type {\n  ExecutionCount, TimeSeriesEntry, DurationStats, PipelineExecution, StageFailure, StageBottleneck,\n  ActionFailure, ErrorEntry, PluginSummary, TypeComputeDistribution, VersionCount,\n  BuildTimeSeriesEntry, BuildDuration, BuildFailure,\n  PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats,\n  ReportingRetentionOptions, ReportingRetentionCounts,\n  DoraOptions, ReportingSettings, ReportingSettingsPatch, IncidentListItem, IncidentTestResult,\n  DoraMetrics, DoraTrendPoint, BuildHealth, IncidentInput,\n  IngestCaller, IngestEvent, IngestMetric, IngestResult, IngestHealthStatus,\n  BucketOptions,\n} from './reporting/types.js';\n\n// The reporting types that are part of the package API. Enumerated rather than\n// `export *` because the reporting modules also export internals (orgScope,\n// runReport, the caches, the DORA row shapes) that must stay private.\nexport type { LastDeployedCommit } from './reporting/last-deploy.js';\nexport type {\n  BucketOptions,\n  BuildHealth, BuildHealthStage, DoraEnvMetrics, DoraLevel, DoraMetrics, DoraOptions, DoraTrendPoint,\n  IncidentInput, IncidentListItem, ReportingSettings, IncidentTestResult,\n  IngestCaller, IngestEvent, IngestHealthStatus, IngestMetric, IngestResult,\n  PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats,\n  ReportingRetentionCounts, ReportingRetentionOptions, ReportingRetentionSettings,\n  ReportingSettingsPatch,\n} from './reporting/types.js';\n\n\nconst logger = createLogger('reporting-service');\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 invalidateOrgReports(orgId);\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   * See ./reporting/ingest.ts — the caller must already hold a sysadmin\n   * tenant scope, because a batch spans whatever orgs the registry resolves to.\n   */\n  async ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void, caller?: IngestCaller): Promise<IngestResult> {\n    return ingest(events, onMetric, caller);\n  }\n\n  /**\n   * The commit sha of this pipeline's last successful deploy — to `environment`\n   * when given, to anywhere otherwise. The exclusive lower bound for \"commits\n   * since the last deploy\". Tenancy is enforced from `caller` exactly as\n   * {@link ingestEvents} does it.\n   */\n  async getLastDeployedCommit(pipelineId: string, environment?: string, caller?: IngestCaller): Promise<LastDeployedCommit> {\n    return lastDeployedCommit(pipelineId, environment, caller);\n  }\n\n  // ── Category 1: Pipeline Execution & Performance ──\n\n\n  /** Execution count per pipeline with status breakdown. */\n  async getExecutionCount(orgId: string, orgIds?: string[], range?: { from?: string; to?: string }): Promise<ExecutionCount[]> {\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    return report<ExecutionCount>(`exec-count:${range?.from ?? ''}:${range?.to ?? ''}`, orgId, orgIds, (pred) => 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      `);\n  }\n\n  /**\n   * 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 rangeClause = optionalStartedAtRange(range);\n    return report<PipelineExecution>(`pipeline-executions:${pipelineId}:${range?.from ?? ''}:${range?.to ?? ''}:${limit}`, orgId, orgIds, (pred) => 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      `);\n  }\n\n  /** Success rate over time for an org. */\n  async getSuccessRate(\n    orgId: string, interval: string, from: string, to: string, orgIds?: string[],\n    bucket: BucketOptions = {},\n  ): Promise<TimeSeriesEntry[]> {\n    assertReportInterval(interval);\n    const { tz = 'UTC', weekStart = 'monday' } = bucket;\n    // The bucketing settings are part of the cache KEY: without them a Chicago\n    // request and a UTC request share an entry and one of them gets the other's weeks.\n    return report<TimeSeriesEntry>(`success-rate:${interval}:${from}:${to}:${bucketKey(tz, weekStart)}`, orgId, orgIds, (pred) => sql`\n        SELECT\n          ${periodBucket(interval, sql`e.started_at`, tz, weekStart)}::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 ${startedAtWindow(from, to)}\n        GROUP BY period ORDER BY period\n      `);\n  }\n\n  /** Average duration per pipeline. */\n  async getAverageDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<DurationStats[]> {\n    return report<DurationStats>(`avg-duration:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY p.id ORDER BY avg_ms DESC\n      `);\n  }\n\n  /** Stage failure heatmap — which stages fail most. */\n  async getStageFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageFailure[]> {\n    return report<StageFailure>(`stage-failures:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY e.stage_name ORDER BY failures DESC\n      `);\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 rows = await report<{ environment: string }>(`report-envs:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        ORDER BY environment\n      `);\n    return rows.map((row) => row.environment);\n  }\n\n  /** Stage bottlenecks — slowest stages per pipeline. */\n  async getStageBottlenecks(orgId: string, from: string, to: string, orgIds?: string[]): Promise<StageBottleneck[]> {\n    return report<StageBottleneck>(`stage-bottlenecks:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC\n      `);\n  }\n\n  /** Action failure rate — which plugin steps fail most. */\n  async getActionFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<ActionFailure[]> {\n    return report<ActionFailure>(`action-failures:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY e.action_name ORDER BY failures DESC\n      `);\n  }\n\n  /**\n   * 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    return report<ErrorEntry>(`errors:${from}:${to}:${limit}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY error_pattern ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `);\n  }\n\n  /**\n   * The four DORA measures plus their per-environment breakdown.\n   * Implementation in ./reporting/dora.ts — see that file's header for why.\n   */\n  getDoraMetrics(\n    orgId: string, from: string, to: string, orgIds?: string[], opts: DoraOptions = {},\n  ): Promise<DoraMetrics> {\n    return doraMetrics(orgId, from, to, orgIds, opts);\n  }\n\n  /** DORA measures bucketed over time. */\n  getDoraTrend(\n    orgId: string, interval: string, from: string, to: string, orgIds?: string[], opts: DoraOptions = {},\n  ): Promise<DoraTrendPoint[]> {\n    return doraTrend(orgId, interval, from, to, orgIds, opts);\n  }\n\n  /** Per-pipeline build health (stage pass rates over a window). */\n  getBuildHealth(\n    orgId: string, pipelineId: string, from: string, to: string, orgIds?: string[],\n  ): Promise<BuildHealth> {\n    return buildHealth(orgId, pipelineId, from, to, orgIds);\n  }\n\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  /** 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  /** 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   * 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(\n    orgId: string, interval: string, from: string, to: string, orgIds?: string[],\n    bucket: BucketOptions = {},\n  ): Promise<BuildTimeSeriesEntry[]> {\n    assertReportInterval(interval);\n    const { tz = 'UTC', weekStart = 'monday' } = bucket;\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    return report<BuildTimeSeriesEntry>(`build-success:${interval}:${from}:${to}:${bucketKey(tz, weekStart)}`, orgId, orgIds, (pred) => sql`\n        SELECT\n          ${periodBucket(interval, sql`e.started_at`, tz, weekStart)}::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 ${startedAtWindow(from, to)}\n        GROUP BY period ORDER BY period\n      `);\n  }\n\n  /** Build duration per plugin. Build activity report — rollup-aware. */\n  async getBuildDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<BuildDuration[]> {\n    return report<BuildDuration>(`build-duration:${from}:${to}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY plugin_name ORDER BY avg_ms DESC\n      `);\n  }\n\n  /** 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    return report<BuildFailure>(`build-failures:${from}:${to}:${limit}`, orgId, orgIds, (pred) => 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 ${startedAtWindow(from, to)}\n        GROUP BY plugin_name, e.error_message\n        ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `);\n  }\n\n  // ── Plugin runtime telemetry — see ./reporting/plugin-runtime.ts ──\n\n  /**\n   * Plugin runtime: per plugin version runs, success rate and p50/p95\n   * duration over `[from, to]`, from the manifest-attributed ACTION events.\n   * Rollup-aware.\n   */\n  async getPluginRuntime(orgId: string, from: string, to: string, filter?: PluginRuntimeFilter, orgIds?: string[]): Promise<PluginRuntimeStats[]> {\n    return pluginRuntime(orgId, from, to, filter, orgIds);\n  }\n\n  /** Cross-org 30-day runtime aggregate for a `(publisher, name)` listing (plugin_stats input). Service callers only. */\n  async getPluginRuntimeAggregate(publisher: string, name: string): Promise<PluginRuntimeAggregate> {\n    return pluginRuntimeAggregate(publisher, name);\n  }\n\n  /** Review \"verified use\": `orgId` ran `(publisher, name)` successfully within 90 days. Service callers only. */\n  async hasVerifiedPluginUse(orgId: string, publisher: string, name: string): Promise<boolean> {\n    return verifiedPluginUse(orgId, publisher, name);\n  }\n\n  // ── Category 3: DORA write paths (post-deploy outcomes + ingest health) ──\n\n  /**\n   * Record a manual post-deploy outcome marker: 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 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        // A redelivered FIRING post (no resolvedAt) must not wipe a recorded\n        // resolve — senders re-post firing alerts on every repeat interval, and\n        // delivery order isn't guaranteed. Keep the stored resolve unless the\n        // post carries its own, or the incident was RE-OPENED (a different\n        // openedAt means a new occurrence, whose resolve state is the post's).\n        set: {\n          environment,\n          openedAt,\n          resolvedAt: sql`CASE WHEN ${schema.incident.openedAt} = excluded.opened_at\n            THEN COALESCE(excluded.resolved_at, ${schema.incident.resolvedAt})\n            ELSE excluded.resolved_at END`,\n          severity,\n        },\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. 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 getReportingSettings(orgId: string, retentionOrgId: string = orgId): Promise<ReportingSettings> {\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    // Retention is a billing entitlement synced onto the account ROOT only; a\n    // team reads its root's window (the incident window stays the team's own).\n    const retention = retentionOrgId === orgId\n      ? row\n      : await this.#readRetentionOverride(retentionOrgId);\n    return {\n      incidentWindowHours: row?.incident_window_hours != null ? Number(row.incident_window_hours) : null,\n      defaultWindowHours: DORA_INCIDENT_WINDOW_HOURS,\n      eventRetentionDays: retention?.event_retention_days != null ? Number(retention.event_retention_days) : null,\n      doraRetentionDays: retention?.dora_retention_days != null ? Number(retention.dora_retention_days) : null,\n      defaultEventRetentionDays: REPORTING_EVENT_RETENTION_DAYS,\n      defaultDoraRetentionDays: REPORTING_DORA_RETENTION_DAYS,\n    };\n  }\n\n  /**\n   * The ROOT org's stored retention override. The caller (a team) can't see the\n   * root's `dora_settings` row under its own RLS scope, so this narrow read of\n   * two integer columns — keyed by the explicit, JWT-derived root id — runs in a\n   * sysadmin scope.\n   */\n  async #readRetentionOverride(orgId: string): Promise<{ event_retention_days: number | null; dora_retention_days: number | null } | undefined> {\n    const rows = await runWithTenantContext({ isSuperAdmin: true }, async () => drizzleRows<{\n      event_retention_days: number | null;\n      dora_retention_days: number | null;\n    }>((await withTenantTx((tx) => tx.execute(sql`\n        SELECT ${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    return rows[0];\n  }\n\n  /**\n   * Upsert per-org reporting settings (incident window +\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 (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.getReportingSettings(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    // The correlation window is expressed in SECONDS as a double, not as\n    // `make_interval(hours => N::int)`. The window is validated as any positive\n    // number (0.5h is legal) and the in-memory DORA correlation uses it exactly;\n    // the int cast made Postgres reject a fractional value, so a 0.5h window\n    // returned 500 from this endpoint and from the correlation lookup below.\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(secs => ${windowHours * 3600}::double precision)\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: 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.getReportingSettings(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(secs => ${windowHours * 3600}::double precision)\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: 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   * Read back one org's ingestion health for the Reports UI freshness\n   * indicator. Returns `null` when the org has NO row — i.e. the deployment has\n   * never ingested anything — which the UI must render as \"no ingest reported\n   * yet\", never as \"stale\". RLS-scoped to the org like every other read.\n   */\n  async getIngestHealth(orgId: string): Promise<IngestHealthStatus | null> {\n    const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx\n        .select()\n        .from(schema.ingestHealth)\n        .where(eq(schema.ingestHealth.orgId, orgId))\n        .limit(1)),\n    );\n    const row = rows[0];\n    if (!row) return null;\n    return {\n      updatedAt: row.updatedAt.toISOString(),\n      lastEventAt: isoOrNull(row.lastEventAt),\n      forwarded: row.forwarded ?? null,\n      dropped: row.dropped ?? null,\n    };\n  }\n\n  /**\n   * Reporting retention sweep: hard-deletes rows past their per-org retention\n   * window (split standard-event vs DORA-source). Cross-tenant housekeeping —\n   * it establishes its own sysadmin scope. See ./reporting/retention-sweep.ts.\n   */\n  async purgeExpiredReportingData(opts: ReportingRetentionOptions = {}): Promise<ReportingRetentionCounts> {\n    return purgeReportingRetention(opts);\n  }\n\n  // ── Category 5: the ANALYTICS reads ──────────────────────────────────────\n  //\n  // Thin delegations to ./reporting/analytics-queries.ts, so `reportingService`\n  // satisfies the report engine's `SectionDataSource` in full and a section never\n  // reaches past the service for its data. Every one of these reads a\n  // pre-aggregated table (`execution_daily_rollups`, `dora_deployments`,\n  // `pipeline_plugin_resolution`, `plugin_vuln_exposure`) rather than raw events —\n  // which is what makes a quarterly report affordable AND what makes it still\n  // answerable after retention has swept the events it came from.\n\n  /** Per-pipeline delivery, worst first. */\n  async getPipelineBreakdown(scope: AnalyticsScope, limit = 10) {\n    return getPipelineBreakdown(scope, limit);\n  }\n\n  /** Failures by category, with the previous period's counts for the trend. */\n  async getFailureAnalysis(scope: AnalyticsScope, previous?: { from: string; to: string }) {\n    return getFailureAnalysis(scope, previous);\n  }\n\n  /** Per-stage timings for one pipeline, slowest first. */\n  async getStagePerformance(scope: AnalyticsScope, pipelineId: string, previous?: { from: string; to: string }) {\n    return getStagePerformance(scope, pipelineId, previous);\n  }\n\n  /** Build time by project and pipeline. Seconds, never money. */\n  async getResourceConsumption(scope: AnalyticsScope, limit = 20) {\n    return getResourceConsumption(scope, limit);\n  }\n\n  /** Each commit's path across environments, and which ones stopped short. */\n  async getPromotionView(scope: AnalyticsScope, productionEnv = 'production', limit = 25) {\n    return getPromotionView(scope, productionEnv, limit);\n  }\n\n  /** Pipelines behind on a plugin, worst gap first (the DECLARED side). */\n  async getOutdatedPlugins(scope: AnalyticsScope, limit = 50) {\n    return getOutdatedPlugins(scope, limit);\n  }\n\n  /** Open plugin vulnerabilities per pipeline (says declared vs deployed). */\n  async getPluginVulnerabilities(scope: AnalyticsScope, limit = 50) {\n    return getPluginVulnerabilities(scope, limit);\n  }\n\n  /** Adoption, creation source, and the deploy-tracking coverage denominator. */\n  async getAdoption(scope: AnalyticsScope, timeSavedMinutes?: number | null) {\n    return getAdoption(scope, timeSavedMinutes ?? (await this.timeSavedAssumption(scope.orgId)));\n  }\n\n  /**\n   * The needs-attention findings for the period.\n   *\n   * Assembled HERE rather than in the section, because the rules need six reads that\n   * must all describe the same window: this period's breakdown, the previous one's,\n   * failure streaks, config-change times, pipelines with an open Critical, and\n   * pipelines DORA cannot see. A section that fetched them itself would be the only\n   * place in the report where the window could drift between panels.\n   *\n   * Every input except the current breakdown is OPTIONAL to the evaluator, and each\n   * one's failure is absorbed: a rule with no data to run on is skipped, which is\n   * why one unavailable read costs one finding rather than the whole section. The\n   * alternative — a section that fails because the streak query timed out — replaces\n   * six findings with none.\n   */\n  async getNeedsAttention(scope: AnalyticsScope, previous?: { from: string; to: string }) {\n    const current = await getPipelineBreakdown(scope, ATTENTION_PIPELINE_LIMIT);\n    const prior = previous\n      ? await soften(getPipelineBreakdown({ ...scope, ...previous }, ATTENTION_PIPELINE_LIMIT), [])\n      : [];\n    const [streakRows, configChanges, vulnerable, untracked, thresholds] = await Promise.all([\n      soften(getPipelineStreaks(scope), []),\n      soften(getPipelineConfigChanges(scope), new Map<string, Date>()),\n      soften(getVulnerablePipelines(scope), []),\n      soften(getUntrackedPipelines(scope), []),\n      soften(this.attentionThresholds(scope.orgId), {}),\n    ]);\n    const items = evaluateNeedsAttention({\n      current,\n      previous: prior,\n      streaks: new Map(streakRows.map((r) => [r.pipelineId, {\n        consecutiveFailures: r.consecutiveFailures,\n        lastSuccessAt: r.lastSuccessAt,\n      }])),\n      configChanges,\n      vulnerablePipelines: new Set(vulnerable),\n      untrackedPipelines: new Set(untracked),\n      thresholds: thresholdsFrom(thresholds),\n      now: new Date(scope.to),\n    });\n    return {\n      items,\n      thresholds: thresholdsFrom(thresholds),\n      // What the rules were evaluated over, so a reader can tell an empty list\n      // (\"nothing tripped\") from an empty input (\"nothing ran\").\n      pipelinesEvaluated: current.length,\n    };\n  }\n\n  /**\n   * The org's stored needs-attention thresholds, or `{}`.\n   *\n   * Returned as a partial on purpose: `thresholdsFrom` fills the rest per field, so\n   * an org that configured one number keeps the defaults for the others instead of\n   * silently disabling four rules by setting one.\n   */\n  private async attentionThresholds(orgId: string): Promise<Record<string, number>> {\n    const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.select({ t: schema.doraSettings.reportAttentionThresholds })\n        .from(schema.doraSettings)\n        .where(eq(schema.doraSettings.orgId, orgId))\n        .limit(1)));\n    const stored = (rows as Array<{ t: Record<string, number> | null }>)[0]?.t;\n    return stored && typeof stored === 'object' ? stored : {};\n  }\n\n  /**\n   * The org's own minutes-saved-per-pipeline assumption, or null.\n   *\n   * Read here so the adoption section cannot accidentally be handed a\n   * platform-chosen default: the number only means something when the customer\n   * picked it, and `null` renders as \"not estimated\" rather than as zero.\n   */\n  private async timeSavedAssumption(orgId: string): Promise<number | null> {\n    const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () =>\n      withTenantTx((tx) => tx.select({ minutes: schema.doraSettings.timeSavedMinutesPerPipeline })\n        .from(schema.doraSettings)\n        .where(eq(schema.doraSettings.orgId, orgId))\n        .limit(1)));\n    return (rows as Array<{ minutes: number | null }>)[0]?.minutes ?? null;\n  }\n}\n\n/**\n * How many pipelines the needs-attention rules consider.\n *\n * The section is a short list of things to do, not a table of everything, so the\n * evaluator sees the same worst-first slice the breakdown section shows. A pipeline\n * outside the worst 25 by the breakdown's own ordering is not the one a lead should\n * be told about first.\n */\nconst ATTENTION_PIPELINE_LIMIT = 25;\n\n/**\n * Run a read, or fall back.\n *\n * Only for the needs-attention inputs, where an absent input SKIPS a rule and the\n * evaluator says so. Never used for a number the report presents: a query that fails\n * and silently reads as zero is how a report states something false.\n */\nasync function soften<T>(p: Promise<T>, fallback: T): Promise<T> {\n  try {\n    return await p;\n  } catch (err) {\n    logger.warn('Needs-attention input unavailable; its rule is skipped', { error: errorMessage(err) });\n    return fallback;\n  }\n}\n\nexport const reportingService = new ReportingService();\n"]}