@pipeline-builder/pipeline-data 4.3.11 → 4.3.12

package/lib/api/reporting/toolchain-runs.js

@@ -0,0 +1,268 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Toolchain RUN DATA (docs/plans/bootstrap-image-versioning.md §6, §7, §9):
+ * which managed toolchain release each `synth` / `self-mutation` action ran on,
+ * and the two queries built over those rows — the canary gate and the Affected
+ * view.
+ *
+ * WHERE THE RELEASE COMES FROM. pipeline-events is a Lambda in the CUSTOMER's
+ * account; everything it posts is customer-controlled, and the tags it reads
+ * are cached for 15 minutes. So the release is never read from the payload or
+ * a tag: the ingest joins the event to the PLATFORM's deployed step manifest
+ * for that pipeline (`pipeline_step_manifests`, written by the registry POST
+ * after a deploy) and takes the release from its `build-image` entry — the
+ * `pipeline-bootstrap` row, whose version IS the release (both halves share
+ * it). The manifest is replaced on every deploy, so it is the release the
+ * pipeline was deployed with when the event arrives.
+ *
+ * THE GATE IS ADVISORY. Outcomes are customer-reported (the events Lambda and
+ * its key live in the customer's account), so a canary org could forge them.
+ * Each org therefore counts for at most `ceil(N / M)` runs, so one org cannot
+ * satisfy the gate alone; the release comes from the platform's manifest; and
+ * the gate only informs a human — an override records a reason.
+ */
+import { BUILD_IMAGE_STEP_KEY } from '@pipeline-builder/api-core';
+import { sql } from 'drizzle-orm';
+import { executeRows } from '../../database/pg-result.js';
+/**
+ * CDK Pipelines' self-mutation action: a fixed stage and action name
+ * (`aws-cdk-lib/pipelines/lib/codepipeline/codepipeline.js`).
+ */
+export const SELF_MUTATION_STAGE = 'UpdatePipeline';
+export const SELF_MUTATION_ACTION = 'SelfMutate';
+/**
+ * The synth step's `stepKey` in the step manifest (`pluginStepLabel(null, …)`).
+ * The synth ACTION's name is a generated id, so it is identified by the
+ * manifest row carrying this key — the names the built pipeline really used.
+ */
+export const SYNTH_STEP_KEY = 'synth';
+/**
+ * The `build-image` entry's plugin: the release's bootstrap half. The entry is
+ * the manifest's non-step row under `step_key` {@link BUILD_IMAGE_STEP_KEY}
+ * (api-core `BUILD_IMAGE_MANIFEST_*`), and its `plugin_version` IS the release.
+ */
+export const BUILD_IMAGE_PLUGIN = 'pipeline-bootstrap';
+const RELEASE_VERSION_RE = /^\d+\.\d+\.\d+$/;
+/**
+ * Each pipeline's deployed toolchain, from its manifest rows. A pipeline
+ * whose manifest records no `build-image` entry (deployed before releases, or
+ * a placeholder bootstrap) has none, and its actions are not stamped. Only an
+ * OWN-ORG row (no publisher) counts: a managed name can never be a listing.
+ */
+export function deployedToolchainOf(rows) {
+    const release = new Map();
+    const synth = new Map();
+    for (const r of rows) {
+        if (r.stepKey === BUILD_IMAGE_STEP_KEY && r.pluginName === BUILD_IMAGE_PLUGIN && r.pluginPublisher === null
+            && typeof r.pluginVersion === 'string' && RELEASE_VERSION_RE.test(r.pluginVersion)) {
+            release.set(r.pipelineId, { orgId: r.orgId, releaseVersion: r.pluginVersion });
+        }
+        if (r.stepKey === SYNTH_STEP_KEY)
+            synth.set(r.pipelineId, { stageName: r.stageName, actionName: r.actionName });
+    }
+    const out = new Map();
+    for (const [pipelineId, r] of release)
+        out.set(pipelineId, { ...r, synth: synth.get(pipelineId) ?? null });
+    return out;
+}
+/**
+ * Which toolchain action (if any) an ACTION event is, given its pipeline's
+ * deployed toolchain. Names are compared post-scrub, as the manifest stores them.
+ */
+export function toolchainActionOf(event, deployed) {
+    if (event.eventType !== 'ACTION' || !deployed || !event.stageName || !event.actionName)
+        return null;
+    if (event.stageName === SELF_MUTATION_STAGE && event.actionName === SELF_MUTATION_ACTION)
+        return 'self-mutation';
+    if (deployed.synth && event.stageName === deployed.synth.stageName && event.actionName === deployed.synth.actionName)
+        return 'synth';
+    return null;
+}
+/** The terminal outcome of a status, or null for a non-terminal / non-judging one. */
+export function toolchainOutcomeOf(status) {
+    if (status === 'SUCCEEDED')
+        return 'succeeded';
+    if (status === 'FAILED')
+        return 'failed';
+    return null;
+}
+/** SQL: a stamped row's action (stamped rows are synth or self-mutation only). */
+const IS_SELF_MUTATION = sql `(e.stage_name = ${SELF_MUTATION_STAGE} AND e.action_name = ${SELF_MUTATION_ACTION})`;
+export const DEFAULT_CANARY_GATE = Object.freeze({
+    minRuns: 20,
+    minOrgs: 2,
+    maxFailurePointsAboveDefault: 5,
+});
+/** Round to 2 dp, so the numbers the console shows are stable. */
+function r2(n) {
+    return Math.round(n * 100) / 100;
+}
+function resolveParams(p) {
+    const merged = { ...DEFAULT_CANARY_GATE, ...(p ?? {}) };
+    const minRuns = Math.max(1, Math.floor(merged.minRuns));
+    const minOrgs = Math.max(1, Math.floor(merged.minOrgs));
+    const maxFailurePointsAboveDefault = Math.max(0, merged.maxFailurePointsAboveDefault);
+    if (![minRuns, minOrgs, maxFailurePointsAboveDefault].every(Number.isFinite))
+        return { ...DEFAULT_CANARY_GATE };
+    return { minRuns, minOrgs, maxFailurePointsAboveDefault };
+}
+/** The per-org contribution cap: ceil(N / M). */
+export function canaryPerOrgCap(params) {
+    return Math.ceil(params.minRuns / params.minOrgs);
+}
+/**
+ * The canary gate: at least N counted synth runs across at least M orgs, and a
+ * failure rate within T points of the current default's. Each org counts its
+ * most recent `ceil(N / M)` runs only — toward N AND toward the failure rate,
+ * so one org can neither satisfy N alone nor dominate the rate. Being BETTER
+ * than the default never fails the gate.
+ */
+export function evaluateCanaryGate(input) {
+    const params = resolveParams(input.params);
+    const perOrgCap = canaryPerOrgCap(params);
+    let countedRuns = 0;
+    let failures = 0;
+    let totalRuns = 0;
+    let orgs = 0;
+    for (const org of input.candidate) {
+        totalRuns += org.outcomes.length;
+        const counted = org.outcomes.slice(0, perOrgCap);
+        if (counted.length === 0)
+            continue;
+        orgs++;
+        countedRuns += counted.length;
+        failures += counted.filter((o) => o === 'failed').length;
+    }
+    const failureRate = countedRuns > 0 ? r2((failures / countedRuns) * 100) : null;
+    const baselineFailureRate = input.baseline.runs > 0 ? r2((input.baseline.failures / input.baseline.runs) * 100) : 0;
+    const pointsAboveDefault = failureRate === null ? null : r2(failureRate - baselineFailureRate);
+    const shortfalls = [];
+    if (countedRuns < params.minRuns)
+        shortfalls.push('runs');
+    if (orgs < params.minOrgs)
+        shortfalls.push('orgs');
+    if (pointsAboveDefault === null || pointsAboveDefault > params.maxFailurePointsAboveDefault)
+        shortfalls.push('failure-rate');
+    return {
+        passed: shortfalls.length === 0,
+        releaseVersion: input.releaseVersion,
+        params,
+        perOrgCap,
+        countedRuns,
+        totalRuns,
+        orgs,
+        failures,
+        failureRate,
+        baselineReleaseVersion: input.baseline.releaseVersion,
+        baselineRuns: input.baseline.runs,
+        baselineFailureRate,
+        pointsAboveDefault,
+        shortfalls,
+    };
+}
+// -----------------------------------------------------------------------------
+// Canary gate — the read
+// -----------------------------------------------------------------------------
+/**
+ * Evaluate the canary gate for `releaseVersion` against `baselineReleaseVersion`
+ * (the current platform default; null when none) from the stamped rows.
+ *
+ * Window: since the release was registered (`toolchain_release.created_at`),
+ * for both the candidate and the default, so the two rates are contemporaneous.
+ * Only terminal (SUCCEEDED / FAILED) SYNTH runs count; self-mutation is not
+ * part of the gate (§6 counts synth runs).
+ *
+ * Reads every org's rows: run it ELEVATED (the plugin service's toolchain tx
+ * is). The candidate read is bounded at `ceil(N/M)` rows per org.
+ */
+export async function readCanaryGate(db, releaseVersion, baselineReleaseVersion, params) {
+    const resolved = resolveParams(params);
+    const cap = canaryPerOrgCap(resolved);
+    const since = sql `(SELECT created_at FROM toolchain_release WHERE release_version = ${releaseVersion})`;
+    const candidate = await executeRows(db, sql `
+    SELECT org_id, status, total FROM (
+      SELECT e.org_id, e.status,
+             row_number() OVER (PARTITION BY e.org_id ORDER BY coalesce(e.completed_at, e.created_at) DESC, e.id) AS rn,
+             count(*) OVER (PARTITION BY e.org_id) AS total
+        FROM pipeline_events e
+       WHERE e.toolchain_release = ${releaseVersion}
+         AND e.event_type = 'ACTION' AND e.status IN ('SUCCEEDED', 'FAILED')
+         AND NOT ${IS_SELF_MUTATION}
+         AND e.created_at >= coalesce(${since}, '-infinity'::timestamptz)
+    ) x
+    WHERE rn <= ${cap}
+    ORDER BY org_id, rn
+  `);
+    const byOrg = new Map();
+    for (const row of candidate) {
+        const entry = byOrg.get(row.org_id) ?? { outcomes: [], total: Number(row.total) };
+        entry.outcomes.push(row.status === 'FAILED' ? 'failed' : 'succeeded');
+        byOrg.set(row.org_id, entry);
+    }
+    let baseline = { releaseVersion: baselineReleaseVersion, runs: 0, failures: 0 };
+    if (baselineReleaseVersion !== null && baselineReleaseVersion !== releaseVersion) {
+        const [b] = await executeRows(db, sql `
+      SELECT count(*) AS runs, count(*) FILTER (WHERE e.status = 'FAILED') AS failures
+        FROM pipeline_events e
+       WHERE e.toolchain_release = ${baselineReleaseVersion}
+         AND e.event_type = 'ACTION' AND e.status IN ('SUCCEEDED', 'FAILED')
+         AND NOT ${IS_SELF_MUTATION}
+         AND e.created_at >= coalesce(${since}, '-infinity'::timestamptz)
+    `);
+        baseline = { releaseVersion: baselineReleaseVersion, runs: Number(b?.runs ?? 0), failures: Number(b?.failures ?? 0) };
+    }
+    const result = evaluateCanaryGate({
+        releaseVersion,
+        candidate: [...byOrg.entries()].map(([orgId, e]) => ({ orgId, outcomes: e.outcomes })),
+        baseline,
+        params: resolved,
+    });
+    // The read is already capped per org, so the pre-cap total is the window count.
+    return { ...result, totalRuns: [...byOrg.values()].reduce((n, e) => n + e.total, 0) };
+}
+/**
+ * Pipelines whose DEPLOYED release is `releaseVersion` (their manifest's
+ * `build-image` entry) and whose LATEST terminal synth run failed, grouped by
+ * org — the console's Affected view and the "Notify affected owners" target
+ * set. A pipeline whose latest synth succeeded has healed and is not listed.
+ *
+ * Elevated read: it spans every org. Callers show the system-org operator
+ * counts, and notify each org about its own pipelines only.
+ */
+export async function readAffectedPipelines(db, releaseVersion) {
+    const rows = await executeRows(db, sql `
+    SELECT m.org_id, m.pipeline_id::text AS pipeline_id
+      FROM pipeline_step_manifests m
+      JOIN LATERAL (
+        SELECT e.status
+          FROM pipeline_events e
+         WHERE e.pipeline_id = m.pipeline_id
+           AND e.toolchain_release IS NOT NULL
+           AND e.event_type = 'ACTION' AND e.status IN ('SUCCEEDED', 'FAILED')
+           AND NOT ${IS_SELF_MUTATION}
+         ORDER BY coalesce(e.completed_at, e.created_at) DESC, e.created_at DESC
+         LIMIT 1
+      ) latest ON latest.status = 'FAILED'
+     WHERE m.step_key = ${BUILD_IMAGE_STEP_KEY} AND m.plugin_name = ${BUILD_IMAGE_PLUGIN} AND m.plugin_publisher IS NULL
+       AND m.plugin_version = ${releaseVersion}
+     ORDER BY m.org_id, m.pipeline_id
+  `);
+    const byOrg = new Map();
+    for (const r of rows) {
+        const ids = byOrg.get(r.org_id) ?? [];
+        if (!ids.includes(r.pipeline_id))
+            ids.push(r.pipeline_id);
+        byOrg.set(r.org_id, ids);
+    }
+    const orgs = [...byOrg.entries()].map(([orgId, pipelineIds]) => ({ orgId, pipelines: pipelineIds.length, pipelineIds }));
+    return { releaseVersion, totalPipelines: orgs.reduce((n, o) => n + o.pipelines, 0), orgs };
+}
+/** The current platform default (elevated read), or null. */
+export async function readPlatformDefaultRelease(db) {
+    const [row] = await executeRows(db, sql `
+    SELECT release_version FROM toolchain_platform_default WHERE singleton = true
+  `);
+    return row?.release_version ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolchain-runs.js","sources":["../../../src/api/reporting/toolchain-runs.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,EAAE,WAAW,EAAoB,MAAM,6BAA6B,CAAC;AAY5E;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AACpD,MAAM,CAAC,MAAM,oBAAoB,GAAG,YAAY,CAAC;AAEjD;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAEtC;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAEvD,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAuB7C;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAqC;IACvE,MAAM,OAAO,GAAG,IAAI,GAAG,EAAqD,CAAC;IAC7E,MAAM,KAAK,GAAG,IAAI,GAAG,EAAqD,CAAC;IAC3E,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,CAAC,OAAO,KAAK,oBAAoB,IAAI,CAAC,CAAC,UAAU,KAAK,kBAAkB,IAAI,CAAC,CAAC,eAAe,KAAK,IAAI;eACtG,OAAO,CAAC,CAAC,aAAa,KAAK,QAAQ,IAAI,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,CAAC;YACrF,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC,aAAa,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,IAAI,CAAC,CAAC,OAAO,KAAK,cAAc;YAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC;IAClH,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,GAAG,EAA6B,CAAC;IACjD,KAAK,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,IAAI,OAAO;QAAE,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;IAC3G,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAAmF,EACnF,QAAuC;IAEvC,IAAI,KAAK,CAAC,SAAS,KAAK,QAAQ,IAAI,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IACpG,IAAI,KAAK,CAAC,SAAS,KAAK,mBAAmB,IAAI,KAAK,CAAC,UAAU,KAAK,oBAAoB;QAAE,OAAO,eAAe,CAAC;IACjH,IAAI,QAAQ,CAAC,KAAK,IAAI,KAAK,CAAC,SAAS,KAAK,QAAQ,CAAC,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,KAAK,CAAC,UAAU;QAAE,OAAO,OAAO,CAAC;IACrI,OAAO,IAAI,CAAC;AACd,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,IAAI,MAAM,KAAK,WAAW;QAAE,OAAO,WAAW,CAAC;IAC/C,IAAI,MAAM,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IACzC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,kFAAkF;AAClF,MAAM,gBAAgB,GAAG,GAAG,CAAA,mBAAmB,mBAAmB,wBAAwB,oBAAoB,GAAG,CAAC;AAgBlH,MAAM,CAAC,MAAM,mBAAmB,GAA+B,MAAM,CAAC,MAAM,CAAC;IAC3E,OAAO,EAAE,EAAE;IACX,OAAO,EAAE,CAAC;IACV,4BAA4B,EAAE,CAAC;CAChC,CAAC,CAAC;AA6CH,kEAAkE;AAClE,SAAS,EAAE,CAAC,CAAS;IACnB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACnC,CAAC;AAED,SAAS,aAAa,CAAC,CAAwC;IAC7D,MAAM,MAAM,GAAG,EAAE,GAAG,mBAAmB,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;IACxD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,MAAM,4BAA4B,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,4BAA4B,CAAC,CAAC;IACtF,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,4BAA4B,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC;QAAE,OAAO,EAAE,GAAG,mBAAmB,EAAE,CAAC;IAChH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,4BAA4B,EAAE,CAAC;AAC5D,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,eAAe,CAAC,MAAqD;IACnF,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAsB;IACvD,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3C,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QAClC,SAAS,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC;QACjC,MAAM,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QACjD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACnC,IAAI,EAAE,CAAC;QACP,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;QAC9B,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,MAAM,CAAC;IAC3D,CAAC;IACD,MAAM,WAAW,GAAG,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,GAAG,WAAW,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAChF,MAAM,mBAAmB,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpH,MAAM,kBAAkB,GAAG,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,GAAG,mBAAmB,CAAC,CAAC;IAE/F,MAAM,UAAU,GAA0B,EAAE,CAAC;IAC7C,IAAI,WAAW,GAAG,MAAM,CAAC,OAAO;QAAE,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1D,IAAI,IAAI,GAAG,MAAM,CAAC,OAAO;QAAE,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,IAAI,kBAAkB,KAAK,IAAI,IAAI,kBAAkB,GAAG,MAAM,CAAC,4BAA4B;QAAE,UAAU,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAE7H,OAAO;QACL,MAAM,EAAE,UAAU,CAAC,MAAM,KAAK,CAAC;QAC/B,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,MAAM;QACN,SAAS;QACT,WAAW;QACX,SAAS;QACT,IAAI;QACJ,QAAQ;QACR,WAAW;QACX,sBAAsB,EAAE,KAAK,CAAC,QAAQ,CAAC,cAAc;QACrD,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAI;QACjC,mBAAmB;QACnB,kBAAkB;QAClB,UAAU;KACX,CAAC;AACJ,CAAC;AAED,gFAAgF;AAChF,yBAAyB;AACzB,gFAAgF;AAEhF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,EAAe,EACf,cAAsB,EACtB,sBAAqC,EACrC,MAAkC;IAElC,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IACtC,MAAM,KAAK,GAAG,GAAG,CAAA,qEAAqE,cAAc,GAAG,CAAC;IACxG,MAAM,SAAS,GAAG,MAAM,WAAW,CAA6D,EAAE,EAAE,GAAG,CAAA;;;;;;qCAMpE,cAAc;;mBAEhC,gBAAgB;wCACK,KAAK;;kBAE3B,GAAG;;GAElB,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,IAAI,GAAG,EAA2D,CAAC;IACjF,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;QAC5B,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAClF,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QACtE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI,QAAQ,GAAG,EAAE,cAAc,EAAE,sBAAsB,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;IAChF,IAAI,sBAAsB,KAAK,IAAI,IAAI,sBAAsB,KAAK,cAAc,EAAE,CAAC;QACjF,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,WAAW,CAAuD,EAAE,EAAE,GAAG,CAAA;;;qCAG1D,sBAAsB;;mBAExC,gBAAgB;wCACK,KAAK;KACxC,CAAC,CAAC;QACH,QAAQ,GAAG,EAAE,cAAc,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,EAAE,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC;IACxH,CAAC;IAED,MAAM,MAAM,GAAG,kBAAkB,CAAC;QAChC,cAAc;QACd,SAAS,EAAE,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;QACtF,QAAQ;QACR,MAAM,EAAE,QAAQ;KACjB,CAAC,CAAC;IACH,gFAAgF;IAChF,OAAO,EAAE,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;AACxF,CAAC;AAmBD;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,EAAe,EAAE,cAAsB;IACjF,MAAM,IAAI,GAAG,MAAM,WAAW,CAA0C,EAAE,EAAE,GAAG,CAAA;;;;;;;;;qBAS5D,gBAAgB;;;;0BAIX,oBAAoB,wBAAwB,kBAAkB;gCACxD,cAAc;;GAE3C,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC1C,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACrB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACtC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QAC1D,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,CAAC;IACD,MAAM,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC;IACzH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;AAC7F,CAAC;AAED,6DAA6D;AAC7D,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAAC,EAAe;IAC9D,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,WAAW,CAA8B,EAAE,EAAE,GAAG,CAAA;;GAEnE,CAAC,CAAC;IACH,OAAO,GAAG,EAAE,eAAe,IAAI,IAAI,CAAC;AACtC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Toolchain RUN DATA (docs/plans/bootstrap-image-versioning.md §6, §7, §9):\n * which managed toolchain release each `synth` / `self-mutation` action ran on,\n * and the two queries built over those rows — the canary gate and the Affected\n * view.\n *\n * WHERE THE RELEASE COMES FROM. pipeline-events is a Lambda in the CUSTOMER's\n * account; everything it posts is customer-controlled, and the tags it reads\n * are cached for 15 minutes. So the release is never read from the payload or\n * a tag: the ingest joins the event to the PLATFORM's deployed step manifest\n * for that pipeline (`pipeline_step_manifests`, written by the registry POST\n * after a deploy) and takes the release from its `build-image` entry — the\n * `pipeline-bootstrap` row, whose version IS the release (both halves share\n * it). The manifest is replaced on every deploy, so it is the release the\n * pipeline was deployed with when the event arrives.\n *\n * THE GATE IS ADVISORY. Outcomes are customer-reported (the events Lambda and\n * its key live in the customer's account), so a canary org could forge them.\n * Each org therefore counts for at most `ceil(N / M)` runs, so one org cannot\n * satisfy the gate alone; the release comes from the platform's manifest; and\n * the gate only informs a human — an override records a reason.\n */\n\nimport { BUILD_IMAGE_STEP_KEY } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { executeRows, type SqlExecutor } from '../../database/pg-result.js';\n\n// -----------------------------------------------------------------------------\n// Which actions are toolchain runs\n// -----------------------------------------------------------------------------\n\n/** The two toolchain actions a release is judged on. */\nexport type ToolchainAction = 'synth' | 'self-mutation';\n\n/** Terminal toolchain outcomes; anything else (STARTED, CANCELED, ABANDONED…) says nothing about the toolchain. */\nexport type ToolchainOutcome = 'succeeded' | 'failed';\n\n/**\n * CDK Pipelines' self-mutation action: a fixed stage and action name\n * (`aws-cdk-lib/pipelines/lib/codepipeline/codepipeline.js`).\n */\nexport const SELF_MUTATION_STAGE = 'UpdatePipeline';\nexport const SELF_MUTATION_ACTION = 'SelfMutate';\n\n/**\n * The synth step's `stepKey` in the step manifest (`pluginStepLabel(null, …)`).\n * The synth ACTION's name is a generated id, so it is identified by the\n * manifest row carrying this key — the names the built pipeline really used.\n */\nexport const SYNTH_STEP_KEY = 'synth';\n\n/**\n * The `build-image` entry's plugin: the release's bootstrap half. The entry is\n * the manifest's non-step row under `step_key` {@link BUILD_IMAGE_STEP_KEY}\n * (api-core `BUILD_IMAGE_MANIFEST_*`), and its `plugin_version` IS the release.\n */\nexport const BUILD_IMAGE_PLUGIN = 'pipeline-bootstrap';\n\nconst RELEASE_VERSION_RE = /^\\d+\\.\\d+\\.\\d+$/;\n\n/** A manifest row, as {@link deployedToolchainOf} reads it. */\nexport interface ToolchainManifestRow {\n  pipelineId: string;\n  orgId: string;\n  stageName: string;\n  actionName: string;\n  pluginPublisher: string | null;\n  pluginName: string | null;\n  pluginVersion: string | null;\n  stepKey?: string | null;\n}\n\n/** One pipeline's deployed toolchain, from its manifest. */\nexport interface DeployedToolchain {\n  orgId: string;\n  /** The release its `build-image` entry records. */\n  releaseVersion: string;\n  /** The synth action as the built pipeline names it; null when the manifest has no synth row. */\n  synth: { stageName: string; actionName: string } | null;\n}\n\n/**\n * Each pipeline's deployed toolchain, from its manifest rows. A pipeline\n * whose manifest records no `build-image` entry (deployed before releases, or\n * a placeholder bootstrap) has none, and its actions are not stamped. Only an\n * OWN-ORG row (no publisher) counts: a managed name can never be a listing.\n */\nexport function deployedToolchainOf(rows: readonly ToolchainManifestRow[]): Map<string, DeployedToolchain> {\n  const release = new Map<string, { orgId: string; releaseVersion: string }>();\n  const synth = new Map<string, { stageName: string; actionName: string }>();\n  for (const r of rows) {\n    if (r.stepKey === BUILD_IMAGE_STEP_KEY && r.pluginName === BUILD_IMAGE_PLUGIN && r.pluginPublisher === null\n      && typeof r.pluginVersion === 'string' && RELEASE_VERSION_RE.test(r.pluginVersion)) {\n      release.set(r.pipelineId, { orgId: r.orgId, releaseVersion: r.pluginVersion });\n    }\n    if (r.stepKey === SYNTH_STEP_KEY) synth.set(r.pipelineId, { stageName: r.stageName, actionName: r.actionName });\n  }\n  const out = new Map<string, DeployedToolchain>();\n  for (const [pipelineId, r] of release) out.set(pipelineId, { ...r, synth: synth.get(pipelineId) ?? null });\n  return out;\n}\n\n/**\n * Which toolchain action (if any) an ACTION event is, given its pipeline's\n * deployed toolchain. Names are compared post-scrub, as the manifest stores them.\n */\nexport function toolchainActionOf(\n  event: { eventType: string; stageName?: string | null; actionName?: string | null },\n  deployed: DeployedToolchain | undefined,\n): ToolchainAction | null {\n  if (event.eventType !== 'ACTION' || !deployed || !event.stageName || !event.actionName) return null;\n  if (event.stageName === SELF_MUTATION_STAGE && event.actionName === SELF_MUTATION_ACTION) return 'self-mutation';\n  if (deployed.synth && event.stageName === deployed.synth.stageName && event.actionName === deployed.synth.actionName) return 'synth';\n  return null;\n}\n\n/** The terminal outcome of a status, or null for a non-terminal / non-judging one. */\nexport function toolchainOutcomeOf(status: string): ToolchainOutcome | null {\n  if (status === 'SUCCEEDED') return 'succeeded';\n  if (status === 'FAILED') return 'failed';\n  return null;\n}\n\n/** SQL: a stamped row's action (stamped rows are synth or self-mutation only). */\nconst IS_SELF_MUTATION = sql`(e.stage_name = ${SELF_MUTATION_STAGE} AND e.action_name = ${SELF_MUTATION_ACTION})`;\n\n// -----------------------------------------------------------------------------\n// Canary gate (§6) — pure computation\n// -----------------------------------------------------------------------------\n\n/** The gate's thresholds (set on the console, Phase 5). */\nexport interface CanaryGateParams {\n  /** N: counted synth runs required. */\n  minRuns: number;\n  /** M: distinct orgs required. */\n  minOrgs: number;\n  /** T: the release's failure rate may exceed the default's by at most this many percentage points. */\n  maxFailurePointsAboveDefault: number;\n}\n\nexport const DEFAULT_CANARY_GATE: Readonly<CanaryGateParams> = Object.freeze({\n  minRuns: 20,\n  minOrgs: 2,\n  maxFailurePointsAboveDefault: 5,\n});\n\n/** One org's terminal synth outcomes on the candidate, NEWEST first. */\nexport interface OrgRuns {\n  orgId: string;\n  outcomes: readonly ToolchainOutcome[];\n}\n\nexport interface CanaryGateInput {\n  releaseVersion: string;\n  candidate: readonly OrgRuns[];\n  /** The current platform default's synth runs over the same window (uncapped). */\n  baseline: { releaseVersion: string | null; runs: number; failures: number };\n  params?: Partial<CanaryGateParams>;\n}\n\nexport type CanaryGateShortfall = 'runs' | 'orgs' | 'failure-rate';\n\n/** The gate's verdict and every number behind it — what the console shows. */\nexport interface CanaryGateResult {\n  passed: boolean;\n  releaseVersion: string;\n  params: CanaryGateParams;\n  /** ceil(N / M): the most runs any one org contributes. */\n  perOrgCap: number;\n  /** Runs counted toward N, after the per-org cap. */\n  countedRuns: number;\n  /** Every terminal synth run on the release, before the cap. */\n  totalRuns: number;\n  /** Distinct orgs with at least one counted run. */\n  orgs: number;\n  /** Failures among the counted runs. */\n  failures: number;\n  /** Percent (0–100) over the counted runs; null with none. */\n  failureRate: number | null;\n  baselineReleaseVersion: string | null;\n  baselineRuns: number;\n  /** Percent (0–100); 0 when the default has no runs in the window (the strict reading). */\n  baselineFailureRate: number;\n  /** failureRate − baselineFailureRate, in points; null with no counted runs. */\n  pointsAboveDefault: number | null;\n  /** Which thresholds were not met (empty when passed). */\n  shortfalls: CanaryGateShortfall[];\n}\n\n/** Round to 2 dp, so the numbers the console shows are stable. */\nfunction r2(n: number): number {\n  return Math.round(n * 100) / 100;\n}\n\nfunction resolveParams(p: Partial<CanaryGateParams> | undefined): CanaryGateParams {\n  const merged = { ...DEFAULT_CANARY_GATE, ...(p ?? {}) };\n  const minRuns = Math.max(1, Math.floor(merged.minRuns));\n  const minOrgs = Math.max(1, Math.floor(merged.minOrgs));\n  const maxFailurePointsAboveDefault = Math.max(0, merged.maxFailurePointsAboveDefault);\n  if (![minRuns, minOrgs, maxFailurePointsAboveDefault].every(Number.isFinite)) return { ...DEFAULT_CANARY_GATE };\n  return { minRuns, minOrgs, maxFailurePointsAboveDefault };\n}\n\n/** The per-org contribution cap: ceil(N / M). */\nexport function canaryPerOrgCap(params: Pick<CanaryGateParams, 'minRuns' | 'minOrgs'>): number {\n  return Math.ceil(params.minRuns / params.minOrgs);\n}\n\n/**\n * The canary gate: at least N counted synth runs across at least M orgs, and a\n * failure rate within T points of the current default's. Each org counts its\n * most recent `ceil(N / M)` runs only — toward N AND toward the failure rate,\n * so one org can neither satisfy N alone nor dominate the rate. Being BETTER\n * than the default never fails the gate.\n */\nexport function evaluateCanaryGate(input: CanaryGateInput): CanaryGateResult {\n  const params = resolveParams(input.params);\n  const perOrgCap = canaryPerOrgCap(params);\n  let countedRuns = 0;\n  let failures = 0;\n  let totalRuns = 0;\n  let orgs = 0;\n  for (const org of input.candidate) {\n    totalRuns += org.outcomes.length;\n    const counted = org.outcomes.slice(0, perOrgCap);\n    if (counted.length === 0) continue;\n    orgs++;\n    countedRuns += counted.length;\n    failures += counted.filter((o) => o === 'failed').length;\n  }\n  const failureRate = countedRuns > 0 ? r2((failures / countedRuns) * 100) : null;\n  const baselineFailureRate = input.baseline.runs > 0 ? r2((input.baseline.failures / input.baseline.runs) * 100) : 0;\n  const pointsAboveDefault = failureRate === null ? null : r2(failureRate - baselineFailureRate);\n\n  const shortfalls: CanaryGateShortfall[] = [];\n  if (countedRuns < params.minRuns) shortfalls.push('runs');\n  if (orgs < params.minOrgs) shortfalls.push('orgs');\n  if (pointsAboveDefault === null || pointsAboveDefault > params.maxFailurePointsAboveDefault) shortfalls.push('failure-rate');\n\n  return {\n    passed: shortfalls.length === 0,\n    releaseVersion: input.releaseVersion,\n    params,\n    perOrgCap,\n    countedRuns,\n    totalRuns,\n    orgs,\n    failures,\n    failureRate,\n    baselineReleaseVersion: input.baseline.releaseVersion,\n    baselineRuns: input.baseline.runs,\n    baselineFailureRate,\n    pointsAboveDefault,\n    shortfalls,\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Canary gate — the read\n// -----------------------------------------------------------------------------\n\n/**\n * Evaluate the canary gate for `releaseVersion` against `baselineReleaseVersion`\n * (the current platform default; null when none) from the stamped rows.\n *\n * Window: since the release was registered (`toolchain_release.created_at`),\n * for both the candidate and the default, so the two rates are contemporaneous.\n * Only terminal (SUCCEEDED / FAILED) SYNTH runs count; self-mutation is not\n * part of the gate (§6 counts synth runs).\n *\n * Reads every org's rows: run it ELEVATED (the plugin service's toolchain tx\n * is). The candidate read is bounded at `ceil(N/M)` rows per org.\n */\nexport async function readCanaryGate(\n  db: SqlExecutor,\n  releaseVersion: string,\n  baselineReleaseVersion: string | null,\n  params?: Partial<CanaryGateParams>,\n): Promise<CanaryGateResult> {\n  const resolved = resolveParams(params);\n  const cap = canaryPerOrgCap(resolved);\n  const since = sql`(SELECT created_at FROM toolchain_release WHERE release_version = ${releaseVersion})`;\n  const candidate = await executeRows<{ org_id: string; status: string; total: string | number }>(db, sql`\n    SELECT org_id, status, total FROM (\n      SELECT e.org_id, e.status,\n             row_number() OVER (PARTITION BY e.org_id ORDER BY coalesce(e.completed_at, e.created_at) DESC, e.id) AS rn,\n             count(*) OVER (PARTITION BY e.org_id) AS total\n        FROM pipeline_events e\n       WHERE e.toolchain_release = ${releaseVersion}\n         AND e.event_type = 'ACTION' AND e.status IN ('SUCCEEDED', 'FAILED')\n         AND NOT ${IS_SELF_MUTATION}\n         AND e.created_at >= coalesce(${since}, '-infinity'::timestamptz)\n    ) x\n    WHERE rn <= ${cap}\n    ORDER BY org_id, rn\n  `);\n  const byOrg = new Map<string, { outcomes: ToolchainOutcome[]; total: number }>();\n  for (const row of candidate) {\n    const entry = byOrg.get(row.org_id) ?? { outcomes: [], total: Number(row.total) };\n    entry.outcomes.push(row.status === 'FAILED' ? 'failed' : 'succeeded');\n    byOrg.set(row.org_id, entry);\n  }\n\n  let baseline = { releaseVersion: baselineReleaseVersion, runs: 0, failures: 0 };\n  if (baselineReleaseVersion !== null && baselineReleaseVersion !== releaseVersion) {\n    const [b] = await executeRows<{ runs: string | number; failures: string | number }>(db, sql`\n      SELECT count(*) AS runs, count(*) FILTER (WHERE e.status = 'FAILED') AS failures\n        FROM pipeline_events e\n       WHERE e.toolchain_release = ${baselineReleaseVersion}\n         AND e.event_type = 'ACTION' AND e.status IN ('SUCCEEDED', 'FAILED')\n         AND NOT ${IS_SELF_MUTATION}\n         AND e.created_at >= coalesce(${since}, '-infinity'::timestamptz)\n    `);\n    baseline = { releaseVersion: baselineReleaseVersion, runs: Number(b?.runs ?? 0), failures: Number(b?.failures ?? 0) };\n  }\n\n  const result = evaluateCanaryGate({\n    releaseVersion,\n    candidate: [...byOrg.entries()].map(([orgId, e]) => ({ orgId, outcomes: e.outcomes })),\n    baseline,\n    params: resolved,\n  });\n  // The read is already capped per org, so the pre-cap total is the window count.\n  return { ...result, totalRuns: [...byOrg.values()].reduce((n, e) => n + e.total, 0) };\n}\n\n// -----------------------------------------------------------------------------\n// Affected view (§9)\n// -----------------------------------------------------------------------------\n\nexport interface AffectedOrg {\n  orgId: string;\n  /** Pipelines in this org on the release whose latest synth failed. */\n  pipelines: number;\n  pipelineIds: string[];\n}\n\nexport interface AffectedPipelines {\n  releaseVersion: string;\n  totalPipelines: number;\n  orgs: AffectedOrg[];\n}\n\n/**\n * Pipelines whose DEPLOYED release is `releaseVersion` (their manifest's\n * `build-image` entry) and whose LATEST terminal synth run failed, grouped by\n * org — the console's Affected view and the \"Notify affected owners\" target\n * set. A pipeline whose latest synth succeeded has healed and is not listed.\n *\n * Elevated read: it spans every org. Callers show the system-org operator\n * counts, and notify each org about its own pipelines only.\n */\nexport async function readAffectedPipelines(db: SqlExecutor, releaseVersion: string): Promise<AffectedPipelines> {\n  const rows = await executeRows<{ org_id: string; pipeline_id: string }>(db, sql`\n    SELECT m.org_id, m.pipeline_id::text AS pipeline_id\n      FROM pipeline_step_manifests m\n      JOIN LATERAL (\n        SELECT e.status\n          FROM pipeline_events e\n         WHERE e.pipeline_id = m.pipeline_id\n           AND e.toolchain_release IS NOT NULL\n           AND e.event_type = 'ACTION' AND e.status IN ('SUCCEEDED', 'FAILED')\n           AND NOT ${IS_SELF_MUTATION}\n         ORDER BY coalesce(e.completed_at, e.created_at) DESC, e.created_at DESC\n         LIMIT 1\n      ) latest ON latest.status = 'FAILED'\n     WHERE m.step_key = ${BUILD_IMAGE_STEP_KEY} AND m.plugin_name = ${BUILD_IMAGE_PLUGIN} AND m.plugin_publisher IS NULL\n       AND m.plugin_version = ${releaseVersion}\n     ORDER BY m.org_id, m.pipeline_id\n  `);\n  const byOrg = new Map<string, string[]>();\n  for (const r of rows) {\n    const ids = byOrg.get(r.org_id) ?? [];\n    if (!ids.includes(r.pipeline_id)) ids.push(r.pipeline_id);\n    byOrg.set(r.org_id, ids);\n  }\n  const orgs = [...byOrg.entries()].map(([orgId, pipelineIds]) => ({ orgId, pipelines: pipelineIds.length, pipelineIds }));\n  return { releaseVersion, totalPipelines: orgs.reduce((n, o) => n + o.pipelines, 0), orgs };\n}\n\n/** The current platform default (elevated read), or null. */\nexport async function readPlatformDefaultRelease(db: SqlExecutor): Promise<string | null> {\n  const [row] = await executeRows<{ release_version: string }>(db, sql`\n    SELECT release_version FROM toolchain_platform_default WHERE singleton = true\n  `);\n  return row?.release_version ?? null;\n}\n"]}

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

@@ -540,9 +540,25 @@ export interface ComputeIngestMetric {
     durationMs: number | null;
     credits: number | null;
 }
+/**
+ * One terminal managed-toolchain run (docs/plans/bootstrap-image-versioning.md
+ * §7): a `synth` or `self-mutation` action whose row was stamped with the
+ * release from the platform's deployed manifest. ALERTING ONLY — the canary
+ * gate and the Affected view read the rows, never this metric.
+ *
+ * `platformDefaultRelease` is the default at ingest time, for the alert's
+ * baseline (`pipeline_toolchain_platform_default_seen_timestamp_seconds`).
+ */
+export interface ToolchainIngestMetric {
+    kind: 'toolchain';
+    toolchainRelease: string;
+    action: 'synth' | 'self-mutation';
+    outcome: 'succeeded' | 'failed';
+    platformDefaultRelease: string | 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;
+export type IngestMetric = StageIngestMetric | ComputeIngestMetric | ToolchainIngestMetric;
 /** Counts + the (possibly truncated) list of unregistered pipeline ids the caller can log. */
 export interface IngestResult {
     inserted: number;

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","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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","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/**\n * One terminal managed-toolchain run (docs/plans/bootstrap-image-versioning.md\n * §7): a `synth` or `self-mutation` action whose row was stamped with the\n * release from the platform's deployed manifest. ALERTING ONLY — the canary\n * gate and the Affected view read the rows, never this metric.\n *\n * `platformDefaultRelease` is the default at ingest time, for the alert's\n * baseline (`pipeline_toolchain_platform_default_seen_timestamp_seconds`).\n */\nexport interface ToolchainIngestMetric {\n  kind: 'toolchain';\n  toolchainRelease: string;\n  action: 'synth' | 'self-mutation';\n  outcome: 'succeeded' | 'failed';\n  platformDefaultRelease: string | 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 | ToolchainIngestMetric;\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/version-references.d.ts

@@ -1,27 +1,5 @@
-/**
- * Which pipelines still REFERENCE a plugin version or image — the one rule every
- * removal path asks before it deletes anything: an org plugin delete (forced or
- * not), a bulk delete, a tombstone purge (manual or the retention sweep), the
- * image registry's age GC, the listing image GC.
- *
- * THE RULE: a version (or its image) that any pipeline references cannot be
- * deleted until no pipeline does — whatever its vulnerability state. A
- * vulnerable image is the WORST thing to delete out from under a pipeline: the
- * next run fails to pull, and the owners learn about the CVE from an outage.
- * Vulnerability consequences are graded warnings and notifications, never removal.
- *
- * A reference is any of:
- *  - `declared` — a LIVE pipeline's config resolves to it (`pipeline_plugin_resolution`);
- *  - `deployed` — a pipeline's last deploy recorded it (`pipeline_step_manifests`),
- *    INCLUDING a soft-deleted pipeline: its CodePipeline still runs the image;
- *  - `exposure` — an open DEPLOYED exposure still names it (the same "still runs
- *    it" fact, kept when a manifest is gone).
- *
- * Matched by image digest when the version has one (a team running its parent's
- * plugin, or another org's install, pins the same digest), else by name +
- * version within the owner org and its teams.
- */
 import { type SQL } from 'drizzle-orm';
+import { withTenantTx } from '../database/tenancy.js';
 /** A version / image whose references are wanted. */
 export interface VersionReferenceTarget {
     pluginName: string;
@@ -59,7 +37,7 @@ export declare function versionReferencedPredicate(cols: {
  * names other orgs' pipelines; callers show the OWNER only counts and its own
  * org's pipelines, and notify each referencing org about its own.
  */
-export declare function findVersionReferences(target: VersionReferenceTarget): Promise<VersionReference[]>;
+export declare function findVersionReferences(target: VersionReferenceTarget, run?: <T>(fn: (tx: Parameters<Parameters<typeof withTenantTx>[0]>[0]) => Promise<T>) => Promise<T>): Promise<VersionReference[]>;
 /** Distinct pipelines among `refs` (a pipeline both declared and deployed counts once). */
 export declare function distinctPipelines(refs: readonly VersionReference[]): Array<{
     pipelineId: string;