@pipeline-builder/pipeline-data 4.3.11 → 4.3.13

package/lib/api/reporting/toolchain-runs.d.ts

@@ -0,0 +1,156 @@
+import { type SqlExecutor } from '../../database/pg-result.js';
+/** The two toolchain actions a release is judged on. */
+export type ToolchainAction = 'synth' | 'self-mutation';
+/** Terminal toolchain outcomes; anything else (STARTED, CANCELED, ABANDONED…) says nothing about the toolchain. */
+export type ToolchainOutcome = 'succeeded' | 'failed';
+/**
+ * CDK Pipelines' self-mutation action: a fixed stage and action name
+ * (`aws-cdk-lib/pipelines/lib/codepipeline/codepipeline.js`).
+ */
+export declare const SELF_MUTATION_STAGE = "UpdatePipeline";
+export declare 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 declare const SYNTH_STEP_KEY = "synth";
+/** A manifest row, as {@link deployedToolchainOf} reads it. */
+export interface ToolchainManifestRow {
+    pipelineId: string;
+    orgId: string;
+    stageName: string;
+    actionName: string;
+    pluginPublisher: string | null;
+    pluginName: string | null;
+    pluginVersion: string | null;
+    stepKey?: string | null;
+}
+/** One pipeline's deployed toolchain, from its manifest. */
+export interface DeployedToolchain {
+    orgId: string;
+    /** The release its `build-image` entry records. */
+    releaseVersion: string;
+    /** The synth action as the built pipeline names it; null when the manifest has no synth row. */
+    synth: {
+        stageName: string;
+        actionName: string;
+    } | null;
+}
+/**
+ * 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 declare function deployedToolchainOf(rows: readonly ToolchainManifestRow[]): Map<string, DeployedToolchain>;
+/**
+ * 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 declare function toolchainActionOf(event: {
+    eventType: string;
+    stageName?: string | null;
+    actionName?: string | null;
+}, deployed: DeployedToolchain | undefined): ToolchainAction | null;
+/** The terminal outcome of a status, or null for a non-terminal / non-judging one. */
+export declare function toolchainOutcomeOf(status: string): ToolchainOutcome | null;
+/** The gate's thresholds (set on the console, Phase 5). */
+export interface CanaryGateParams {
+    /** N: counted synth runs required. */
+    minRuns: number;
+    /** M: distinct orgs required. */
+    minOrgs: number;
+    /** T: the release's failure rate may exceed the default's by at most this many percentage points. */
+    maxFailurePointsAboveDefault: number;
+}
+export declare const DEFAULT_CANARY_GATE: Readonly<CanaryGateParams>;
+/** One org's terminal synth outcomes on the candidate, NEWEST first. */
+export interface OrgRuns {
+    orgId: string;
+    outcomes: readonly ToolchainOutcome[];
+}
+export interface CanaryGateInput {
+    releaseVersion: string;
+    candidate: readonly OrgRuns[];
+    /** The current platform default's synth runs over the same window (uncapped). */
+    baseline: {
+        releaseVersion: string | null;
+        runs: number;
+        failures: number;
+    };
+    params?: Partial<CanaryGateParams>;
+}
+export type CanaryGateShortfall = 'runs' | 'orgs' | 'failure-rate';
+/** The gate's verdict and every number behind it — what the console shows. */
+export interface CanaryGateResult {
+    passed: boolean;
+    releaseVersion: string;
+    params: CanaryGateParams;
+    /** ceil(N / M): the most runs any one org contributes. */
+    perOrgCap: number;
+    /** Runs counted toward N, after the per-org cap. */
+    countedRuns: number;
+    /** Every terminal synth run on the release, before the cap. */
+    totalRuns: number;
+    /** Distinct orgs with at least one counted run. */
+    orgs: number;
+    /** Failures among the counted runs. */
+    failures: number;
+    /** Percent (0–100) over the counted runs; null with none. */
+    failureRate: number | null;
+    baselineReleaseVersion: string | null;
+    baselineRuns: number;
+    /** Percent (0–100); 0 when the default has no runs in the window (the strict reading). */
+    baselineFailureRate: number;
+    /** failureRate − baselineFailureRate, in points; null with no counted runs. */
+    pointsAboveDefault: number | null;
+    /** Which thresholds were not met (empty when passed). */
+    shortfalls: CanaryGateShortfall[];
+}
+/** The per-org contribution cap: ceil(N / M). */
+export declare function canaryPerOrgCap(params: Pick<CanaryGateParams, 'minRuns' | 'minOrgs'>): number;
+/**
+ * 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 declare function evaluateCanaryGate(input: CanaryGateInput): CanaryGateResult;
+/**
+ * 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 declare function readCanaryGate(db: SqlExecutor, releaseVersion: string, baselineReleaseVersion: string | null, params?: Partial<CanaryGateParams>): Promise<CanaryGateResult>;
+export interface AffectedOrg {
+    orgId: string;
+    /** Pipelines in this org on the release whose latest synth failed. */
+    pipelines: number;
+    pipelineIds: string[];
+}
+export interface AffectedPipelines {
+    releaseVersion: string;
+    totalPipelines: number;
+    orgs: AffectedOrg[];
+}
+/**
+ * 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 declare function readAffectedPipelines(db: SqlExecutor, releaseVersion: string): Promise<AffectedPipelines>;
+/** The current platform default (elevated read), or null. */
+export declare function readPlatformDefaultRelease(db: SqlExecutor): Promise<string | null>;

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

@@ -0,0 +1,267 @@
+// 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, MANAGED_TOOLCHAIN, TOOLCHAIN_RELEASE_VERSION_PATTERN } 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.
+ */
+const BUILD_IMAGE_PLUGIN = MANAGED_TOOLCHAIN.bootstrap;
+/**
+ * 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' && TOOLCHAIN_RELEASE_VERSION_PATTERN.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":"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","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, MANAGED_TOOLCHAIN, TOOLCHAIN_RELEASE_VERSION_PATTERN } 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 */\nconst BUILD_IMAGE_PLUGIN = MANAGED_TOOLCHAIN.bootstrap;\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' && TOOLCHAIN_RELEASE_VERSION_PATTERN.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

@@ -5,6 +5,7 @@
  * with no behaviour. reporting-service.ts re-exports them, so the
  * `@pipeline-builder/pipeline-data` public surface is unchanged.
  */
+import type { WeekStart } from '@pipeline-builder/api-core';
 export interface ExecutionCount {
     id: string;
     project: string;
@@ -165,7 +166,7 @@ export interface BucketOptions {
     tz?: string;
     /** Where the week starts. Postgres DATE_TRUNC is Monday-only, so `sunday`
      *  shifts the boundary explicitly. */
-    weekStart?: 'monday' | 'sunday';
+    weekStart?: WeekStart;
 }
 export interface ReportingRetentionOptions {
     /** Rows deleted per statement (default 1000). */
@@ -230,7 +231,7 @@ export interface DoraOptions {
     /** IANA timezone for the trend's buckets (see {@link BucketOptions}). */
     tz?: string;
     /** Week start for the trend's buckets. */
-    weekStart?: 'monday' | 'sunday';
+    weekStart?: WeekStart;
 }
 /**
  * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`
@@ -540,9 +541,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;