@pipeline-builder/pipeline-data 4.1.1 → 4.1.2

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

@@ -0,0 +1,469 @@
+/**
+ * Public result shapes for the reporting service.
+ *
+ * Split out of reporting-service.ts purely for size: these are data contracts
+ * with no behaviour. reporting-service.ts re-exports them, so the
+ * `@pipeline-builder/pipeline-data` public surface is unchanged.
+ */
+export interface ExecutionCount {
+    id: string;
+    project: string;
+    organization: string;
+    pipelineName: string | null;
+    total: number;
+    succeeded: number;
+    failed: number;
+    canceled: number;
+    firstExecution: string | null;
+    lastExecution: string | null;
+}
+export interface TimeSeriesEntry {
+    period: string;
+    succeeded: number;
+    failed: number;
+    canceled: number;
+    successPct: number;
+}
+export interface DurationStats {
+    id: string;
+    project: string;
+    pipelineName: string | null;
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+    p95Ms: number;
+    executions: number;
+}
+export interface PipelineExecution {
+    executionId: string;
+    /** Rolled-up terminal status: succeeded | failed | canceled | in-progress. */
+    status: string;
+    startedAt: string | null;
+    endedAt: string | null;
+    durationMs: number | null;
+    /** First failing stage/action for the execution (null when it didn't fail). */
+    failingStage: string | null;
+    failingAction: string | null;
+}
+export interface StageFailure {
+    stageName: string;
+    failures: number;
+    total: number;
+    failurePct: number;
+}
+export interface StageBottleneck {
+    id: string;
+    pipelineName: string | null;
+    stageName: string;
+    avgMs: number;
+    maxMs: number;
+}
+export interface ActionFailure {
+    actionName: string;
+    failures: number;
+    total: number;
+    failurePct: number;
+}
+export interface ErrorEntry {
+    errorPattern: string;
+    occurrences: number;
+    affectedPipelines: number;
+    lastSeen: string;
+}
+export interface PluginSummary {
+    total: number;
+    active: number;
+    inactive: number;
+    /** Counts per sharing rung — one bucket per `visibility` value. */
+    public: number;
+    org: number;
+    private: number;
+    uniqueNames: number;
+}
+export interface TypeComputeDistribution {
+    pluginType: string;
+    computeType: string;
+    count: number;
+}
+export interface VersionCount {
+    name: string;
+    versionCount: number;
+    latestVersion: string;
+    hasDefault: boolean;
+}
+export interface BuildTimeSeriesEntry {
+    period: string;
+    succeeded: number;
+    failed: number;
+    successPct: number;
+}
+export interface BuildDuration {
+    pluginName: string;
+    avgMs: number;
+    maxMs: number;
+    builds: number;
+}
+export interface BuildFailure {
+    pluginName: string;
+    errorMessage: string;
+    occurrences: number;
+    lastSeen: string;
+}
+/**
+ * The DORA headline environment. Deployment to this literal env name is the
+ * industry-standard DORA signal; MTTR is measured production-only, and this
+ * environment's card is the summary shown at the top of the panel.
+ */
+/** Per-org retention override row (Phase 7). Both nullable ⇒ global defaults. */
+export interface ReportingRetentionSettings {
+    eventRetentionDays: number | null;
+    doraRetentionDays: number | null;
+    defaultEventRetentionDays: number;
+    defaultDoraRetentionDays: number;
+}
+/** Options for the reporting retention sweep. */
+export interface ReportingRetentionOptions {
+    /** Rows deleted per statement (default 1000). */
+    batchSize?: number;
+    /** 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;
+    /** Fixed "now" for the whole sweep (default `new Date()`). */
+    now?: Date;
+}
+/** Per-run purge tallies (also logged). */
+export interface ReportingRetentionCounts {
+    /** Orgs swept this run. */
+    orgs: number;
+    /** Standard `pipeline_events` (environment IS NULL) rows purged. */
+    standardEvents: number;
+    /** DORA-source `pipeline_events` (environment IS NOT NULL) rows purged. */
+    doraEvents: number;
+    /** `deployment_outcomes` rows purged. */
+    deploymentOutcomes: number;
+    /** `incidents` rows purged. */
+    incidents: number;
+}
+/**
+ * DORA performance band. `null` = insufficient data to classify (no
+ * deployments/failures/lead-time sample in the window), so the UI shows a
+ * neutral state rather than mislabeling an empty window as "low".
+ */
+export type DoraLevel = 'elite' | 'high' | 'medium' | 'low' | null;
+/** Optional scoping for {@link ReportingService.getDoraMetrics}. */
+export interface DoraOptions {
+    /** Restrict to a single pipeline (per-pipeline DORA). */
+    pipelineId?: string;
+    /** Restrict to a single deploy environment (else all deploy environments). */
+    environment?: string;
+    /**
+     * Per-org incident→deploy correlation window override (hours). When set (a
+     * positive finite number), the incident correlation uses it instead of the
+     * global `DORA_INCIDENT_WINDOW_HOURS`. The route resolves this from the org's
+     * `dora_settings` row (see {@link ReportingService.getIncidentSettings}) and
+     * passes it in; unset falls back to the env default.
+     */
+    incidentWindowHours?: number;
+}
+/**
+ * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`
+ * (Phase 5b) is the incident→deploy correlation window; `eventRetentionDays` /
+ * `doraRetentionDays` (Phase 7) are the two retention-sweep windows. Each override
+ * is `null` when unset (the paired `default*` field shows the env fallback applied).
+ */
+export interface IncidentSettings {
+    /** The org's stored correlation-window override in hours, or `null` when unset. */
+    incidentWindowHours: number | null;
+    /** The global env default applied when no override is stored. */
+    defaultWindowHours: number;
+    /** Standard-event retention override in days, or `null` when unset (Phase 7). */
+    eventRetentionDays: number | null;
+    /** DORA-source retention override in days, or `null` when unset (Phase 7). */
+    doraRetentionDays: number | null;
+    /** Global standard-event retention default applied when unset (days). */
+    defaultEventRetentionDays: number;
+    /** Global DORA-source retention default applied when unset (days). */
+    defaultDoraRetentionDays: number;
+}
+/** A partial reporting-settings write (Phase 5b + 7). Only provided fields are
+ *  upserted; omitted fields are left unchanged (an omitted retention field keeps
+ *  its stored override / the global default). */
+export interface ReportingSettingsPatch {
+    incidentWindowHours?: number;
+    eventRetentionDays?: number;
+    doraRetentionDays?: number;
+}
+/** One row of the org-admin incidents list (recent incidents + deploy correlation). */
+export interface IncidentListItem {
+    incidentId: string;
+    environment: string;
+    severity: string;
+    openedAt: string | null;
+    resolvedAt: string | null;
+    createdAt: string | null;
+    /** True once the incident has a `resolved_at`. */
+    resolved: boolean;
+    /** The correlated deploy execution id (most recent successful deploy in-window), or null. */
+    correlatedExecutionId: string | null;
+    /** That deploy's completion instant, or null when uncorrelated. */
+    deployCompletedAt: string | null;
+}
+/** Result of the wiring-test dry-run correlation ({@link ReportingService.testIncidentCorrelation}). */
+export interface IncidentTestResult {
+    environment: string;
+    /** The synthetic incident's openedAt (now, ISO). */
+    openedAt: string;
+    /** The effective correlation window used. */
+    windowHours: number;
+    /** Whether a recent successful deploy to `environment` correlated. */
+    correlated: boolean;
+    /** The correlated deploy execution id, or null. */
+    executionId: string | null;
+    /** That deploy's completion instant, or null. */
+    deployCompletedAt: string | null;
+}
+/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */
+/**
+ * DORA metrics over a [from,to] window, org-scoped (single-org or rollup subtree).
+ *
+ * DEPLOY-BASIS — every metric derives from real DEPLOY-STAGE executions, i.e.
+ * `pipeline_events` rows with `event_type='STAGE'` and a non-null `environment`
+ * (the forwarder sets `environment` only for the stages a user declared in
+ * `pb.deploys`). A CI-only build/test pipeline with no deploy stage produces NO
+ * DORA data — there is no run-based fallback. The panel is empty until deployed
+ * pipelines re-synth with the new deploy tags and start emitting deploy events.
+ *
+ * `production` is the headline environment; MTTR is measured production-only.
+ */
+export interface DoraMetrics {
+    /** The [from,to] window echoed back (deploy `completed_at` range). */
+    window: {
+        from: string;
+        to: string;
+    };
+    /** The scoping applied (echoed for the UI); `null` when unscoped. */
+    filters: {
+        pipelineId: string | null;
+        environment: string | null;
+    };
+    /** The headline environment name (`production`). */
+    headline: string;
+    /** Per-environment DF / CFR / lead time. Sorted headline-first, then A→Z. */
+    environments: DoraEnvMetrics[];
+    /**
+     * Mean Time To Restore — PRODUCTION-ONLY, from `deployment_outcomes`.
+     * `median(restored.at − deployed.completed_at)` over restored production
+     * incidents (deltas clamped ≥0). `incidents` counts production deploys marked
+     * failed; `restored` counts those that recovered; `medianSeconds` is null when
+     * no restored incident has a resolvable deploy time.
+     */
+    meanTimeToRestore: {
+        incidents: number;
+        restored: number;
+        medianSeconds: number | null;
+        level: DoraLevel;
+    };
+    /**
+     * Coverage reconciliation — registered pipelines with no observed deploy in
+     * the window. A high `withoutDeploys` count means DORA is blind to most of the
+     * fleet (pipelines that haven't re-synthed with deploy tags, or don't deploy).
+     */
+    coverage: {
+        /** Pipelines in the registry (org-scoped). */
+        registered: number;
+        /** Registered pipelines with ≥1 deploy-stage execution in the window. */
+        deploying: number;
+        /** registered − deploying (clamped ≥0). */
+        withoutDeploys: number;
+    };
+}
+/** Per-environment DORA metrics (deployment frequency, CFR, lead time). */
+export interface DoraEnvMetrics {
+    environment: string;
+    /** Deployment Frequency — successful deploy-stage executions for this env. */
+    deploymentFrequency: {
+        deployments: number;
+        perDay: number;
+        level: DoraLevel;
+    };
+    /**
+     * Change Failure Rate — two-class:
+     * `(deployTimeFailures + postDeployFailures) / attempts`.
+     * - `deployTimeFailures` — deploy stage `result=failed` (from events).
+     * - `postDeployFailures` — a successful deploy later marked failed in prod
+     *   (from `deployment_outcomes`).
+     * - `attempts` — all terminal deploy-stage attempts (succeeded + failed).
+     */
+    changeFailureRate: {
+        rate: number;
+        deployTimeFailures: number;
+        postDeployFailures: number;
+        attempts: number;
+        level: DoraLevel;
+    };
+    /**
+     * Lead Time — MEASURED: `median(deploy_completed − oldest_commit_time)` over
+     * 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.
+     */
+    leadTime: {
+        /** Successful deploys with a resolvable commit time (the median sample). */
+        deployments: number;
+        medianSeconds: number | null;
+        level: DoraLevel;
+    };
+}
+/** One interval bucket of the DORA trend (deploy frequency + change failure). */
+export interface DoraTrendPoint {
+    /** Bucket start (DATE_TRUNC of the deploy `completed_at`), ISO text. */
+    period: string;
+    /** Successful deploy-stage executions in the bucket. */
+    deployments: number;
+    /** Failed deploy-stage executions in the bucket. */
+    failed: number;
+    /** succeeded + failed in the bucket (deploy attempts). */
+    total: number;
+    /** failed/total as a percent (0 when total is 0). Deploy-time CFR only. */
+    changeFailurePct: number;
+}
+/** Per-stage build-health metrics (Phase 6) for one pipeline over a window. */
+export interface BuildHealthStage {
+    stage: string;
+    /** Terminal stage runs (succeeded + failed) in the window. */
+    runs: number;
+    successes: number;
+    failures: number;
+    /** successes / runs as a percent (0 when runs is 0). */
+    successRate: number;
+    /** Duration percentiles over the stage's terminal runs; null when no durations. */
+    p50Ms: number | null;
+    p90Ms: number | null;
+    p99Ms: number | null;
+}
+/**
+ * Per-pipeline build-health breakdown (Phase 6). Standard reporting (NOT
+ * `advanced_reporting`-gated) — per-stage success rate + timing percentiles, with
+ * totals summed across stages.
+ */
+export interface BuildHealth {
+    stages: BuildHealthStage[];
+    totals: {
+        runs: number;
+        failures: number;
+        failureRate: number;
+    };
+}
+/** Post-deploy incident marker (Phase 5) accepted by `ReportingService.recordIncident`. */
+export interface IncidentInput {
+    incidentId: string;
+    environment: string;
+    openedAt: string;
+    resolvedAt?: string;
+    severity: string;
+}
+/** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */
+export interface IngestEvent {
+    /** Stable pipeline id the events Lambda read from the `pb.pipeline-id`
+     *  tag (= the platform pipelineId). The registry join key. */
+    pipelineId: string;
+    eventSource: 'codepipeline' | 'codebuild' | 'plugin-build';
+    eventType: 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';
+    status: string;
+    executionId?: string;
+    stageName?: string;
+    actionName?: string;
+    /** Human-readable failure reason (Action events). */
+    errorMessage?: string;
+    startedAt?: string;
+    completedAt?: string;
+    durationMs?: number;
+    /** Source commit id of the change being shipped (DORA deploy attribution). */
+    commitSha?: string;
+    /** Source ref/branch (DORA deploy attribution). */
+    commitRef?: string;
+    /** Deploy target (e.g. "production"). Its presence on a STAGE/ACTION event
+     *  marks a real deployment (derived server-side — there is no `isDeploy`). */
+    environment?: string;
+    /** Oldest unshipped commit timestamp (ISO 8601) for measured lead time. */
+    commitTimestamp?: string;
+    /** Number of commits shipped in this change (≥1). */
+    commitCount?: number;
+    detail?: Record<string, unknown>;
+}
+/**
+ * Per-event metric descriptor emitted (via the {@link ReportingService.ingestEvents}
+ * `onMetric` hook) for each REGISTERED terminal deploy/stage event, so the route
+ * layer can fan them into Prometheus counters without pipeline-data importing
+ * api-server's metrics registry. `result` is the terminal outcome; `environment`
+ * is non-null only for a deploy-stage event.
+ */
+export interface IngestMetric {
+    pipelineId: string;
+    orgId: string;
+    stage: string;
+    environment: string | null;
+    result: 'succeeded' | 'failed';
+}
+/** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */
+export interface IngestResult {
+    inserted: number;
+    skipped: number;
+    unregisteredPipelineIds: string[];
+}
+/**
+ * Read-only reporting service for pipeline execution and plugin inventory aggregations.
+ * Does not extend CrudService — reports are aggregate queries, not entity CRUD.
+ *
+ * All queries are cached in-memory to avoid repeated expensive SQL aggregations:
+ * - Inventory queries (plugin summary/distribution/versions): 5 min TTL
+ * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL
+ */
+/**
+ * Internal row shapes for the DORA queries. Exported because ./dora.ts consumes
+ * them; not part of the package's public surface (reporting-service.ts
+ * re-exports this module wholesale, which is a deliberate simplification — these
+ * describe query results, not API contracts).
+ */
+export interface DeployRow {
+    environment: string;
+    status: 'SUCCEEDED' | 'FAILED' | string;
+    /** Deploy execution id — the attribution key for dedup against outcomes/incidents. */
+    execution_id: string | null;
+    completed_at: string | null;
+    commit_ts: string | null;
+    /**
+     * Whether the deploy completed inside [from,to]. Absent (undefined) in unit
+     * fixtures ⇒ treated as in-window. `t`/`f` tolerated (pg boolean text form).
+     */
+    in_window?: boolean | string | null;
+}
+/** Raw post-deploy outcome marker row (from `deployment_outcomes`, in-window). */
+export interface OutcomeRow {
+    environment: string | null;
+    outcome: 'failed' | 'restored' | string;
+    /** Execution the user marked — dedup key against incident-correlated deploys. */
+    execution_id: string | null;
+}
+/** Production restored-incident pair: recovery time + the deploy's completion. */
+export interface MttrPairRow {
+    restored_at: string | null;
+    deployed_at: string | null;
+    /** Execution id — lets incident precedence override the manual outcome per deploy. */
+    execution_id: string | null;
+}
+/**
+ * Raw incident row (from `incidents`, opened in-window). Correlated in JS to the
+ * most recent successful deploy to `environment` within DORA_INCIDENT_WINDOW_HOURS
+ * → an automated post-deploy failure (CFR) + real recovery time (MTTR).
+ */
+export interface IncidentRow {
+    environment: string;
+    opened_at: string | null;
+    resolved_at: string | null;
+}
+/** Coverage counts: registered pipelines vs those that actually deployed. */
+export interface CoverageRow {
+    registered: number | string | null;
+    deploying: number | string | null;
+}

package/lib/api/reporting/types.js

@@ -0,0 +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\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 (Phase 7). Both nullable ⇒ global defaults. */\nexport interface ReportingRetentionSettings {\n  eventRetentionDays: number | null;\n  doraRetentionDays: number | null;\n  defaultEventRetentionDays: number;\n  defaultDoraRetentionDays: number;\n}\n\n/** Options for the reporting retention sweep. */\nexport interface ReportingRetentionOptions {\n  /** Rows deleted per statement (default 1000). */\n  batchSize?: number;\n  /** Max batches per table per org per tick (default 50); the rest defers to\n   *  the next tick so a huge backlog can't hold locks too long. */\n  maxBatchesPerTable?: number;\n  /** Fixed \"now\" for the whole sweep (default `new Date()`). */\n  now?: Date;\n}\n\n/** Per-run purge tallies (also logged). */\nexport interface ReportingRetentionCounts {\n  /** Orgs swept this run. */\n  orgs: number;\n  /** Standard `pipeline_events` (environment IS NULL) rows purged. */\n  standardEvents: number;\n  /** DORA-source `pipeline_events` (environment IS NOT NULL) rows purged. */\n  doraEvents: number;\n  /** `deployment_outcomes` rows purged. */\n  deploymentOutcomes: number;\n  /** `incidents` rows purged. */\n  incidents: number;\n}\n\n/**\n * DORA performance band. `null` = insufficient data to classify (no\n * deployments/failures/lead-time sample in the window), so the UI shows a\n * neutral state rather than mislabeling an empty window as \"low\".\n */\nexport type DoraLevel = 'elite' | 'high' | 'medium' | 'low' | null;\n\n/** Optional scoping for {@link ReportingService.getDoraMetrics}. */\nexport interface DoraOptions {\n  /** Restrict to a single pipeline (per-pipeline DORA). */\n  pipelineId?: string;\n  /** Restrict to a single deploy environment (else all deploy environments). */\n  environment?: string;\n  /**\n   * Per-org incident→deploy correlation window override (hours). When set (a\n   * positive finite number), the incident correlation uses it instead of the\n   * global `DORA_INCIDENT_WINDOW_HOURS`. The route resolves this from the org's\n   * `dora_settings` row (see {@link ReportingService.getIncidentSettings}) and\n   * passes it in; unset falls back to the env default.\n   */\n  incidentWindowHours?: number;\n}\n\n/**\n * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`\n * (Phase 5b) is the incident→deploy correlation window; `eventRetentionDays` /\n * `doraRetentionDays` (Phase 7) are the two retention-sweep windows. Each override\n * is `null` when unset (the paired `default*` field shows the env fallback applied).\n */\nexport interface IncidentSettings {\n  /** The org's stored correlation-window override in hours, or `null` when unset. */\n  incidentWindowHours: number | null;\n  /** The global env default applied when no override is stored. */\n  defaultWindowHours: number;\n  /** Standard-event retention override in days, or `null` when unset (Phase 7). */\n  eventRetentionDays: number | null;\n  /** DORA-source retention override in days, or `null` when unset (Phase 7). */\n  doraRetentionDays: number | null;\n  /** Global standard-event retention default applied when unset (days). */\n  defaultEventRetentionDays: number;\n  /** Global DORA-source retention default applied when unset (days). */\n  defaultDoraRetentionDays: number;\n}\n\n/** A partial reporting-settings write (Phase 5b + 7). Only provided fields are\n *  upserted; omitted fields are left unchanged (an omitted retention field keeps\n *  its stored override / the global default). */\nexport interface ReportingSettingsPatch {\n  incidentWindowHours?: number;\n  eventRetentionDays?: number;\n  doraRetentionDays?: number;\n}\n\n/** One row of the org-admin incidents list (recent incidents + deploy correlation). */\nexport interface IncidentListItem {\n  incidentId: string;\n  environment: string;\n  severity: string;\n  openedAt: string | null;\n  resolvedAt: string | null;\n  createdAt: string | null;\n  /** True once the incident has a `resolved_at`. */\n  resolved: boolean;\n  /** The correlated deploy execution id (most recent successful deploy in-window), or null. */\n  correlatedExecutionId: string | null;\n  /** That deploy's completion instant, or null when uncorrelated. */\n  deployCompletedAt: string | null;\n}\n\n/** Result of the wiring-test dry-run correlation ({@link ReportingService.testIncidentCorrelation}). */\nexport interface IncidentTestResult {\n  environment: string;\n  /** The synthetic incident's openedAt (now, ISO). */\n  openedAt: string;\n  /** The effective correlation window used. */\n  windowHours: number;\n  /** Whether a recent successful deploy to `environment` correlated. */\n  correlated: boolean;\n  /** The correlated deploy execution id, or null. */\n  executionId: string | null;\n  /** That deploy's completion instant, or null. */\n  deployCompletedAt: string | null;\n}\n\n// DORA performance bands (thresholds from the DORA/Accelerate reports). Each\n// helper returns `null` when there's no sample to classify.\n/** Deployment frequency by deploys/day: elite ≥1/day, high ≥1/week, medium ≥1/month. */\n\n/**\n * DORA metrics over a [from,to] window, org-scoped (single-org or rollup subtree).\n *\n * DEPLOY-BASIS — every metric derives from real DEPLOY-STAGE executions, i.e.\n * `pipeline_events` rows with `event_type='STAGE'` and a non-null `environment`\n * (the forwarder sets `environment` only for the stages a user declared in\n * `pb.deploys`). A CI-only build/test pipeline with no deploy stage produces NO\n * DORA data — there is no run-based fallback. The panel is empty until deployed\n * pipelines re-synth with the new deploy tags and start emitting deploy events.\n *\n * `production` is the headline environment; MTTR is measured production-only.\n */\nexport interface DoraMetrics {\n  /** The [from,to] window echoed back (deploy `completed_at` range). */\n  window: { from: string; to: string };\n  /** The scoping applied (echoed for the UI); `null` when unscoped. */\n  filters: { pipelineId: string | null; environment: string | null };\n  /** The headline environment name (`production`). */\n  headline: string;\n  /** Per-environment DF / CFR / lead time. Sorted headline-first, then A→Z. */\n  environments: DoraEnvMetrics[];\n  /**\n   * Mean Time To Restore — PRODUCTION-ONLY, from `deployment_outcomes`.\n   * `median(restored.at − deployed.completed_at)` over restored production\n   * incidents (deltas clamped ≥0). `incidents` counts production deploys marked\n   * failed; `restored` counts those that recovered; `medianSeconds` is null when\n   * no restored incident has a resolvable deploy time.\n   */\n  meanTimeToRestore: {\n    incidents: number;\n    restored: number;\n    medianSeconds: number | null;\n    level: DoraLevel;\n  };\n  /**\n   * Coverage reconciliation — registered pipelines with no observed deploy in\n   * the window. A high `withoutDeploys` count means DORA is blind to most of the\n   * fleet (pipelines that haven't re-synthed with deploy tags, or don't deploy).\n   */\n  coverage: {\n    /** Pipelines in the registry (org-scoped). */\n    registered: number;\n    /** Registered pipelines with ≥1 deploy-stage execution in the window. */\n    deploying: number;\n    /** registered − deploying (clamped ≥0). */\n    withoutDeploys: number;\n  };\n}\n\n/** Per-environment DORA metrics (deployment frequency, CFR, lead time). */\nexport interface DoraEnvMetrics {\n  environment: string;\n  /** Deployment Frequency — successful deploy-stage executions for this env. */\n  deploymentFrequency: {\n    deployments: number;\n    perDay: number;\n    level: DoraLevel;\n  };\n  /**\n   * Change Failure Rate — two-class:\n   * `(deployTimeFailures + postDeployFailures) / attempts`.\n   * - `deployTimeFailures` — deploy stage `result=failed` (from events).\n   * - `postDeployFailures` — a successful deploy later marked failed in prod\n   *   (from `deployment_outcomes`).\n   * - `attempts` — all terminal deploy-stage attempts (succeeded + failed).\n   */\n  changeFailureRate: {\n    rate: number;\n    deployTimeFailures: number;\n    postDeployFailures: number;\n    attempts: number;\n    level: DoraLevel;\n  };\n  /**\n   * Lead Time — MEASURED: `median(deploy_completed − oldest_commit_time)` over\n   * successful deploys with a resolvable commit timestamp (deltas clamped ≥0).\n   * `medianSeconds` is `null` (= unknown) when no successful deploy in this env\n   * carried a `commit_timestamp`. The old median-run-duration proxy is removed.\n   */\n  leadTime: {\n    /** Successful deploys with a resolvable commit time (the median sample). */\n    deployments: number;\n    medianSeconds: number | null;\n    level: DoraLevel;\n  };\n}\n\n/** One interval bucket of the DORA trend (deploy frequency + change failure). */\nexport interface DoraTrendPoint {\n  /** Bucket start (DATE_TRUNC of the deploy `completed_at`), ISO text. */\n  period: string;\n  /** Successful deploy-stage executions in the bucket. */\n  deployments: number;\n  /** Failed deploy-stage executions in the bucket. */\n  failed: number;\n  /** succeeded + failed in the bucket (deploy attempts). */\n  total: number;\n  /** failed/total as a percent (0 when total is 0). Deploy-time CFR only. */\n  changeFailurePct: number;\n}\n\n/** Per-stage build-health metrics (Phase 6) for one pipeline over a window. */\nexport interface BuildHealthStage {\n  stage: string;\n  /** Terminal stage runs (succeeded + failed) in the window. */\n  runs: number;\n  successes: number;\n  failures: number;\n  /** successes / runs as a percent (0 when runs is 0). */\n  successRate: number;\n  /** Duration percentiles over the stage's terminal runs; null when no durations. */\n  p50Ms: number | null;\n  p90Ms: number | null;\n  p99Ms: number | null;\n}\n\n/**\n * Per-pipeline build-health breakdown (Phase 6). Standard reporting (NOT\n * `advanced_reporting`-gated) — per-stage success rate + timing percentiles, with\n * totals summed across stages.\n */\nexport interface BuildHealth {\n  stages: BuildHealthStage[];\n  totals: { runs: number; failures: number; failureRate: number };\n}\n\n/** Post-deploy incident marker (Phase 5) accepted by `ReportingService.recordIncident`. */\nexport interface IncidentInput {\n  incidentId: string;\n  environment: string;\n  openedAt: string;\n  resolvedAt?: string;\n  severity: string;\n}\n\n/** Event payload accepted by `ReportingService.ingestEvents`. Mirrors the route's Zod shape. */\nexport interface IngestEvent {\n  /** Stable pipeline id the events Lambda read from the `pb.pipeline-id`\n   *  tag (= the platform pipelineId). The registry join key. */\n  pipelineId: string;\n  eventSource: 'codepipeline' | 'codebuild' | 'plugin-build';\n  eventType: 'PIPELINE' | 'STAGE' | 'ACTION' | 'BUILD';\n  status: string;\n  executionId?: string;\n  stageName?: string;\n  actionName?: string;\n  /** Human-readable failure reason (Action events). */\n  errorMessage?: string;\n  startedAt?: string;\n  completedAt?: string;\n  durationMs?: number;\n  /** Source commit id of the change being shipped (DORA deploy attribution). */\n  commitSha?: string;\n  /** Source ref/branch (DORA deploy attribution). */\n  commitRef?: string;\n  /** Deploy target (e.g. \"production\"). Its presence on a STAGE/ACTION event\n   *  marks a real deployment (derived server-side — there is no `isDeploy`). */\n  environment?: string;\n  /** Oldest unshipped commit timestamp (ISO 8601) for measured lead time. */\n  commitTimestamp?: string;\n  /** Number of commits shipped in this change (≥1). */\n  commitCount?: number;\n  detail?: Record<string, unknown>;\n}\n\n/**\n * Per-event metric descriptor emitted (via the {@link ReportingService.ingestEvents}\n * `onMetric` hook) for each REGISTERED terminal deploy/stage event, so the route\n * layer can fan them into Prometheus counters without pipeline-data importing\n * api-server's metrics registry. `result` is the terminal outcome; `environment`\n * is non-null only for a deploy-stage event.\n */\nexport interface IngestMetric {\n  pipelineId: string;\n  orgId: string;\n  stage: string;\n  environment: string | null;\n  result: 'succeeded' | 'failed';\n}\n\n/** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */\nexport interface IngestResult {\n  inserted: number;\n  skipped: number;\n  unregisteredPipelineIds: string[];\n}\n\n\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"]}