@pipeline-builder/pipeline-data 4.3.3 → 4.3.5

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

@@ -44,6 +44,8 @@ export interface PipelineExecution {
     /** First failing stage/action for the execution (null when it didn't fail). */
     failingStage: string | null;
     failingAction: string | null;
+    /** The first failure detail an event of the execution carried (`detail.failure`), or null. */
+    failure: unknown | null;
 }
 export interface StageFailure {
     stageName: string;
@@ -437,6 +439,35 @@ export interface IncidentInput {
     resolvedAt?: string;
     severity: string;
 }
+/** The persisted incident state as an audit row records it (scrubbed values, ISO instants). */
+export interface IncidentState {
+    environment: string;
+    openedAt: string | null;
+    resolvedAt: string | null;
+    severity: string;
+}
+/**
+ * What `ReportingService.recordIncident` did. `changed` is false for a sender's
+ * repeat-interval re-post of an unchanged alert, so the route records an audit
+ * row only for an incident that is new or actually moved (opened, re-opened,
+ * resolved, re-ranked) — a webhook re-firing every few hours must not bury the
+ * trail.
+ */
+export interface IncidentWrite {
+    /** The stored (scrubbed) incident id. */
+    incidentId: string;
+    created: boolean;
+    changed: boolean;
+    before: IncidentState | null;
+    after: IncidentState;
+}
+/** What `ReportingService.recordDeploymentOutcome` replaced: the prior marker of the same outcome, if any. */
+export interface DeploymentOutcomeWrite {
+    previous: {
+        at: string | null;
+        environment: string | null;
+    } | null;
+}
 /** 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`
@@ -464,6 +495,16 @@ export interface IngestEvent {
     commitTimestamp?: string;
     /** Number of commits shipped in this change (≥1). */
     commitCount?: number;
+    /**
+     * The EventBridge event `id` the forwarder received this state change as.
+     * AWS-assigned and unique per delivery source event, so it is the strongest
+     * dedup key there is (`event_source_event_idx`) and the thread an audit or
+     * DORA row follows back to the exact AWS event. Absent for plugin-build
+     * events, which have no EventBridge origin.
+     */
+    sourceEventId?: string;
+    /** The SQS message id it arrived in (folded into `detail.sourceMessageId`; not a column). */
+    sourceMessageId?: string;
     detail?: Record<string, unknown>;
 }
 /**
@@ -473,13 +514,35 @@ export interface IngestEvent {
  * api-server's metrics registry. `result` is the terminal outcome; `environment`
  * is non-null only for a deploy-stage event.
  */
-export interface IngestMetric {
+export interface StageIngestMetric {
+    kind: 'stage';
     pipelineId: string;
     orgId: string;
     stage: string;
     environment: string | null;
     result: 'succeeded' | 'failed';
 }
+/**
+ * One terminal CodeBuild ACTION's compute consumption (Phase 4, measurement
+ * half).
+ *
+ * `credits` is NULL rather than 0 when the action could not be measured — no
+ * declared start time, or a compute size the forwarder could not read. The
+ * distinction is the whole value of this metric: zero would make a coverage gap
+ * look like idleness, and a tier ladder re-derived against an unknown
+ * denominator is a repricing nobody can defend.
+ */
+export interface ComputeIngestMetric {
+    kind: 'compute';
+    pipelineId: string;
+    orgId: string;
+    computeType: string | null;
+    durationMs: number | null;
+    credits: number | null;
+}
+/** What the ingest fans out to its caller's metric registry. Discriminated, so
+ *  a new kind cannot be silently counted as a stage outcome. */
+export type IngestMetric = StageIngestMetric | ComputeIngestMetric;
 /** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */
 export interface IngestResult {
     inserted: number;
@@ -509,6 +572,16 @@ export interface IngestResult {
      * to 0 makes a bad clock look like an instant deploy.
      */
     droppedInvalidTime: number;
+    /**
+     * The registered pipeline ids whose events were dropped as FOREIGN-ORG — the
+     * tenancy refusal the route audits as a failure. Ids only (never the org they
+     * resolved to: that would tell a prober which tenant owns the pipeline).
+     */
+    foreignPipelineIds: string[];
+    /** Distinct execution ids of the rows that actually landed (the audit's correlation set). */
+    insertedExecutionIds: string[];
+    /** Distinct pipeline ids of the rows that actually landed. */
+    insertedPipelineIds: string[];
 }
 /**
  * Who is writing, for the ingest tenancy check.
@@ -532,6 +605,12 @@ export interface IngestCaller {
      * cross-tenant. Never set this from anything a request body can influence.
      */
     crossTenant?: boolean;
+    /**
+     * The access key (service-account / PAT key id) the ingest token was exchanged
+     * from, stamped on every row as `ingest_key_id` so a forged or misrouted row
+     * names the credential that wrote it. A key ID, never the secret.
+     */
+    keyId?: string;
 }
 /**
  * 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. */\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"]}
+//# 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  /** The first failure detail an event of the execution carried (`detail.failure`), or null. */\n  failure: unknown | 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/** The persisted incident state as an audit row records it (scrubbed values, ISO instants). */\nexport interface IncidentState {\n  environment: string;\n  openedAt: string | null;\n  resolvedAt: string | null;\n  severity: string;\n}\n\n/**\n * What `ReportingService.recordIncident` did. `changed` is false for a sender's\n * repeat-interval re-post of an unchanged alert, so the route records an audit\n * row only for an incident that is new or actually moved (opened, re-opened,\n * resolved, re-ranked) — a webhook re-firing every few hours must not bury the\n * trail.\n */\nexport interface IncidentWrite {\n  /** The stored (scrubbed) incident id. */\n  incidentId: string;\n  created: boolean;\n  changed: boolean;\n  before: IncidentState | null;\n  after: IncidentState;\n}\n\n/** What `ReportingService.recordDeploymentOutcome` replaced: the prior marker of the same outcome, if any. */\nexport interface DeploymentOutcomeWrite {\n  previous: { at: string | null; environment: string | null } | null;\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  /**\n   * The EventBridge event `id` the forwarder received this state change as.\n   * AWS-assigned and unique per delivery source event, so it is the strongest\n   * dedup key there is (`event_source_event_idx`) and the thread an audit or\n   * DORA row follows back to the exact AWS event. Absent for plugin-build\n   * events, which have no EventBridge origin.\n   */\n  sourceEventId?: string;\n  /** The SQS message id it arrived in (folded into `detail.sourceMessageId`; not a column). */\n  sourceMessageId?: string;\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 StageIngestMetric {\n  kind: 'stage';\n  pipelineId: string;\n  orgId: string;\n  stage: string;\n  environment: string | null;\n  result: 'succeeded' | 'failed';\n}\n\n/**\n * One terminal CodeBuild ACTION's compute consumption (Phase 4, measurement\n * half).\n *\n * `credits` is NULL rather than 0 when the action could not be measured — no\n * declared start time, or a compute size the forwarder could not read. The\n * distinction is the whole value of this metric: zero would make a coverage gap\n * look like idleness, and a tier ladder re-derived against an unknown\n * denominator is a repricing nobody can defend.\n */\nexport interface ComputeIngestMetric {\n  kind: 'compute';\n  pipelineId: string;\n  orgId: string;\n  computeType: string | null;\n  durationMs: number | null;\n  credits: number | null;\n}\n\n/** What the ingest fans out to its caller's metric registry. Discriminated, so\n *  a new kind cannot be silently counted as a stage outcome. */\nexport type IngestMetric = StageIngestMetric | ComputeIngestMetric;\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   * The registered pipeline ids whose events were dropped as FOREIGN-ORG — the\n   * tenancy refusal the route audits as a failure. Ids only (never the org they\n   * resolved to: that would tell a prober which tenant owns the pipeline).\n   */\n  foreignPipelineIds: string[];\n  /** Distinct execution ids of the rows that actually landed (the audit's correlation set). */\n  insertedExecutionIds: string[];\n  /** Distinct pipeline ids of the rows that actually landed. */\n  insertedPipelineIds: string[];\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   * The access key (service-account / PAT key id) the ingest token was exchanged\n   * from, stamped on every row as `ingest_key_id` so a forged or misrouted row\n   * names the credential that wrote it. A key ID, never the secret.\n   */\n  keyId?: 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"]}

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

@@ -1,8 +1,9 @@
 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';
+import { type AttentionRuleId } from './reporting/needs-attention.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, IncidentWrite, DeploymentOutcomeWrite, 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 type { BucketOptions, BuildHealth, BuildHealthStage, DoraEnvMetrics, DoraLevel, DoraMetrics, DoraOptions, DoraTrendPoint, DeploymentOutcomeWrite, IncidentInput, IncidentListItem, IncidentState, IncidentWrite, 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). */
@@ -128,7 +129,7 @@ export declare class ReportingService {
         outcome: 'failed' | 'restored';
         at: string;
         environment?: string;
-    }): Promise<void>;
+    }): Promise<DeploymentOutcomeWrite>;
     /**
      * Ingest a production incident from the org's incident tooling
      * (PagerDuty / Datadog / Alertmanager webhook). Idempotent — keyed on
@@ -139,7 +140,7 @@ export declare class ReportingService {
      * Runs under the caller's org context (RLS WITH CHECK); free-form fields are
      * AWS-id scrubbed at this persistence boundary like the other ingest paths.
      */
-    recordIncident(orgId: string, input: IncidentInput): Promise<void>;
+    recordIncident(orgId: string, input: IncidentInput): Promise<IncidentWrite>;
     /**
      * Read the per-org DORA settings. Returns the stored
      * `incidentWindowHours` override (or `null` when unset) plus the global env
@@ -255,6 +256,11 @@ export declare class ReportingService {
      * 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.
+     *
+     * A skipped rule is SAID, in `unavailableRules`. Absorbed silently, a failed
+     * vulnerable-pipelines read became an empty set — indistinguishable from "no
+     * pipeline runs a vulnerable plugin", which is the one false negative a security
+     * reader must never be handed. The composer turns it into a data-quality note.
      */
     getNeedsAttention(scope: AnalyticsScope, previous?: {
         from: string;
@@ -263,6 +269,7 @@ export declare class ReportingService {
         items: import("./reporting/needs-attention.js").AttentionItem[];
         thresholds: import("./reporting/needs-attention.js").NeedsAttentionThresholds;
         pipelinesEvaluated: number;
+        unavailableRules: AttentionRuleId[];
     }>;
     /**
      * The org's stored needs-attention thresholds, or `{}`.