@pipeline-builder/pipeline-data 4.1.24 → 4.1.25

package/lib/api/reporting/stakeholder/templates.d.ts

@@ -0,0 +1,21 @@
+import type { ReportCadence, ReportTemplate } from '../../../database/schema/reporting-stakeholder.js';
+/** A named, ordered section list with the cadence it is designed for. */
+export interface TemplateSpec {
+    id: ReportTemplate;
+    /** What a lead picks in the UI. */
+    label: string;
+    /** One line explaining who it is for — shown next to the label. */
+    audience: string;
+    /** The cadence this template assumes. A weekly DORA report is mostly noise. */
+    cadence: ReportCadence;
+    sections: readonly string[];
+}
+export declare const REPORT_TEMPLATE_SPECS: readonly TemplateSpec[];
+/** Look a template up by id. */
+export declare function getTemplate(id: string): TemplateSpec | undefined;
+/**
+ * Every section id a template names must exist in the registry. Called at module
+ * load so a template referencing a removed section fails the BUILD rather than
+ * producing a report full of "Unknown report section" panels in production.
+ */
+export declare function assertTemplatesResolve(): void;

package/lib/api/reporting/stakeholder/templates.js

@@ -0,0 +1,104 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The manager-facing templates.
+ *
+ * A template is a curated section list, not a free-form picker, because the
+ * failure mode of this feature is a report nobody reads. Managers do not act on
+ * "p95 stage duration"; they act on answers to four questions — are we shipping,
+ * is it getting better or worse, what is blocking us, is anything risky. Each
+ * template answers those in that order, so the first thing on the page is a
+ * number with a direction rather than a table.
+ *
+ * Section ORDER is the reading order. It is deliberate and worth preserving.
+ */
+import { getSection } from './sections.js';
+export const REPORT_TEMPLATE_SPECS = [
+    {
+        id: 'weekly_delivery',
+        label: 'Weekly delivery summary',
+        audience: 'For an engineering manager: what shipped this week and what is blocking it.',
+        cadence: 'weekly',
+        // NEEDS ATTENTION LEADS. A weekly report's job is to answer "what should I
+        // look at", and putting the decision first is the difference between a report
+        // that gets read and a table that gets skimmed. Then: are we shipping, what is
+        // breaking, and which pipelines are worst.
+        //
+        // No DORA here: weekly DORA on a normal team is too small a sample to mean
+        // anything, and the locked-section path would dominate the page for orgs
+        // without the add-on.
+        sections: [
+            'needs_attention',
+            'execution_count',
+            'success_rate',
+            'failure_analysis',
+            'pipeline_breakdown',
+            'promotion',
+        ],
+    },
+    {
+        id: 'monthly_health',
+        label: 'Monthly engineering health',
+        audience: 'For a director: delivery performance with DORA levels and trend.',
+        cadence: 'monthly',
+        // A month is the smallest window where DORA bands are meaningful. Adds the
+        // supply-chain and posture panels a director is accountable for and a lead
+        // rarely volunteers: vulnerable plugins, versions behind, compliance.
+        sections: [
+            'needs_attention',
+            'dora',
+            'dora_trend',
+            'success_rate',
+            'failure_analysis',
+            'stage_performance',
+            'plugin_vulnerabilities',
+            'outdated_plugins',
+            'compliance_posture',
+        ],
+    },
+    {
+        id: 'quarterly_review',
+        label: 'Quarterly review',
+        audience: 'For a leadership review: the quarter across teams, with quarter-over-quarter change.',
+        cadence: 'quarterly',
+        // Widest view: delivery, health, supply chain, adoption and cost-of-build.
+        // `adoption` and `resource_consumption` are here and nowhere else — both are
+        // quarter-scale questions, and asking them weekly would produce noise a lead
+        // would rightly ignore.
+        sections: [
+            'dora',
+            'dora_trend',
+            'execution_count',
+            'success_rate',
+            'failure_analysis',
+            'promotion',
+            'environments',
+            'plugin_vulnerabilities',
+            'outdated_plugins',
+            'compliance_posture',
+            'adoption',
+            'resource_consumption',
+        ],
+    },
+];
+/** Look a template up by id. */
+export function getTemplate(id) {
+    return REPORT_TEMPLATE_SPECS.find((t) => t.id === id);
+}
+/**
+ * Every section id a template names must exist in the registry. Called at module
+ * load so a template referencing a removed section fails the BUILD rather than
+ * producing a report full of "Unknown report section" panels in production.
+ */
+export function assertTemplatesResolve() {
+    for (const template of REPORT_TEMPLATE_SPECS) {
+        for (const id of template.sections) {
+            if (!getSection(id)) {
+                throw new Error(`Template "${template.id}" names unknown section "${id}". `
+                    + 'Register it in sections.ts or remove it from the template.');
+            }
+        }
+    }
+}
+assertTemplatesResolve();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../../../src/api/reporting/stakeholder/templates.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAe3C,MAAM,CAAC,MAAM,qBAAqB,GAA4B;IAC5D;QACE,EAAE,EAAE,iBAAiB;QACrB,KAAK,EAAE,yBAAyB;QAChC,QAAQ,EAAE,6EAA6E;QACvF,OAAO,EAAE,QAAQ;QACjB,2EAA2E;QAC3E,8EAA8E;QAC9E,+EAA+E;QAC/E,2CAA2C;QAC3C,EAAE;QACF,2EAA2E;QAC3E,yEAAyE;QACzE,sBAAsB;QACtB,QAAQ,EAAE;YACR,iBAAiB;YACjB,iBAAiB;YACjB,cAAc;YACd,kBAAkB;YAClB,oBAAoB;YACpB,WAAW;SACZ;KACF;IACD;QACE,EAAE,EAAE,gBAAgB;QACpB,KAAK,EAAE,4BAA4B;QACnC,QAAQ,EAAE,kEAAkE;QAC5E,OAAO,EAAE,SAAS;QAClB,2EAA2E;QAC3E,2EAA2E;QAC3E,sEAAsE;QACtE,QAAQ,EAAE;YACR,iBAAiB;YACjB,MAAM;YACN,YAAY;YACZ,cAAc;YACd,kBAAkB;YAClB,mBAAmB;YACnB,wBAAwB;YACxB,kBAAkB;YAClB,oBAAoB;SACrB;KACF;IACD;QACE,EAAE,EAAE,kBAAkB;QACtB,KAAK,EAAE,kBAAkB;QACzB,QAAQ,EAAE,sFAAsF;QAChG,OAAO,EAAE,WAAW;QACpB,2EAA2E;QAC3E,6EAA6E;QAC7E,6EAA6E;QAC7E,wBAAwB;QACxB,QAAQ,EAAE;YACR,MAAM;YACN,YAAY;YACZ,iBAAiB;YACjB,cAAc;YACd,kBAAkB;YAClB,WAAW;YACX,cAAc;YACd,wBAAwB;YACxB,kBAAkB;YAClB,oBAAoB;YACpB,UAAU;YACV,sBAAsB;SACvB;KACF;CACF,CAAC;AAEF,gCAAgC;AAChC,MAAM,UAAU,WAAW,CAAC,EAAU;IACpC,OAAO,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB;IACpC,KAAK,MAAM,QAAQ,IAAI,qBAAqB,EAAE,CAAC;QAC7C,KAAK,MAAM,EAAE,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,CAAC;gBACpB,MAAM,IAAI,KAAK,CACb,aAAa,QAAQ,CAAC,EAAE,4BAA4B,EAAE,KAAK;sBACzD,4DAA4D,CAC/D,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED,sBAAsB,EAAE,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The manager-facing templates.\n *\n * A template is a curated section list, not a free-form picker, because the\n * failure mode of this feature is a report nobody reads. Managers do not act on\n * \"p95 stage duration\"; they act on answers to four questions — are we shipping,\n * is it getting better or worse, what is blocking us, is anything risky. Each\n * template answers those in that order, so the first thing on the page is a\n * number with a direction rather than a table.\n *\n * Section ORDER is the reading order. It is deliberate and worth preserving.\n */\n\nimport { getSection } from './sections.js';\nimport type { ReportCadence, ReportTemplate } from '../../../database/schema/reporting-stakeholder.js';\n\n/** A named, ordered section list with the cadence it is designed for. */\nexport interface TemplateSpec {\n  id: ReportTemplate;\n  /** What a lead picks in the UI. */\n  label: string;\n  /** One line explaining who it is for — shown next to the label. */\n  audience: string;\n  /** The cadence this template assumes. A weekly DORA report is mostly noise. */\n  cadence: ReportCadence;\n  sections: readonly string[];\n}\n\nexport const REPORT_TEMPLATE_SPECS: readonly TemplateSpec[] = [\n  {\n    id: 'weekly_delivery',\n    label: 'Weekly delivery summary',\n    audience: 'For an engineering manager: what shipped this week and what is blocking it.',\n    cadence: 'weekly',\n    // NEEDS ATTENTION LEADS. A weekly report's job is to answer \"what should I\n    // look at\", and putting the decision first is the difference between a report\n    // that gets read and a table that gets skimmed. Then: are we shipping, what is\n    // breaking, and which pipelines are worst.\n    //\n    // No DORA here: weekly DORA on a normal team is too small a sample to mean\n    // anything, and the locked-section path would dominate the page for orgs\n    // without the add-on.\n    sections: [\n      'needs_attention',\n      'execution_count',\n      'success_rate',\n      'failure_analysis',\n      'pipeline_breakdown',\n      'promotion',\n    ],\n  },\n  {\n    id: 'monthly_health',\n    label: 'Monthly engineering health',\n    audience: 'For a director: delivery performance with DORA levels and trend.',\n    cadence: 'monthly',\n    // A month is the smallest window where DORA bands are meaningful. Adds the\n    // supply-chain and posture panels a director is accountable for and a lead\n    // rarely volunteers: vulnerable plugins, versions behind, compliance.\n    sections: [\n      'needs_attention',\n      'dora',\n      'dora_trend',\n      'success_rate',\n      'failure_analysis',\n      'stage_performance',\n      'plugin_vulnerabilities',\n      'outdated_plugins',\n      'compliance_posture',\n    ],\n  },\n  {\n    id: 'quarterly_review',\n    label: 'Quarterly review',\n    audience: 'For a leadership review: the quarter across teams, with quarter-over-quarter change.',\n    cadence: 'quarterly',\n    // Widest view: delivery, health, supply chain, adoption and cost-of-build.\n    // `adoption` and `resource_consumption` are here and nowhere else — both are\n    // quarter-scale questions, and asking them weekly would produce noise a lead\n    // would rightly ignore.\n    sections: [\n      'dora',\n      'dora_trend',\n      'execution_count',\n      'success_rate',\n      'failure_analysis',\n      'promotion',\n      'environments',\n      'plugin_vulnerabilities',\n      'outdated_plugins',\n      'compliance_posture',\n      'adoption',\n      'resource_consumption',\n    ],\n  },\n];\n\n/** Look a template up by id. */\nexport function getTemplate(id: string): TemplateSpec | undefined {\n  return REPORT_TEMPLATE_SPECS.find((t) => t.id === id);\n}\n\n/**\n * Every section id a template names must exist in the registry. Called at module\n * load so a template referencing a removed section fails the BUILD rather than\n * producing a report full of \"Unknown report section\" panels in production.\n */\nexport function assertTemplatesResolve(): void {\n  for (const template of REPORT_TEMPLATE_SPECS) {\n    for (const id of template.sections) {\n      if (!getSection(id)) {\n        throw new Error(\n          `Template \"${template.id}\" names unknown section \"${id}\". `\n          + 'Register it in sections.ts or remove it from the template.',\n        );\n      }\n    }\n  }\n}\n\nassertTemplatesResolve();\n"]}

package/lib/api/reporting/types.d.ts

@@ -153,9 +153,30 @@ export interface ReportingRetentionSettings {
     defaultDoraRetentionDays: number;
 }
 /** Options for the reporting retention sweep. */
+/**
+ * How a time-bucketed report slices its periods. Absent means UTC + Monday, which
+ * is what every pre-timezone caller got — so an omitted value can never silently
+ * change an existing report's boundaries.
+ */
+export interface BucketOptions {
+    /** IANA timezone the buckets are cut in (validated at the route). */
+    tz?: string;
+    /** Where the week starts. Postgres DATE_TRUNC is Monday-only, so `sunday`
+     *  shifts the boundary explicitly. */
+    weekStart?: 'monday' | 'sunday';
+}
 export interface ReportingRetentionOptions {
     /** Rows deleted per statement (default 1000). */
     batchSize?: number;
+    /**
+     * The leader-locked run this sweep belongs to. Checked BETWEEN ORGS: aborted
+     * means the lock was lost (another pod is taking over) or the process is
+     * shutting down, and the remaining orgs are picked up next tick. Without it a
+     * long sweep kept deleting after another pod had already taken the lock.
+     */
+    run?: {
+        signal: AbortSignal;
+    };
     /** Max batches per table per org per tick (default 50); the rest defers to
      *  the next tick so a huge backlog can't hold locks too long. */
     maxBatchesPerTable?: number;
@@ -204,6 +225,10 @@ export interface DoraOptions {
      * passes it in; unset falls back to the env default.
      */
     incidentWindowHours?: number;
+    /** IANA timezone for the trend's buckets (see {@link BucketOptions}). */
+    tz?: string;
+    /** Week start for the trend's buckets. */
+    weekStart?: 'monday' | 'sunday';
 }
 /**
  * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`
@@ -301,6 +326,11 @@ export interface DoraMetrics {
         incidents: number;
         restored: number;
         medianSeconds: number | null;
+        /** 90th/95th percentile recovery, over the same sample as the median. The
+         *  median alone hides the long tail that actually defines an outage's cost;
+         *  `null` when no recovery gap was observed. */
+        p90Seconds: number | null;
+        p95Seconds: number | null;
         level: DoraLevel;
     };
     /**
@@ -346,11 +376,16 @@ export interface DoraEnvMetrics {
      * successful deploys with a resolvable commit timestamp (deltas clamped ≥0).
      * `medianSeconds` is `null` (= unknown) when no successful deploy in this env
      * carried a `commit_timestamp`. The old median-run-duration proxy is removed.
+     *
+     * `p90Seconds`/`p95Seconds` come from the same sample. The level is scored off
+     * the MEDIAN only, so adding the tails cannot move a team's DORA band.
      */
     leadTime: {
         /** Successful deploys with a resolvable commit time (the median sample). */
         deployments: number;
         medianSeconds: number | null;
+        p90Seconds: number | null;
+        p95Seconds: number | null;
         level: DoraLevel;
     };
 }
@@ -459,6 +494,44 @@ export interface IngestResult {
      * PIPELINE or BUILD events would land rows and push no frame at all.
      */
     affectedOrgs: string[];
+    /**
+     * Events dropped because the pipeline they name belongs to an org the caller
+     * may not write for. Surfaced so the route can log and count them: a non-zero
+     * value is either a misrouted producer or an attempt to inject events into
+     * another tenant's reports, and both need to be visible.
+     */
+    droppedForeignOrg: number;
+    /**
+     * Events dropped because their timestamps are impossible — dated in the future,
+     * or completing before they started. Rejected here rather than clamped later:
+     * a deploy whose duration or lead time is negative silently skews deployment
+     * frequency, change-failure rate and lead time for the whole org, and a clamp
+     * to 0 makes a bad clock look like an instant deploy.
+     */
+    droppedInvalidTime: number;
+}
+/**
+ * Who is writing, for the ingest tenancy check.
+ *
+ * `/reports/events` resolves an event's org from the pipeline registry, so
+ * without this a token holding `reporting:ingest` could post events for ANY
+ * pipeline id and have them attributed to that pipeline's org — one org
+ * injecting rows into another's reports.
+ */
+export interface IngestCaller {
+    /**
+     * Org ids this caller may write events for: its own, plus descendant teams.
+     * Resolved by the route. An event whose pipeline belongs to anything else is
+     * dropped.
+     */
+    allowedOrgIds: readonly string[];
+    /**
+     * A verified INTERNAL service principal (the plugin service posts plugin-build
+     * events for every tenant). Such callers are exempt: they hold a signed
+     * service key no external client can mint, and they legitimately write
+     * cross-tenant. Never set this from anything a request body can influence.
+     */
+    crossTenant?: boolean;
 }
 /**
  * One org's ingestion-health row as READ back by the Reports UI. The

package/lib/api/reporting/types.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/api/reporting/types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Public result shapes for the reporting service.\n *\n * Split out of reporting-service.ts purely for size: these are data contracts\n * with no behaviour. reporting-service.ts re-exports them, so the\n * `@pipeline-builder/pipeline-data` public surface is unchanged.\n */\n\nexport interface ExecutionCount {\n  id: string;\n  project: string;\n  organization: string;\n  pipelineName: string | null;\n  total: number;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  firstExecution: string | null;\n  lastExecution: string | null;\n}\n\nexport interface TimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  successPct: number;\n}\n\nexport interface DurationStats {\n  id: string;\n  project: string;\n  pipelineName: string | null;\n  avgMs: number;\n  minMs: number;\n  maxMs: number;\n  p95Ms: number;\n  executions: number;\n}\n\nexport interface PipelineExecution {\n  executionId: string;\n  /** Rolled-up terminal status: succeeded | failed | canceled | in-progress. */\n  status: string;\n  startedAt: string | null;\n  endedAt: string | null;\n  durationMs: number | null;\n  /** First failing stage/action for the execution (null when it didn't fail). */\n  failingStage: string | null;\n  failingAction: string | null;\n}\n\nexport interface StageFailure {\n  stageName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\nexport interface StageBottleneck {\n  id: string;\n  pipelineName: string | null;\n  stageName: string;\n  avgMs: number;\n  maxMs: number;\n}\n\nexport interface ActionFailure {\n  actionName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\nexport interface ErrorEntry {\n  errorPattern: string;\n  occurrences: number;\n  affectedPipelines: number;\n  lastSeen: string;\n}\n\nexport interface PluginSummary {\n  total: number;\n  active: number;\n  inactive: number;\n  /** Counts per sharing rung — one bucket per `visibility` value. */\n  public: number;\n  org: number;\n  private: number;\n  uniqueNames: number;\n}\n\nexport interface TypeComputeDistribution {\n  pluginType: string;\n  computeType: string;\n  count: number;\n}\n\nexport interface VersionCount {\n  name: string;\n  versionCount: number;\n  latestVersion: string;\n  hasDefault: boolean;\n}\n\nexport interface BuildTimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  successPct: number;\n}\n\nexport interface BuildDuration {\n  pluginName: string;\n  avgMs: number;\n  maxMs: number;\n  builds: number;\n}\n\n/**\n * Plugin runtime report filters. `publisher: null` selects own-org\n * (publisher-less) plugins; an omitted field doesn't filter.\n */\nexport interface PluginRuntimeFilter {\n  name?: string;\n  publisher?: string | null;\n  version?: string;\n}\n\n/** Per plugin version runtime stats over a window (terminal ACTION runs). */\nexport interface PluginRuntimeStats {\n  pluginPublisher: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  runs: number;\n  succeeded: number;\n  failed: number;\n  /** 0–100, one decimal. */\n  successPct: number;\n  /** Null when no run in the group carried a duration. */\n  p50Ms: number | null;\n  p95Ms: number | null;\n  lastRun: string;\n}\n\n/** Cross-org 30-day aggregate for one `(publisher, name)` listing. */\nexport interface PluginRuntimeAggregate {\n  runs30d: number;\n  /** 0–1; null when there were no runs. */\n  successRate30d: number | null;\n  activeOrgCount30d: number;\n}\n\nexport interface BuildFailure {\n  pluginName: string;\n  errorMessage: string;\n  occurrences: number;\n  lastSeen: string;\n}\n\n/**\n * The DORA headline environment. Deployment to this literal env name is the\n * industry-standard DORA signal; MTTR is measured production-only, and this\n * environment's card is the summary shown at the top of the panel.\n */\n\n/** Per-org retention override row. Both nullable ⇒ global defaults. */\nexport interface ReportingRetentionSettings {\n  eventRetentionDays: number | null;\n  doraRetentionDays: number | null;\n  defaultEventRetentionDays: number;\n  defaultDoraRetentionDays: number;\n}\n\n/** Options for the reporting retention sweep. */\nexport interface ReportingRetentionOptions {\n  /** Rows deleted per statement (default 1000). */\n  batchSize?: number;\n  /** Max batches per table per org per tick (default 50); the rest defers to\n   *  the next tick so a huge backlog can't hold locks too long. */\n  maxBatchesPerTable?: number;\n  /** Fixed \"now\" for the whole sweep (default `new Date()`). */\n  now?: Date;\n  /**\n   * Resolve the org whose `dora_settings` retention governs `orgId`'s rows — its\n   * account ROOT. Retention is a billing entitlement synced onto the root only,\n   * so a team's rows must follow the root's (purchased) window, not the env\n   * default. Return `null` when the root can't be resolved: that org is SKIPPED\n   * this tick (never purged on a possibly-shorter window). Default: identity\n   * (every org is its own root — a flat deployment).\n   */\n  resolveRetentionOrgId?: (orgId: string) => Promise<string | null>;\n}\n\n/** Per-run purge tallies (also logged). */\nexport interface ReportingRetentionCounts {\n  /** Orgs swept this run. */\n  orgs: number;\n  /** Standard `pipeline_events` (environment IS NULL) rows purged. */\n  standardEvents: number;\n  /** DORA-source `pipeline_events` (environment IS NOT NULL) rows purged. */\n  doraEvents: number;\n  /** `deployment_outcomes` rows purged. */\n  deploymentOutcomes: number;\n  /** `incidents` rows purged. */\n  incidents: number;\n}\n\n/**\n * DORA performance band. `null` = insufficient data to classify (no\n * deployments/failures/lead-time sample in the window), so the UI shows a\n * neutral state rather than mislabeling an empty window as \"low\".\n */\nexport type DoraLevel = 'elite' | 'high' | 'medium' | 'low' | null;\n\n/** Optional scoping for {@link ReportingService.getDoraMetrics}. */\nexport interface DoraOptions {\n  /** Restrict to a single pipeline (per-pipeline DORA). */\n  pipelineId?: string;\n  /** Restrict to a single deploy environment (else all deploy environments). */\n  environment?: string;\n  /**\n   * Per-org incident→deploy correlation window override (hours). When set (a\n   * positive finite number), the incident correlation uses it instead of the\n   * global `DORA_INCIDENT_WINDOW_HOURS`. The route resolves this from the org's\n   * `dora_settings` row (see {@link ReportingService.getReportingSettings}) and\n   * passes it in; unset falls back to the env default.\n   */\n  incidentWindowHours?: number;\n}\n\n/**\n * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`\n * is the incident→deploy correlation window; `eventRetentionDays` /\n * `doraRetentionDays` are the two retention-sweep windows. Each override\n * is `null` when unset (the paired `default*` field shows the env fallback applied).\n */\nexport interface ReportingSettings {\n  /** The org's stored correlation-window override in hours, or `null` when unset. */\n  incidentWindowHours: number | null;\n  /** The global env default applied when no override is stored. */\n  defaultWindowHours: number;\n  /** Standard-event retention override in days, or `null` when unset. */\n  eventRetentionDays: number | null;\n  /** DORA-source retention override in days, or `null` when unset. */\n  doraRetentionDays: number | null;\n  /** Global standard-event retention default applied when unset (days). */\n  defaultEventRetentionDays: number;\n  /** Global DORA-source retention default applied when unset (days). */\n  defaultDoraRetentionDays: number;\n}\n\n/** A partial reporting-settings write (7). Only provided fields are\n *  upserted; omitted fields are left unchanged (an omitted retention field keeps\n *  its stored override / the global default). */\nexport interface ReportingSettingsPatch {\n  incidentWindowHours?: number;\n  eventRetentionDays?: number;\n  doraRetentionDays?: number;\n}\n\n/** One row of the org-admin incidents list (recent incidents + deploy correlation). */\nexport interface IncidentListItem {\n  incidentId: string;\n  environment: string;\n  severity: string;\n  openedAt: string | null;\n  resolvedAt: string | null;\n  createdAt: string | null;\n  /** True once the incident has a `resolved_at`. */\n  resolved: boolean;\n  /** The correlated deploy execution id (most recent successful deploy in-window), or null. */\n  correlatedExecutionId: string | null;\n  /** That deploy's completion instant, or null when uncorrelated. */\n  deployCompletedAt: string | null;\n}\n\n/** Result of the wiring-test dry-run correlation ({@link ReportingService.testIncidentCorrelation}). */\nexport interface IncidentTestResult {\n  environment: string;\n  /** The synthetic incident's openedAt (now, ISO). */\n  openedAt: string;\n  /** The effective correlation window used. */\n  windowHours: number;\n  /** Whether a recent successful deploy to `environment` correlated. */\n  correlated: boolean;\n  /** The correlated deploy execution id, or null. */\n  executionId: string | null;\n  /** That deploy's completion instant, or null. */\n  deployCompletedAt: string | null;\n}\n\n// DORA performance bands (thresholds from the DORA/Accelerate reports). Each\n// helper returns `null` when there's no sample to classify.\n/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */\n\n/**\n * DORA metrics over a [from,to] window, org-scoped (single-org or rollup subtree).\n *\n * DEPLOY-BASIS — every metric derives from real DEPLOY-STAGE executions, i.e.\n * `pipeline_events` rows with `event_type='STAGE'` and a non-null `environment`\n * (the forwarder sets `environment` only for the stages a user declared in\n * `pb.deploys`). A CI-only build/test pipeline with no deploy stage produces NO\n * DORA data — there is no run-based fallback. The panel is empty until deployed\n * pipelines re-synth with the new deploy tags and start emitting deploy events.\n *\n * `production` is the headline environment; MTTR is measured production-only.\n */\nexport interface DoraMetrics {\n  /** The [from,to] window echoed back (deploy `completed_at` range). */\n  window: { from: string; to: string };\n  /** The scoping applied (echoed for the UI); `null` when unscoped. */\n  filters: { pipelineId: string | null; environment: string | null };\n  /** The headline environment name (`production`). */\n  headline: string;\n  /** Per-environment DF / CFR / lead time. Sorted headline-first, then A→Z. */\n  environments: DoraEnvMetrics[];\n  /**\n   * Mean Time To Restore — PRODUCTION-ONLY, from `deployment_outcomes`.\n   * `median(restored.at − deployed.completed_at)` over restored production\n   * incidents (deltas clamped ≥0). `incidents` counts production deploys marked\n   * failed; `restored` counts those that recovered; `medianSeconds` is null when\n   * no restored incident has a resolvable deploy time.\n   */\n  meanTimeToRestore: {\n    incidents: number;\n    restored: number;\n    medianSeconds: number | null;\n    level: DoraLevel;\n  };\n  /**\n   * Coverage reconciliation — registered pipelines with no observed deploy in\n   * the window. A high `withoutDeploys` count means DORA is blind to most of the\n   * fleet (pipelines that haven't re-synthed with deploy tags, or don't deploy).\n   */\n  coverage: {\n    /** Pipelines in the registry (org-scoped). */\n    registered: number;\n    /** Registered pipelines with ≥1 deploy-stage execution in the window. */\n    deploying: number;\n    /** registered − deploying (clamped ≥0). */\n    withoutDeploys: number;\n  };\n}\n\n/** Per-environment DORA metrics (deployment frequency, CFR, lead time). */\nexport interface DoraEnvMetrics {\n  environment: string;\n  /** Deployment Frequency — successful deploy-stage executions for this env. */\n  deploymentFrequency: {\n    deployments: number;\n    perDay: number;\n    level: DoraLevel;\n  };\n  /**\n   * Change Failure Rate — two-class:\n   * `(deployTimeFailures + postDeployFailures) / attempts`.\n   * - `deployTimeFailures` — deploy stage `result=failed` (from events).\n   * - `postDeployFailures` — a successful deploy later marked failed in prod\n   *   (from `deployment_outcomes`).\n   * - `attempts` — all terminal deploy-stage attempts (succeeded + failed).\n   */\n  changeFailureRate: {\n    rate: number;\n    deployTimeFailures: number;\n    postDeployFailures: number;\n    attempts: number;\n    level: DoraLevel;\n  };\n  /**\n   * Lead Time — MEASURED: `median(deploy_completed − oldest_commit_time)` over\n   * successful deploys with a resolvable commit timestamp (deltas clamped ≥0).\n   * `medianSeconds` is `null` (= unknown) when no successful deploy in this env\n   * carried a `commit_timestamp`. The old median-run-duration proxy is removed.\n   */\n  leadTime: {\n    /** Successful deploys with a resolvable commit time (the median sample). */\n    deployments: number;\n    medianSeconds: number | null;\n    level: DoraLevel;\n  };\n}\n\n/** One interval bucket of the DORA trend (deploy frequency + change failure). */\nexport interface DoraTrendPoint {\n  /** Bucket start (DATE_TRUNC of the deploy `completed_at`), ISO text. */\n  period: string;\n  /** Successful deploy-stage executions in the bucket. */\n  deployments: number;\n  /** Failed deploy-stage executions in the bucket. */\n  failed: number;\n  /** succeeded + failed in the bucket (deploy attempts). */\n  total: number;\n  /** failed/total as a percent (0 when total is 0). Deploy-time CFR only. */\n  changeFailurePct: number;\n}\n\n/** Per-stage build-health metrics for one pipeline over a window. */\nexport interface BuildHealthStage {\n  stage: string;\n  /** Terminal stage runs (succeeded + failed) in the window. */\n  runs: number;\n  successes: number;\n  failures: number;\n  /** successes / runs as a percent (0 when runs is 0). */\n  successRate: number;\n  /** Duration percentiles over the stage's terminal runs; null when no durations. */\n  p50Ms: number | null;\n  p90Ms: number | null;\n  p99Ms: number | null;\n}\n\n/**\n * Per-pipeline build-health breakdown. Standard reporting (NOT\n * `advanced_reporting`-gated) — per-stage success rate + timing percentiles, with\n * totals summed across stages.\n */\nexport interface BuildHealth {\n  stages: BuildHealthStage[];\n  totals: { runs: number; failures: number; failureRate: number };\n}\n\n/** Post-deploy incident marker accepted by `ReportingService.recordIncident`. */\nexport interface IncidentInput {\n  incidentId: string;\n  environment: string;\n  openedAt: string;\n  resolvedAt?: string;\n  severity: string;\n}\n\n/** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */\nexport interface IngestEvent {\n  /** Stable pipeline id the events Lambda read from the `pb.pipeline-id`\n   *  tag (= the platform pipelineId). The registry join key. */\n  pipelineId: string;\n  eventSource: 'codepipeline' | 'codebuild' | 'plugin-build';\n  eventType: 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason (Action events). */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  /** Source commit id of the change being shipped (DORA deploy attribution). */\n  commitSha?: string;\n  /** Source ref/branch (DORA deploy attribution). */\n  commitRef?: string;\n  /** Deploy target (e.g. \"production\"). Its presence on a STAGE/ACTION event\n   *  marks a real deployment (derived server-side — there is no `isDeploy`). */\n  environment?: string;\n  /** Oldest unshipped commit timestamp (ISO 8601) for measured lead time. */\n  commitTimestamp?: string;\n  /** Number of commits shipped in this change (≥1). */\n  commitCount?: number;\n  detail?: Record<string, unknown>;\n}\n\n/**\n * Per-event metric descriptor emitted (via the {@link ReportingService.ingestEvents}\n * `onMetric` hook) for each REGISTERED terminal deploy/stage event, so the route\n * layer can fan them into Prometheus counters without pipeline-data importing\n * api-server's metrics registry. `result` is the terminal outcome; `environment`\n * is non-null only for a deploy-stage event.\n */\nexport interface IngestMetric {\n  pipelineId: string;\n  orgId: string;\n  stage: string;\n  environment: string | null;\n  result: 'succeeded' | 'failed';\n}\n\n/** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */\nexport interface IngestResult {\n  inserted: number;\n  skipped: number;\n  unregisteredPipelineIds: string[];\n  /**\n   * Every org with at least one row in this batch, deduped.\n   *\n   * Already computed for post-commit cache invalidation; surfaced because the\n   * ingest route needs the same set to push its live SSE frame. The stage-metric\n   * hook can't drive that fan-out: it only fires for STAGE events, so a batch of\n   * PIPELINE or BUILD events would land rows and push no frame at all.\n   */\n  affectedOrgs: string[];\n}\n\n/**\n * One org's ingestion-health row as READ back by the Reports UI. The\n * AWS events Lambda writes it; this is the shape that lets the UI tell\n * \"ingestion is healthy, there were simply no deploys in the range\" apart from\n * \"we haven't heard from the ingest pipeline since X\".\n *\n * `null` from {@link ReportingService.getIngestHealth} means the deployment has\n * NEVER reported — not \"stale\". The two must not be conflated: a fresh install\n * (or one whose forwarder was never wired up) has no heartbeat at all, and\n * calling that \"stale\" would invent a regression that never happened.\n */\nexport interface IngestHealthStatus {\n  /** When the forwarder last posted a heartbeat (its own clock, ISO 8601). */\n  updatedAt: string;\n  /** Timestamp of the newest event it had forwarded, or null if it has seen none. */\n  lastEventAt: string | null;\n  /** Cumulative events forwarded, or null when the forwarder doesn't report it. */\n  forwarded: number | null;\n  /** Cumulative events DROPPED (non-zero ⇒ data loss upstream of the reports). */\n  dropped: number | null;\n}\n\n\n/**\n * Read-only reporting service for pipeline execution and plugin inventory aggregations.\n * Does not extend CrudService — reports are aggregate queries, not entity CRUD.\n *\n * All queries are cached in-memory to avoid repeated expensive SQL aggregations:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL\n * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL\n */\n\n/**\n * Internal row shapes for the DORA queries. Exported because ./dora.ts consumes\n * them; not part of the package's public surface (reporting-service.ts\n * re-exports this module wholesale, which is a deliberate simplification — these\n * describe query results, not API contracts).\n */\nexport interface DeployRow {\n  environment: string;\n  status: 'SUCCEEDED' | 'FAILED' | string;\n  /** Deploy execution id — the attribution key for dedup against outcomes/incidents. */\n  execution_id: string | null;\n  completed_at: string | null;\n  commit_ts: string | null;\n  /**\n   * Whether the deploy completed inside [from,to]. Absent (undefined) in unit\n   * fixtures ⇒ treated as in-window. `t`/`f` tolerated (pg boolean text form).\n   */\n  in_window?: boolean | string | null;\n}\n\n/** Raw post-deploy outcome marker row (from `deployment_outcomes`, in-window). */\nexport interface OutcomeRow {\n  environment: string | null;\n  outcome: 'failed' | 'restored' | string;\n  /** Execution the user marked — dedup key against incident-correlated deploys. */\n  execution_id: string | null;\n}\n\n/** Production restored-incident pair: recovery time + the deploy's completion. */\nexport interface MttrPairRow {\n  restored_at: string | null;\n  deployed_at: string | null;\n  /** Execution id — lets incident precedence override the manual outcome per deploy. */\n  execution_id: string | null;\n}\n\n/**\n * Raw incident row (from `incidents`, opened in-window). Correlated in JS to the\n * most recent successful deploy to `environment` within DORA_INCIDENT_WINDOW_HOURS\n * → an automated post-deploy failure (CFR) + real recovery time (MTTR).\n */\nexport interface IncidentRow {\n  environment: string;\n  opened_at: string | null;\n  resolved_at: string | null;\n}\n\n/** Coverage counts: registered pipelines vs those that actually deployed. */\nexport interface CoverageRow {\n  registered: number | string | null;\n  deploying: number | string | null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/api/reporting/types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Public result shapes for the reporting service.\n *\n * Split out of reporting-service.ts purely for size: these are data contracts\n * with no behaviour. reporting-service.ts re-exports them, so the\n * `@pipeline-builder/pipeline-data` public surface is unchanged.\n */\n\nexport interface ExecutionCount {\n  id: string;\n  project: string;\n  organization: string;\n  pipelineName: string | null;\n  total: number;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  firstExecution: string | null;\n  lastExecution: string | null;\n}\n\nexport interface TimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  successPct: number;\n}\n\nexport interface DurationStats {\n  id: string;\n  project: string;\n  pipelineName: string | null;\n  avgMs: number;\n  minMs: number;\n  maxMs: number;\n  p95Ms: number;\n  executions: number;\n}\n\nexport interface PipelineExecution {\n  executionId: string;\n  /** Rolled-up terminal status: succeeded | failed | canceled | in-progress. */\n  status: string;\n  startedAt: string | null;\n  endedAt: string | null;\n  durationMs: number | null;\n  /** First failing stage/action for the execution (null when it didn't fail). */\n  failingStage: string | null;\n  failingAction: string | null;\n}\n\nexport interface StageFailure {\n  stageName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\nexport interface StageBottleneck {\n  id: string;\n  pipelineName: string | null;\n  stageName: string;\n  avgMs: number;\n  maxMs: number;\n}\n\nexport interface ActionFailure {\n  actionName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\nexport interface ErrorEntry {\n  errorPattern: string;\n  occurrences: number;\n  affectedPipelines: number;\n  lastSeen: string;\n}\n\nexport interface PluginSummary {\n  total: number;\n  active: number;\n  inactive: number;\n  /** Counts per sharing rung — one bucket per `visibility` value. */\n  public: number;\n  org: number;\n  private: number;\n  uniqueNames: number;\n}\n\nexport interface TypeComputeDistribution {\n  pluginType: string;\n  computeType: string;\n  count: number;\n}\n\nexport interface VersionCount {\n  name: string;\n  versionCount: number;\n  latestVersion: string;\n  hasDefault: boolean;\n}\n\nexport interface BuildTimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  successPct: number;\n}\n\nexport interface BuildDuration {\n  pluginName: string;\n  avgMs: number;\n  maxMs: number;\n  builds: number;\n}\n\n/**\n * Plugin runtime report filters. `publisher: null` selects own-org\n * (publisher-less) plugins; an omitted field doesn't filter.\n */\nexport interface PluginRuntimeFilter {\n  name?: string;\n  publisher?: string | null;\n  version?: string;\n}\n\n/** Per plugin version runtime stats over a window (terminal ACTION runs). */\nexport interface PluginRuntimeStats {\n  pluginPublisher: string | null;\n  pluginName: string;\n  pluginVersion: string;\n  runs: number;\n  succeeded: number;\n  failed: number;\n  /** 0–100, one decimal. */\n  successPct: number;\n  /** Null when no run in the group carried a duration. */\n  p50Ms: number | null;\n  p95Ms: number | null;\n  lastRun: string;\n}\n\n/** Cross-org 30-day aggregate for one `(publisher, name)` listing. */\nexport interface PluginRuntimeAggregate {\n  runs30d: number;\n  /** 0–1; null when there were no runs. */\n  successRate30d: number | null;\n  activeOrgCount30d: number;\n}\n\nexport interface BuildFailure {\n  pluginName: string;\n  errorMessage: string;\n  occurrences: number;\n  lastSeen: string;\n}\n\n/**\n * The DORA headline environment. Deployment to this literal env name is the\n * industry-standard DORA signal; MTTR is measured production-only, and this\n * environment's card is the summary shown at the top of the panel.\n */\n\n/** Per-org retention override row. Both nullable ⇒ global defaults. */\nexport interface ReportingRetentionSettings {\n  eventRetentionDays: number | null;\n  doraRetentionDays: number | null;\n  defaultEventRetentionDays: number;\n  defaultDoraRetentionDays: number;\n}\n\n/** Options for the reporting retention sweep. */\n/**\n * How a time-bucketed report slices its periods. Absent means UTC + Monday, which\n * is what every pre-timezone caller got — so an omitted value can never silently\n * change an existing report's boundaries.\n */\nexport interface BucketOptions {\n  /** IANA timezone the buckets are cut in (validated at the route). */\n  tz?: string;\n  /** Where the week starts. Postgres DATE_TRUNC is Monday-only, so `sunday`\n   *  shifts the boundary explicitly. */\n  weekStart?: 'monday' | 'sunday';\n}\n\nexport interface ReportingRetentionOptions {\n  /** Rows deleted per statement (default 1000). */\n  batchSize?: number;\n  /**\n   * The leader-locked run this sweep belongs to. Checked BETWEEN ORGS: aborted\n   * means the lock was lost (another pod is taking over) or the process is\n   * shutting down, and the remaining orgs are picked up next tick. Without it a\n   * long sweep kept deleting after another pod had already taken the lock.\n   */\n  run?: { signal: AbortSignal };\n  /** Max batches per table per org per tick (default 50); the rest defers to\n   *  the next tick so a huge backlog can't hold locks too long. */\n  maxBatchesPerTable?: number;\n  /** Fixed \"now\" for the whole sweep (default `new Date()`). */\n  now?: Date;\n  /**\n   * Resolve the org whose `dora_settings` retention governs `orgId`'s rows — its\n   * account ROOT. Retention is a billing entitlement synced onto the root only,\n   * so a team's rows must follow the root's (purchased) window, not the env\n   * default. Return `null` when the root can't be resolved: that org is SKIPPED\n   * this tick (never purged on a possibly-shorter window). Default: identity\n   * (every org is its own root — a flat deployment).\n   */\n  resolveRetentionOrgId?: (orgId: string) => Promise<string | null>;\n}\n\n/** Per-run purge tallies (also logged). */\nexport interface ReportingRetentionCounts {\n  /** Orgs swept this run. */\n  orgs: number;\n  /** Standard `pipeline_events` (environment IS NULL) rows purged. */\n  standardEvents: number;\n  /** DORA-source `pipeline_events` (environment IS NOT NULL) rows purged. */\n  doraEvents: number;\n  /** `deployment_outcomes` rows purged. */\n  deploymentOutcomes: number;\n  /** `incidents` rows purged. */\n  incidents: number;\n}\n\n/**\n * DORA performance band. `null` = insufficient data to classify (no\n * deployments/failures/lead-time sample in the window), so the UI shows a\n * neutral state rather than mislabeling an empty window as \"low\".\n */\nexport type DoraLevel = 'elite' | 'high' | 'medium' | 'low' | null;\n\n/** Optional scoping for {@link ReportingService.getDoraMetrics}. */\nexport interface DoraOptions {\n  /** Restrict to a single pipeline (per-pipeline DORA). */\n  pipelineId?: string;\n  /** Restrict to a single deploy environment (else all deploy environments). */\n  environment?: string;\n  /**\n   * Per-org incident→deploy correlation window override (hours). When set (a\n   * positive finite number), the incident correlation uses it instead of the\n   * global `DORA_INCIDENT_WINDOW_HOURS`. The route resolves this from the org's\n   * `dora_settings` row (see {@link ReportingService.getReportingSettings}) and\n   * passes it in; unset falls back to the env default.\n   */\n  incidentWindowHours?: number;\n  /** IANA timezone for the trend's buckets (see {@link BucketOptions}). */\n  tz?: string;\n  /** Week start for the trend's buckets. */\n  weekStart?: 'monday' | 'sunday';\n}\n\n/**\n * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`\n * is the incident→deploy correlation window; `eventRetentionDays` /\n * `doraRetentionDays` are the two retention-sweep windows. Each override\n * is `null` when unset (the paired `default*` field shows the env fallback applied).\n */\nexport interface ReportingSettings {\n  /** The org's stored correlation-window override in hours, or `null` when unset. */\n  incidentWindowHours: number | null;\n  /** The global env default applied when no override is stored. */\n  defaultWindowHours: number;\n  /** Standard-event retention override in days, or `null` when unset. */\n  eventRetentionDays: number | null;\n  /** DORA-source retention override in days, or `null` when unset. */\n  doraRetentionDays: number | null;\n  /** Global standard-event retention default applied when unset (days). */\n  defaultEventRetentionDays: number;\n  /** Global DORA-source retention default applied when unset (days). */\n  defaultDoraRetentionDays: number;\n}\n\n/** A partial reporting-settings write (7). Only provided fields are\n *  upserted; omitted fields are left unchanged (an omitted retention field keeps\n *  its stored override / the global default). */\nexport interface ReportingSettingsPatch {\n  incidentWindowHours?: number;\n  eventRetentionDays?: number;\n  doraRetentionDays?: number;\n}\n\n/** One row of the org-admin incidents list (recent incidents + deploy correlation). */\nexport interface IncidentListItem {\n  incidentId: string;\n  environment: string;\n  severity: string;\n  openedAt: string | null;\n  resolvedAt: string | null;\n  createdAt: string | null;\n  /** True once the incident has a `resolved_at`. */\n  resolved: boolean;\n  /** The correlated deploy execution id (most recent successful deploy in-window), or null. */\n  correlatedExecutionId: string | null;\n  /** That deploy's completion instant, or null when uncorrelated. */\n  deployCompletedAt: string | null;\n}\n\n/** Result of the wiring-test dry-run correlation ({@link ReportingService.testIncidentCorrelation}). */\nexport interface IncidentTestResult {\n  environment: string;\n  /** The synthetic incident's openedAt (now, ISO). */\n  openedAt: string;\n  /** The effective correlation window used. */\n  windowHours: number;\n  /** Whether a recent successful deploy to `environment` correlated. */\n  correlated: boolean;\n  /** The correlated deploy execution id, or null. */\n  executionId: string | null;\n  /** That deploy's completion instant, or null. */\n  deployCompletedAt: string | null;\n}\n\n// DORA performance bands (thresholds from the DORA/Accelerate reports). Each\n// helper returns `null` when there's no sample to classify.\n/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */\n\n/**\n * DORA metrics over a [from,to] window, org-scoped (single-org or rollup subtree).\n *\n * DEPLOY-BASIS — every metric derives from real DEPLOY-STAGE executions, i.e.\n * `pipeline_events` rows with `event_type='STAGE'` and a non-null `environment`\n * (the forwarder sets `environment` only for the stages a user declared in\n * `pb.deploys`). A CI-only build/test pipeline with no deploy stage produces NO\n * DORA data — there is no run-based fallback. The panel is empty until deployed\n * pipelines re-synth with the new deploy tags and start emitting deploy events.\n *\n * `production` is the headline environment; MTTR is measured production-only.\n */\nexport interface DoraMetrics {\n  /** The [from,to] window echoed back (deploy `completed_at` range). */\n  window: { from: string; to: string };\n  /** The scoping applied (echoed for the UI); `null` when unscoped. */\n  filters: { pipelineId: string | null; environment: string | null };\n  /** The headline environment name (`production`). */\n  headline: string;\n  /** Per-environment DF / CFR / lead time. Sorted headline-first, then A→Z. */\n  environments: DoraEnvMetrics[];\n  /**\n   * Mean Time To Restore — PRODUCTION-ONLY, from `deployment_outcomes`.\n   * `median(restored.at − deployed.completed_at)` over restored production\n   * incidents (deltas clamped ≥0). `incidents` counts production deploys marked\n   * failed; `restored` counts those that recovered; `medianSeconds` is null when\n   * no restored incident has a resolvable deploy time.\n   */\n  meanTimeToRestore: {\n    incidents: number;\n    restored: number;\n    medianSeconds: number | null;\n    /** 90th/95th percentile recovery, over the same sample as the median. The\n     *  median alone hides the long tail that actually defines an outage's cost;\n     *  `null` when no recovery gap was observed. */\n    p90Seconds: number | null;\n    p95Seconds: number | null;\n    level: DoraLevel;\n  };\n  /**\n   * Coverage reconciliation — registered pipelines with no observed deploy in\n   * the window. A high `withoutDeploys` count means DORA is blind to most of the\n   * fleet (pipelines that haven't re-synthed with deploy tags, or don't deploy).\n   */\n  coverage: {\n    /** Pipelines in the registry (org-scoped). */\n    registered: number;\n    /** Registered pipelines with ≥1 deploy-stage execution in the window. */\n    deploying: number;\n    /** registered − deploying (clamped ≥0). */\n    withoutDeploys: number;\n  };\n}\n\n/** Per-environment DORA metrics (deployment frequency, CFR, lead time). */\nexport interface DoraEnvMetrics {\n  environment: string;\n  /** Deployment Frequency — successful deploy-stage executions for this env. */\n  deploymentFrequency: {\n    deployments: number;\n    perDay: number;\n    level: DoraLevel;\n  };\n  /**\n   * Change Failure Rate — two-class:\n   * `(deployTimeFailures + postDeployFailures) / attempts`.\n   * - `deployTimeFailures` — deploy stage `result=failed` (from events).\n   * - `postDeployFailures` — a successful deploy later marked failed in prod\n   *   (from `deployment_outcomes`).\n   * - `attempts` — all terminal deploy-stage attempts (succeeded + failed).\n   */\n  changeFailureRate: {\n    rate: number;\n    deployTimeFailures: number;\n    postDeployFailures: number;\n    attempts: number;\n    level: DoraLevel;\n  };\n  /**\n   * Lead Time — MEASURED: `median(deploy_completed − oldest_commit_time)` over\n   * successful deploys with a resolvable commit timestamp (deltas clamped ≥0).\n   * `medianSeconds` is `null` (= unknown) when no successful deploy in this env\n   * carried a `commit_timestamp`. The old median-run-duration proxy is removed.\n   *\n   * `p90Seconds`/`p95Seconds` come from the same sample. The level is scored off\n   * the MEDIAN only, so adding the tails cannot move a team's DORA band.\n   */\n  leadTime: {\n    /** Successful deploys with a resolvable commit time (the median sample). */\n    deployments: number;\n    medianSeconds: number | null;\n    p90Seconds: number | null;\n    p95Seconds: number | null;\n    level: DoraLevel;\n  };\n}\n\n/** One interval bucket of the DORA trend (deploy frequency + change failure). */\nexport interface DoraTrendPoint {\n  /** Bucket start (DATE_TRUNC of the deploy `completed_at`), ISO text. */\n  period: string;\n  /** Successful deploy-stage executions in the bucket. */\n  deployments: number;\n  /** Failed deploy-stage executions in the bucket. */\n  failed: number;\n  /** succeeded + failed in the bucket (deploy attempts). */\n  total: number;\n  /** failed/total as a percent (0 when total is 0). Deploy-time CFR only. */\n  changeFailurePct: number;\n}\n\n/** Per-stage build-health metrics for one pipeline over a window. */\nexport interface BuildHealthStage {\n  stage: string;\n  /** Terminal stage runs (succeeded + failed) in the window. */\n  runs: number;\n  successes: number;\n  failures: number;\n  /** successes / runs as a percent (0 when runs is 0). */\n  successRate: number;\n  /** Duration percentiles over the stage's terminal runs; null when no durations. */\n  p50Ms: number | null;\n  p90Ms: number | null;\n  p99Ms: number | null;\n}\n\n/**\n * Per-pipeline build-health breakdown. Standard reporting (NOT\n * `advanced_reporting`-gated) — per-stage success rate + timing percentiles, with\n * totals summed across stages.\n */\nexport interface BuildHealth {\n  stages: BuildHealthStage[];\n  totals: { runs: number; failures: number; failureRate: number };\n}\n\n/** Post-deploy incident marker accepted by `ReportingService.recordIncident`. */\nexport interface IncidentInput {\n  incidentId: string;\n  environment: string;\n  openedAt: string;\n  resolvedAt?: string;\n  severity: string;\n}\n\n/** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */\nexport interface IngestEvent {\n  /** Stable pipeline id the events Lambda read from the `pb.pipeline-id`\n   *  tag (= the platform pipelineId). The registry join key. */\n  pipelineId: string;\n  eventSource: 'codepipeline' | 'codebuild' | 'plugin-build';\n  eventType: 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason (Action events). */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  /** Source commit id of the change being shipped (DORA deploy attribution). */\n  commitSha?: string;\n  /** Source ref/branch (DORA deploy attribution). */\n  commitRef?: string;\n  /** Deploy target (e.g. \"production\"). Its presence on a STAGE/ACTION event\n   *  marks a real deployment (derived server-side — there is no `isDeploy`). */\n  environment?: string;\n  /** Oldest unshipped commit timestamp (ISO 8601) for measured lead time. */\n  commitTimestamp?: string;\n  /** Number of commits shipped in this change (≥1). */\n  commitCount?: number;\n  detail?: Record<string, unknown>;\n}\n\n/**\n * Per-event metric descriptor emitted (via the {@link ReportingService.ingestEvents}\n * `onMetric` hook) for each REGISTERED terminal deploy/stage event, so the route\n * layer can fan them into Prometheus counters without pipeline-data importing\n * api-server's metrics registry. `result` is the terminal outcome; `environment`\n * is non-null only for a deploy-stage event.\n */\nexport interface IngestMetric {\n  pipelineId: string;\n  orgId: string;\n  stage: string;\n  environment: string | null;\n  result: 'succeeded' | 'failed';\n}\n\n/** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */\nexport interface IngestResult {\n  inserted: number;\n  skipped: number;\n  unregisteredPipelineIds: string[];\n  /**\n   * Every org with at least one row in this batch, deduped.\n   *\n   * Already computed for post-commit cache invalidation; surfaced because the\n   * ingest route needs the same set to push its live SSE frame. The stage-metric\n   * hook can't drive that fan-out: it only fires for STAGE events, so a batch of\n   * PIPELINE or BUILD events would land rows and push no frame at all.\n   */\n  affectedOrgs: string[];\n  /**\n   * Events dropped because the pipeline they name belongs to an org the caller\n   * may not write for. Surfaced so the route can log and count them: a non-zero\n   * value is either a misrouted producer or an attempt to inject events into\n   * another tenant's reports, and both need to be visible.\n   */\n  droppedForeignOrg: number;\n  /**\n   * Events dropped because their timestamps are impossible — dated in the future,\n   * or completing before they started. Rejected here rather than clamped later:\n   * a deploy whose duration or lead time is negative silently skews deployment\n   * frequency, change-failure rate and lead time for the whole org, and a clamp\n   * to 0 makes a bad clock look like an instant deploy.\n   */\n  droppedInvalidTime: number;\n}\n\n/**\n * Who is writing, for the ingest tenancy check.\n *\n * `/reports/events` resolves an event's org from the pipeline registry, so\n * without this a token holding `reporting:ingest` could post events for ANY\n * pipeline id and have them attributed to that pipeline's org — one org\n * injecting rows into another's reports.\n */\nexport interface IngestCaller {\n  /**\n   * Org ids this caller may write events for: its own, plus descendant teams.\n   * Resolved by the route. An event whose pipeline belongs to anything else is\n   * dropped.\n   */\n  allowedOrgIds: readonly string[];\n  /**\n   * A verified INTERNAL service principal (the plugin service posts plugin-build\n   * events for every tenant). Such callers are exempt: they hold a signed\n   * service key no external client can mint, and they legitimately write\n   * cross-tenant. Never set this from anything a request body can influence.\n   */\n  crossTenant?: boolean;\n}\n\n/**\n * One org's ingestion-health row as READ back by the Reports UI. The\n * AWS events Lambda writes it; this is the shape that lets the UI tell\n * \"ingestion is healthy, there were simply no deploys in the range\" apart from\n * \"we haven't heard from the ingest pipeline since X\".\n *\n * `null` from {@link ReportingService.getIngestHealth} means the deployment has\n * NEVER reported — not \"stale\". The two must not be conflated: a fresh install\n * (or one whose forwarder was never wired up) has no heartbeat at all, and\n * calling that \"stale\" would invent a regression that never happened.\n */\nexport interface IngestHealthStatus {\n  /** When the forwarder last posted a heartbeat (its own clock, ISO 8601). */\n  updatedAt: string;\n  /** Timestamp of the newest event it had forwarded, or null if it has seen none. */\n  lastEventAt: string | null;\n  /** Cumulative events forwarded, or null when the forwarder doesn't report it. */\n  forwarded: number | null;\n  /** Cumulative events DROPPED (non-zero ⇒ data loss upstream of the reports). */\n  dropped: number | null;\n}\n\n\n/**\n * Read-only reporting service for pipeline execution and plugin inventory aggregations.\n * Does not extend CrudService — reports are aggregate queries, not entity CRUD.\n *\n * All queries are cached in-memory to avoid repeated expensive SQL aggregations:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL\n * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL\n */\n\n/**\n * Internal row shapes for the DORA queries. Exported because ./dora.ts consumes\n * them; not part of the package's public surface (reporting-service.ts\n * re-exports this module wholesale, which is a deliberate simplification — these\n * describe query results, not API contracts).\n */\nexport interface DeployRow {\n  environment: string;\n  status: 'SUCCEEDED' | 'FAILED' | string;\n  /** Deploy execution id — the attribution key for dedup against outcomes/incidents. */\n  execution_id: string | null;\n  completed_at: string | null;\n  commit_ts: string | null;\n  /**\n   * Whether the deploy completed inside [from,to]. Absent (undefined) in unit\n   * fixtures ⇒ treated as in-window. `t`/`f` tolerated (pg boolean text form).\n   */\n  in_window?: boolean | string | null;\n}\n\n/** Raw post-deploy outcome marker row (from `deployment_outcomes`, in-window). */\nexport interface OutcomeRow {\n  environment: string | null;\n  outcome: 'failed' | 'restored' | string;\n  /** Execution the user marked — dedup key against incident-correlated deploys. */\n  execution_id: string | null;\n}\n\n/** Production restored-incident pair: recovery time + the deploy's completion. */\nexport interface MttrPairRow {\n  restored_at: string | null;\n  deployed_at: string | null;\n  /** Execution id — lets incident precedence override the manual outcome per deploy. */\n  execution_id: string | null;\n}\n\n/**\n * Raw incident row (from `incidents`, opened in-window). Correlated in JS to the\n * most recent successful deploy to `environment` within DORA_INCIDENT_WINDOW_HOURS\n * → an automated post-deploy failure (CFR) + real recovery time (MTTR).\n */\nexport interface IncidentRow {\n  environment: string;\n  opened_at: string | null;\n  resolved_at: string | null;\n}\n\n/** Coverage counts: registered pipelines vs those that actually deployed. */\nexport interface CoverageRow {\n  registered: number | string | null;\n  deploying: number | string | null;\n}\n"]}

package/lib/api/reporting-service.d.ts

@@ -1,5 +1,8 @@
-import type { ExecutionCount, TimeSeriesEntry, DurationStats, PipelineExecution, StageFailure, StageBottleneck, ActionFailure, ErrorEntry, PluginSummary, TypeComputeDistribution, VersionCount, BuildTimeSeriesEntry, BuildDuration, BuildFailure, PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats, ReportingRetentionOptions, ReportingRetentionCounts, DoraOptions, ReportingSettings, ReportingSettingsPatch, IncidentListItem, IncidentTestResult, DoraMetrics, DoraTrendPoint, BuildHealth, IncidentInput, IngestEvent, IngestMetric, IngestResult, IngestHealthStatus } from './reporting/types.js';
-export type { BuildHealth, BuildHealthStage, DoraEnvMetrics, DoraLevel, DoraMetrics, DoraOptions, DoraTrendPoint, IncidentInput, IncidentListItem, ReportingSettings, IncidentTestResult, IngestEvent, IngestHealthStatus, IngestMetric, IngestResult, PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats, ReportingRetentionCounts, ReportingRetentionOptions, ReportingRetentionSettings, ReportingSettingsPatch, } from './reporting/types.js';
+import { type AnalyticsScope } from './reporting/analytics-queries.js';
+import type { LastDeployedCommit } from './reporting/last-deploy.js';
+import type { ExecutionCount, TimeSeriesEntry, DurationStats, PipelineExecution, StageFailure, StageBottleneck, ActionFailure, ErrorEntry, PluginSummary, TypeComputeDistribution, VersionCount, BuildTimeSeriesEntry, BuildDuration, BuildFailure, PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats, ReportingRetentionOptions, ReportingRetentionCounts, DoraOptions, ReportingSettings, ReportingSettingsPatch, IncidentListItem, IncidentTestResult, DoraMetrics, DoraTrendPoint, BuildHealth, IncidentInput, IngestCaller, IngestEvent, IngestMetric, IngestResult, IngestHealthStatus, BucketOptions } from './reporting/types.js';
+export type { LastDeployedCommit } from './reporting/last-deploy.js';
+export type { BucketOptions, BuildHealth, BuildHealthStage, DoraEnvMetrics, DoraLevel, DoraMetrics, DoraOptions, DoraTrendPoint, IncidentInput, IncidentListItem, ReportingSettings, IncidentTestResult, IngestCaller, IngestEvent, IngestHealthStatus, IngestMetric, IngestResult, PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats, ReportingRetentionCounts, ReportingRetentionOptions, ReportingRetentionSettings, ReportingSettingsPatch, } from './reporting/types.js';
 export declare class ReportingService {
     #private;
     /** Invalidate all cached reports for an org (call after event ingest). */
@@ -10,7 +13,14 @@ export declare 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.
      */
-    ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void): Promise<IngestResult>;
+    ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void, caller?: IngestCaller): Promise<IngestResult>;
+    /**
+     * 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.
+     */
+    getLastDeployedCommit(pipelineId: string, environment?: string, caller?: IngestCaller): Promise<LastDeployedCommit>;
     /** Execution count per pipeline with status breakdown. */
     getExecutionCount(orgId: string, orgIds?: string[], range?: {
         from?: string;
@@ -37,7 +47,7 @@ export declare class ReportingService {
         to?: string;
     }, limit?: number): Promise<PipelineExecution[]>;
     /** Success rate over time for an org. */
-    getSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[]): Promise<TimeSeriesEntry[]>;
+    getSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[], bucket?: BucketOptions): Promise<TimeSeriesEntry[]>;
     /** Average duration per pipeline. */
     getAverageDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<DurationStats[]>;
     /** Stage failure heatmap — which stages fail most. */
@@ -91,7 +101,7 @@ export declare class ReportingService {
      * SHOULD enum these per-eventSource so we catch drift at ingest rather
      * than silently producing zero rows here. See findings N71.
      */
-    getBuildSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[]): Promise<BuildTimeSeriesEntry[]>;
+    getBuildSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[], bucket?: BucketOptions): Promise<BuildTimeSeriesEntry[]>;
     /** Build duration per plugin. Build activity report — rollup-aware. */
     getBuildDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<BuildDuration[]>;
     /** Build failures — top error messages. Build activity report — rollup-aware. */
@@ -191,5 +201,84 @@ export declare class ReportingService {
      * it establishes its own sysadmin scope. See ./reporting/retention-sweep.ts.
      */
     purgeExpiredReportingData(opts?: ReportingRetentionOptions): Promise<ReportingRetentionCounts>;
+    /** Per-pipeline delivery, worst first. */
+    getPipelineBreakdown(scope: AnalyticsScope, limit?: number): Promise<import("./reporting/analytics-queries.js").PipelineBreakdownRow[]>;
+    /** Failures by category, with the previous period's counts for the trend. */
+    getFailureAnalysis(scope: AnalyticsScope, previous?: {
+        from: string;
+        to: string;
+    }): Promise<{
+        categories: import("./reporting/analytics-queries.js").FailureCategoryRow[];
+        total: number;
+        actionableTotal: number;
+    }>;
+    /** Per-stage timings for one pipeline, slowest first. */
+    getStagePerformance(scope: AnalyticsScope, pipelineId: string, previous?: {
+        from: string;
+        to: string;
+    }): Promise<import("./reporting/analytics-queries.js").StagePerformanceRow[]>;
+    /** Build time by project and pipeline. Seconds, never money. */
+    getResourceConsumption(scope: AnalyticsScope, limit?: number): Promise<{
+        pipelines: import("./reporting/analytics-queries.js").ResourceRow[];
+        totalBuildSeconds: number;
+    }>;
+    /** Each commit's path across environments, and which ones stopped short. */
+    getPromotionView(scope: AnalyticsScope, productionEnv?: string, limit?: number): Promise<{
+        commits: import("./reporting/analytics-queries.js").PromotionRow[];
+        stuckCount: number;
+    }>;
+    /** Pipelines behind on a plugin, worst gap first (the DECLARED side). */
+    getOutdatedPlugins(scope: AnalyticsScope, limit?: number): Promise<{
+        rows: import("./reporting/analytics-queries.js").OutdatedPluginRow[];
+        behindPipelines: number;
+        majorBehind: number;
+    }>;
+    /** Open plugin vulnerabilities per pipeline (says declared vs deployed). */
+    getPluginVulnerabilities(scope: AnalyticsScope, limit?: number): Promise<{
+        rows: import("./reporting/analytics-queries.js").VulnerabilityRow[];
+        exposedPipelines: number;
+        criticalPipelines: number;
+    }>;
+    /** Adoption, creation source, and the deploy-tracking coverage denominator. */
+    getAdoption(scope: AnalyticsScope, timeSavedMinutes?: number | null): Promise<import("./reporting/analytics-queries.js").AdoptionSummary>;
+    /**
+     * 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.
+     */
+    getNeedsAttention(scope: AnalyticsScope, previous?: {
+        from: string;
+        to: string;
+    }): Promise<{
+        items: import("./reporting/needs-attention.js").AttentionItem[];
+        thresholds: import("./reporting/needs-attention.js").NeedsAttentionThresholds;
+        pipelinesEvaluated: number;
+    }>;
+    /**
+     * 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.
+     */
+    private attentionThresholds;
+    /**
+     * 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.
+     */
+    private timeSavedAssumption;
 }
 export declare const reportingService: ReportingService;