@pipeline-builder/pipeline-data 4.1.24 → 4.1.26

package/lib/api/reporting/last-deploy.js

@@ -0,0 +1,93 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The last commit this pipeline deployed to an environment — the exclusive lower
+ * bound the events Lambda needs to ask an SCM "what shipped since?".
+ *
+ * The Lambda keeps that bound in a warm-container map (`lastShaByPipeline` in
+ * `scm.ts`). A cold start empties it, so the next deploy resolved as a SINGLE
+ * commit: lead time came out as the age of the newest commit alone and
+ * `commitCount` as 1, both far too small, and nothing in the data marked the
+ * number as degraded. Lambda containers recycle constantly, so this was the
+ * common case, not an edge one.
+ *
+ * Reading it back from `commit_sha` — already persisted for every event that
+ * carried one — makes the bound survive a cold start without any new state.
+ */
+import { createLogger } from '@pipeline-builder/api-core';
+import { eq, sql } from 'drizzle-orm';
+import { schema } from '../../database/drizzle-schema.js';
+import { withTenantTx } from '../../database/tenancy.js';
+import { drizzleRows } from '../crud-service.js';
+const logger = createLogger('reporting-last-deploy');
+const NONE = { commitSha: null, deployedAt: null };
+/**
+ * The commit sha of the most recent SUCCEEDED deploy-stage execution for this
+ * pipeline — narrowed to one `environment` when given.
+ *
+ * Two steps, because the two facts live on different rows: `environment` is
+ * stamped on the deploy STAGE event, while `commit_sha` rides the source
+ * ACTION/PIPELINE event of the same execution. They are joined by `execution_id`,
+ * exactly as the DORA lead-time query does it.
+ *
+ * `environment` is OPTIONAL because of who asks. The events Lambda resolves a
+ * commit while handling the SOURCE event, and a source stage carries no
+ * environment — the execution has not reached a deploy stage yet, so at that
+ * moment the environment is genuinely unknown. Omitting it answers "what did this
+ * pipeline last ship anywhere", which is the right lower bound for an SCM range;
+ * passing it answers per-environment, for callers that know.
+ *
+ * TENANCY. `caller` is enforced the same way as {@link ingestEvents}: the org
+ * comes from the pipeline REGISTRY, never from the caller, and a pipeline outside
+ * the caller's allow-list returns nothing. Without this the endpoint would hand
+ * any `reporting:ingest` holder another tenant's commit history — the same hole
+ * the ingest tenancy check closes on the write side.
+ */
+export async function getLastDeployedCommit(pipelineId, environment, caller) {
+    const unrestricted = caller === undefined || caller.crossTenant === true;
+    const allowed = new Set(caller?.allowedOrgIds ?? []);
+    return withTenantTx(async (tx) => {
+        const [registry] = await tx
+            .select({ orgId: schema.pipelineRegistry.orgId })
+            .from(schema.pipelineRegistry)
+            .where(eq(schema.pipelineRegistry.pipelineId, pipelineId));
+        // Unregistered pipeline: indistinguishable from "no deploys yet" to the
+        // caller, deliberately — an unregistered id must not confirm or deny existence.
+        if (!registry)
+            return NONE;
+        if (!unrestricted && !allowed.has(registry.orgId)) {
+            logger.warn('Refused last-deploy-commit lookup outside the caller org scope', {
+                pipelineId, foreignOrgId: registry.orgId, allowedOrgIds: [...allowed],
+            });
+            return NONE;
+        }
+        const rows = drizzleRows((await tx.execute(sql `
+      WITH last_deploy AS (
+        SELECT e.execution_id AS execution_id, e.completed_at AS completed_at
+        FROM ${schema.pipelineEvent} e
+        WHERE e.pipeline_id = ${pipelineId}
+          AND e.org_id = ${registry.orgId}
+          ${environment ? sql `AND e.environment = ${environment}` : sql `AND e.environment IS NOT NULL`}
+          AND e.event_type = 'STAGE'
+          AND e.status = 'SUCCEEDED'
+          AND e.completed_at IS NOT NULL
+        ORDER BY e.completed_at DESC
+        LIMIT 1
+      )
+      SELECT c.commit_sha AS commit_sha, ld.completed_at::text AS completed_at
+      FROM last_deploy ld
+      JOIN ${schema.pipelineEvent} c
+        ON c.execution_id = ld.execution_id
+       AND c.pipeline_id = ${pipelineId}
+       AND c.org_id = ${registry.orgId}
+      WHERE c.commit_sha IS NOT NULL
+      ORDER BY c.created_at DESC
+      LIMIT 1
+    `)).rows);
+        const row = rows[0];
+        if (!row)
+            return NONE;
+        return { commitSha: row.commit_sha ?? null, deployedAt: row.completed_at ?? null };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"last-deploy.js","sourceRoot":"","sources":["../../../src/api/reporting/last-deploy.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,GAAG,YAAY,CAAC,uBAAuB,CAAC,CAAC;AAUrD,MAAM,IAAI,GAAuB,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,UAAkB,EAClB,WAAoB,EACpB,MAAqB;IAErB,MAAM,YAAY,GAAG,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,WAAW,KAAK,IAAI,CAAC;IACzE,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,IAAI,EAAE,CAAC,CAAC;IAErD,OAAO,YAAY,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;QAC/B,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,EAAE;aACxB,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;aAChD,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;aAC7B,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;QAC7D,wEAAwE;QACxE,gFAAgF;QAChF,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QAE3B,IAAI,CAAC,YAAY,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAClD,MAAM,CAAC,IAAI,CAAC,gEAAgE,EAAE;gBAC5E,UAAU,EAAE,YAAY,EAAE,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC,GAAG,OAAO,CAAC;aACtE,CAAC,CAAC;YACH,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,IAAI,GAAG,WAAW,CAA6D,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;eAG/F,MAAM,CAAC,aAAa;gCACH,UAAU;2BACf,QAAQ,CAAC,KAAK;YAC7B,WAAW,CAAC,CAAC,CAAC,GAAG,CAAA,uBAAuB,WAAW,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA,+BAA+B;;;;;;;;;aASzF,MAAM,CAAC,aAAa;;6BAEJ,UAAU;wBACf,QAAQ,CAAC,KAAK;;;;KAIjC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAEV,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,IAAI,CAAC,GAAG;YAAE,OAAO,IAAI,CAAC;QACtB,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,UAAU,IAAI,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,YAAY,IAAI,IAAI,EAAE,CAAC;IACrF,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The last commit this pipeline deployed to an environment — the exclusive lower\n * bound the events Lambda needs to ask an SCM \"what shipped since?\".\n *\n * The Lambda keeps that bound in a warm-container map (`lastShaByPipeline` in\n * `scm.ts`). A cold start empties it, so the next deploy resolved as a SINGLE\n * commit: lead time came out as the age of the newest commit alone and\n * `commitCount` as 1, both far too small, and nothing in the data marked the\n * number as degraded. Lambda containers recycle constantly, so this was the\n * common case, not an edge one.\n *\n * Reading it back from `commit_sha` — already persisted for every event that\n * carried one — makes the bound survive a cold start without any new state.\n */\n\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { eq, sql } from 'drizzle-orm';\nimport type { IngestCaller } from './types.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport { withTenantTx } from '../../database/tenancy.js';\nimport { drizzleRows } from '../crud-service.js';\n\nconst logger = createLogger('reporting-last-deploy');\n\n/** The bound, or nulls when this pipeline has no recorded deploy carrying a commit. */\nexport interface LastDeployedCommit {\n  /** Commit sha of the most recent successful deploy to the environment. */\n  commitSha: string | null;\n  /** When that deploy completed, ISO text — for the caller's own logging. */\n  deployedAt: string | null;\n}\n\nconst NONE: LastDeployedCommit = { commitSha: null, deployedAt: null };\n\n/**\n * The commit sha of the most recent SUCCEEDED deploy-stage execution for this\n * pipeline — narrowed to one `environment` when given.\n *\n * Two steps, because the two facts live on different rows: `environment` is\n * stamped on the deploy STAGE event, while `commit_sha` rides the source\n * ACTION/PIPELINE event of the same execution. They are joined by `execution_id`,\n * exactly as the DORA lead-time query does it.\n *\n * `environment` is OPTIONAL because of who asks. The events Lambda resolves a\n * commit while handling the SOURCE event, and a source stage carries no\n * environment — the execution has not reached a deploy stage yet, so at that\n * moment the environment is genuinely unknown. Omitting it answers \"what did this\n * pipeline last ship anywhere\", which is the right lower bound for an SCM range;\n * passing it answers per-environment, for callers that know.\n *\n * TENANCY. `caller` is enforced the same way as {@link ingestEvents}: the org\n * comes from the pipeline REGISTRY, never from the caller, and a pipeline outside\n * the caller's allow-list returns nothing. Without this the endpoint would hand\n * any `reporting:ingest` holder another tenant's commit history — the same hole\n * the ingest tenancy check closes on the write side.\n */\nexport async function getLastDeployedCommit(\n  pipelineId: string,\n  environment?: string,\n  caller?: IngestCaller,\n): Promise<LastDeployedCommit> {\n  const unrestricted = caller === undefined || caller.crossTenant === true;\n  const allowed = new Set(caller?.allowedOrgIds ?? []);\n\n  return withTenantTx(async (tx) => {\n    const [registry] = await tx\n      .select({ orgId: schema.pipelineRegistry.orgId })\n      .from(schema.pipelineRegistry)\n      .where(eq(schema.pipelineRegistry.pipelineId, pipelineId));\n    // Unregistered pipeline: indistinguishable from \"no deploys yet\" to the\n    // caller, deliberately — an unregistered id must not confirm or deny existence.\n    if (!registry) return NONE;\n\n    if (!unrestricted && !allowed.has(registry.orgId)) {\n      logger.warn('Refused last-deploy-commit lookup outside the caller org scope', {\n        pipelineId, foreignOrgId: registry.orgId, allowedOrgIds: [...allowed],\n      });\n      return NONE;\n    }\n\n    const rows = drizzleRows<{ commit_sha: string | null; completed_at: string | null }>((await tx.execute(sql`\n      WITH last_deploy AS (\n        SELECT e.execution_id AS execution_id, e.completed_at AS completed_at\n        FROM ${schema.pipelineEvent} e\n        WHERE e.pipeline_id = ${pipelineId}\n          AND e.org_id = ${registry.orgId}\n          ${environment ? sql`AND e.environment = ${environment}` : sql`AND e.environment IS NOT NULL`}\n          AND e.event_type = 'STAGE'\n          AND e.status = 'SUCCEEDED'\n          AND e.completed_at IS NOT NULL\n        ORDER BY e.completed_at DESC\n        LIMIT 1\n      )\n      SELECT c.commit_sha AS commit_sha, ld.completed_at::text AS completed_at\n      FROM last_deploy ld\n      JOIN ${schema.pipelineEvent} c\n        ON c.execution_id = ld.execution_id\n       AND c.pipeline_id = ${pipelineId}\n       AND c.org_id = ${registry.orgId}\n      WHERE c.commit_sha IS NOT NULL\n      ORDER BY c.created_at DESC\n      LIMIT 1\n    `)).rows);\n\n    const row = rows[0];\n    if (!row) return NONE;\n    return { commitSha: row.commit_sha ?? null, deployedAt: row.completed_at ?? null };\n  });\n}\n"]}

package/lib/api/reporting/needs-attention.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Which pipelines need somebody to look at them, and WHY.
+ *
+ * The rest of the report describes; this decides. That is a meaningful difference,
+ * and it is why every finding carries its EVIDENCE — "p95 up 31%, 4m12s → 5m31s",
+ * not "performance degraded". A flag without the number behind it is an opinion the
+ * reader has to take on trust, and the first time one is wrong the whole section
+ * stops being read.
+ *
+ * THE THRESHOLDS ARE ORG-CONFIGURABLE, with defaults stated below. They have to be:
+ * 90% success is a crisis for a deploy pipeline and unremarkable for a flaky
+ * integration suite somebody is already rewriting, and a platform-imposed number
+ * would make the section wrong for one of them by construction.
+ *
+ * WHAT IS DELIBERATELY NOT A RULE: anything per-person, anything about volume
+ * ("this team shipped less than that team"), and anything comparing one team to
+ * another. Those are the flags that turn a delivery report into a performance
+ * review, which is the failure mode this whole feature is trying to avoid.
+ */
+import type { PipelineBreakdownRow } from './analytics-queries.js';
+/** The thresholds a rule trips at. Every one is overridable per org. */
+export interface NeedsAttentionThresholds {
+    /** Success rate below this, as a percentage. */
+    successRatePct: number;
+    /** p95 duration up by more than this, as a percentage of the previous period. */
+    p95IncreasePct: number;
+    /** This many consecutive failures. */
+    consecutiveFailures: number;
+    /** No successful run in this many days. */
+    staleDays: number;
+    /** A failure within this many hours of a pipeline configuration change. */
+    failureAfterChangeHours: number;
+}
+/**
+ * The defaults.
+ *
+ * Each is the point at which a reasonable lead would want to know, not the point at
+ * which something is definitely wrong — the section's job is to raise attention,
+ * and a threshold set where the problem is already undeniable raises it too late.
+ */
+export declare const DEFAULT_THRESHOLDS: Readonly<NeedsAttentionThresholds>;
+/** Why a pipeline was flagged. The id is stable; the evidence is human. */
+export type AttentionRuleId = 'low_success_rate' | 'slower_p95' | 'consecutive_failures' | 'no_recent_success' | 'failed_after_config_change' | 'vulnerable_plugin' | 'no_deploy_tracking';
+/** One finding about one pipeline. */
+export interface AttentionFinding {
+    rule: AttentionRuleId;
+    /** The sentence a lead reads, with the number in it. */
+    evidence: string;
+    /** `high` means "this is broken now"; `medium` means "this is drifting". */
+    severity: 'high' | 'medium';
+}
+/** A flagged pipeline and everything that tripped. */
+export interface AttentionItem {
+    pipelineId: string;
+    pipelineName: string | null;
+    findings: AttentionFinding[];
+    /** The worst severity among the findings — what the list sorts on. */
+    severity: 'high' | 'medium';
+}
+/** What the evaluator needs beyond the current period's breakdown. */
+export interface AttentionInput {
+    current: readonly PipelineBreakdownRow[];
+    /** The previous period, for the p95 comparison. Absent ⇒ that rule is skipped. */
+    previous?: readonly PipelineBreakdownRow[];
+    /** Per pipeline: consecutive failures ending the period, and last success. */
+    streaks?: ReadonlyMap<string, {
+        consecutiveFailures: number;
+        lastSuccessAt: Date | null;
+    }>;
+    /** Per pipeline: the most recent config change, from the audit trail. */
+    configChanges?: ReadonlyMap<string, Date>;
+    /** Pipelines with an open Critical plugin exposure. */
+    vulnerablePipelines?: ReadonlySet<string>;
+    /** Pipelines that ran but produced no deploy rows — DORA cannot see them. */
+    untrackedPipelines?: ReadonlySet<string>;
+    thresholds?: Partial<NeedsAttentionThresholds>;
+    now?: Date;
+}
+/**
+ * Evaluate every rule against the period.
+ *
+ * Returns only the pipelines that tripped something, worst first, so the section is
+ * a short list of things to do rather than a table of everything.
+ */
+export declare function evaluateNeedsAttention(input: AttentionInput): AttentionItem[];
+/**
+ * Read an org's thresholds out of stored settings, falling back per field.
+ *
+ * Per FIELD, not per object: an org that set only `successRatePct` keeps the
+ * defaults for everything else, rather than silently disabling four rules by
+ * configuring one.
+ */
+export declare function thresholdsFrom(stored: Partial<NeedsAttentionThresholds> | null | undefined): NeedsAttentionThresholds;

package/lib/api/reporting/needs-attention.js

@@ -0,0 +1,152 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The defaults.
+ *
+ * Each is the point at which a reasonable lead would want to know, not the point at
+ * which something is definitely wrong — the section's job is to raise attention,
+ * and a threshold set where the problem is already undeniable raises it too late.
+ */
+export const DEFAULT_THRESHOLDS = Object.freeze({
+    successRatePct: 90,
+    p95IncreasePct: 25,
+    consecutiveFailures: 3,
+    staleDays: 7,
+    failureAfterChangeHours: 24,
+});
+/** `272000` → `4m32s`, for evidence a person reads. */
+function duration(ms) {
+    const total = Math.round(ms / 1000);
+    const m = Math.floor(total / 60);
+    const s = total % 60;
+    return m > 0 ? `${m}m${String(s).padStart(2, '0')}s` : `${s}s`;
+}
+/**
+ * Evaluate every rule against the period.
+ *
+ * Returns only the pipelines that tripped something, worst first, so the section is
+ * a short list of things to do rather than a table of everything.
+ */
+export function evaluateNeedsAttention(input) {
+    const t = { ...DEFAULT_THRESHOLDS, ...input.thresholds };
+    const now = input.now ?? new Date();
+    const priorByPipeline = new Map((input.previous ?? []).map((p) => [p.pipelineId, p]));
+    const items = [];
+    for (const row of input.current) {
+        const findings = [];
+        // 1. Success rate. Skipped entirely for a pipeline with no runs: a pipeline
+        // nobody ran has no success rate, and flagging it as 0% would put every
+        // dormant pipeline at the top of the list forever.
+        if (row.runs > 0 && row.successPct !== null && row.successPct < t.successRatePct) {
+            findings.push({
+                rule: 'low_success_rate',
+                severity: row.successPct < t.successRatePct / 2 ? 'high' : 'medium',
+                evidence: `${row.successPct}% of ${row.runs} runs succeeded (below ${t.successRatePct}%)`,
+            });
+        }
+        // 2. Getting slower. Needs both periods AND a real baseline — a jump from 2s
+        // to 3s is 50% and means nothing, so a tiny baseline is not evidence.
+        const prior = priorByPipeline.get(row.pipelineId);
+        if (row.p95Ms !== null && prior?.p95Ms && prior.p95Ms > 10_000) {
+            const deltaPct = ((row.p95Ms - prior.p95Ms) / prior.p95Ms) * 100;
+            if (deltaPct > t.p95IncreasePct) {
+                findings.push({
+                    rule: 'slower_p95',
+                    severity: deltaPct > t.p95IncreasePct * 2 ? 'high' : 'medium',
+                    evidence: `p95 up ${deltaPct.toFixed(0)}%, ${duration(prior.p95Ms)} → ${duration(row.p95Ms)}`,
+                });
+            }
+        }
+        const streak = input.streaks?.get(row.pipelineId);
+        // 3. Consecutive failures. The clearest "this is broken now" signal there is:
+        // a 70% success rate over a month and three failures in a row are very
+        // different situations, and only the second needs somebody today.
+        if (streak && streak.consecutiveFailures >= t.consecutiveFailures) {
+            findings.push({
+                rule: 'consecutive_failures',
+                severity: 'high',
+                evidence: `${streak.consecutiveFailures} consecutive failures`,
+            });
+        }
+        // 4. Nothing has worked lately. Distinct from the rate: a pipeline that
+        // succeeded 90% of the time and then stopped succeeding entirely looks fine
+        // by rate and is completely broken.
+        if (streak && row.runs > 0) {
+            const days = streak.lastSuccessAt
+                ? Math.floor((now.getTime() - streak.lastSuccessAt.getTime()) / 86_400_000)
+                : null;
+            if (days === null) {
+                findings.push({
+                    rule: 'no_recent_success',
+                    severity: 'high',
+                    evidence: `no successful run in this period (${row.runs} attempts)`,
+                });
+            }
+            else if (days >= t.staleDays) {
+                findings.push({
+                    rule: 'no_recent_success',
+                    severity: days >= t.staleDays * 2 ? 'high' : 'medium',
+                    evidence: `last succeeded ${days} days ago`,
+                });
+            }
+        }
+        // 5. Broke shortly after somebody changed it. The most useful correlation in
+        // the whole section, because it names a likely cause rather than a symptom —
+        // and it is the one a human would work out by hand from two screens.
+        const changedAt = input.configChanges?.get(row.pipelineId);
+        if (changedAt && row.lastFailureAt) {
+            const gapHours = (new Date(row.lastFailureAt).getTime() - changedAt.getTime()) / 3600_000;
+            if (gapHours >= 0 && gapHours <= t.failureAfterChangeHours) {
+                findings.push({
+                    rule: 'failed_after_config_change',
+                    severity: 'high',
+                    evidence: `failed ${gapHours < 1 ? 'less than an hour' : `${Math.round(gapHours)}h`} after a configuration change`
+                        + (row.lastFailureStage ? ` (${row.lastFailureStage})` : ''),
+                });
+            }
+        }
+        // 6. Running a plugin version with open Critical findings.
+        if (input.vulnerablePipelines?.has(row.pipelineId)) {
+            findings.push({
+                rule: 'vulnerable_plugin',
+                severity: 'high',
+                evidence: 'runs a plugin version with open Critical vulnerabilities',
+            });
+        }
+        // 7. Invisible to DORA. Not a failure — a MEASUREMENT gap, and flagged
+        // because a pipeline nobody can see deploying is the reason a deployment-
+        // frequency number is wrong, and nothing else in the report would say so.
+        if (input.untrackedPipelines?.has(row.pipelineId) && row.runs > 0) {
+            findings.push({
+                rule: 'no_deploy_tracking',
+                severity: 'medium',
+                evidence: 'ran, but produced no deploy data — re-synth to include deploy tags',
+            });
+        }
+        if (findings.length > 0) {
+            items.push({
+                pipelineId: row.pipelineId,
+                pipelineName: row.pipelineName,
+                findings,
+                severity: findings.some((f) => f.severity === 'high') ? 'high' : 'medium',
+            });
+        }
+    }
+    // High first, then the pipelines with the most wrong with them.
+    return items.sort((a, b) => {
+        if (a.severity !== b.severity)
+            return a.severity === 'high' ? -1 : 1;
+        return b.findings.length - a.findings.length;
+    });
+}
+/**
+ * Read an org's thresholds out of stored settings, falling back per field.
+ *
+ * Per FIELD, not per object: an org that set only `successRatePct` keeps the
+ * defaults for everything else, rather than silently disabling four rules by
+ * configuring one.
+ */
+export function thresholdsFrom(stored) {
+    return { ...DEFAULT_THRESHOLDS, ...(stored ?? {}) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"needs-attention.js","sourceRoot":"","sources":["../../../src/api/reporting/needs-attention.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Which pipelines need somebody to look at them, and WHY.\n *\n * The rest of the report describes; this decides. That is a meaningful difference,\n * and it is why every finding carries its EVIDENCE — \"p95 up 31%, 4m12s → 5m31s\",\n * not \"performance degraded\". A flag without the number behind it is an opinion the\n * reader has to take on trust, and the first time one is wrong the whole section\n * stops being read.\n *\n * THE THRESHOLDS ARE ORG-CONFIGURABLE, with defaults stated below. They have to be:\n * 90% success is a crisis for a deploy pipeline and unremarkable for a flaky\n * integration suite somebody is already rewriting, and a platform-imposed number\n * would make the section wrong for one of them by construction.\n *\n * WHAT IS DELIBERATELY NOT A RULE: anything per-person, anything about volume\n * (\"this team shipped less than that team\"), and anything comparing one team to\n * another. Those are the flags that turn a delivery report into a performance\n * review, which is the failure mode this whole feature is trying to avoid.\n */\n\nimport type { PipelineBreakdownRow } from './analytics-queries.js';\n\n/** The thresholds a rule trips at. Every one is overridable per org. */\nexport interface NeedsAttentionThresholds {\n  /** Success rate below this, as a percentage. */\n  successRatePct: number;\n  /** p95 duration up by more than this, as a percentage of the previous period. */\n  p95IncreasePct: number;\n  /** This many consecutive failures. */\n  consecutiveFailures: number;\n  /** No successful run in this many days. */\n  staleDays: number;\n  /** A failure within this many hours of a pipeline configuration change. */\n  failureAfterChangeHours: number;\n}\n\n/**\n * The defaults.\n *\n * Each is the point at which a reasonable lead would want to know, not the point at\n * which something is definitely wrong — the section's job is to raise attention,\n * and a threshold set where the problem is already undeniable raises it too late.\n */\nexport const DEFAULT_THRESHOLDS: Readonly<NeedsAttentionThresholds> = Object.freeze({\n  successRatePct: 90,\n  p95IncreasePct: 25,\n  consecutiveFailures: 3,\n  staleDays: 7,\n  failureAfterChangeHours: 24,\n});\n\n/** Why a pipeline was flagged. The id is stable; the evidence is human. */\nexport type AttentionRuleId =\n  | 'low_success_rate'\n  | 'slower_p95'\n  | 'consecutive_failures'\n  | 'no_recent_success'\n  | 'failed_after_config_change'\n  | 'vulnerable_plugin'\n  | 'no_deploy_tracking';\n\n/** One finding about one pipeline. */\nexport interface AttentionFinding {\n  rule: AttentionRuleId;\n  /** The sentence a lead reads, with the number in it. */\n  evidence: string;\n  /** `high` means \"this is broken now\"; `medium` means \"this is drifting\". */\n  severity: 'high' | 'medium';\n}\n\n/** A flagged pipeline and everything that tripped. */\nexport interface AttentionItem {\n  pipelineId: string;\n  pipelineName: string | null;\n  findings: AttentionFinding[];\n  /** The worst severity among the findings — what the list sorts on. */\n  severity: 'high' | 'medium';\n}\n\n/** What the evaluator needs beyond the current period's breakdown. */\nexport interface AttentionInput {\n  current: readonly PipelineBreakdownRow[];\n  /** The previous period, for the p95 comparison. Absent ⇒ that rule is skipped. */\n  previous?: readonly PipelineBreakdownRow[];\n  /** Per pipeline: consecutive failures ending the period, and last success. */\n  streaks?: ReadonlyMap<string, { consecutiveFailures: number; lastSuccessAt: Date | null }>;\n  /** Per pipeline: the most recent config change, from the audit trail. */\n  configChanges?: ReadonlyMap<string, Date>;\n  /** Pipelines with an open Critical plugin exposure. */\n  vulnerablePipelines?: ReadonlySet<string>;\n  /** Pipelines that ran but produced no deploy rows — DORA cannot see them. */\n  untrackedPipelines?: ReadonlySet<string>;\n  thresholds?: Partial<NeedsAttentionThresholds>;\n  now?: Date;\n}\n\n/** `272000` → `4m32s`, for evidence a person reads. */\nfunction duration(ms: number): string {\n  const total = Math.round(ms / 1000);\n  const m = Math.floor(total / 60);\n  const s = total % 60;\n  return m > 0 ? `${m}m${String(s).padStart(2, '0')}s` : `${s}s`;\n}\n\n/**\n * Evaluate every rule against the period.\n *\n * Returns only the pipelines that tripped something, worst first, so the section is\n * a short list of things to do rather than a table of everything.\n */\nexport function evaluateNeedsAttention(input: AttentionInput): AttentionItem[] {\n  const t = { ...DEFAULT_THRESHOLDS, ...input.thresholds };\n  const now = input.now ?? new Date();\n  const priorByPipeline = new Map((input.previous ?? []).map((p) => [p.pipelineId, p]));\n  const items: AttentionItem[] = [];\n\n  for (const row of input.current) {\n    const findings: AttentionFinding[] = [];\n\n    // 1. Success rate. Skipped entirely for a pipeline with no runs: a pipeline\n    // nobody ran has no success rate, and flagging it as 0% would put every\n    // dormant pipeline at the top of the list forever.\n    if (row.runs > 0 && row.successPct !== null && row.successPct < t.successRatePct) {\n      findings.push({\n        rule: 'low_success_rate',\n        severity: row.successPct < t.successRatePct / 2 ? 'high' : 'medium',\n        evidence: `${row.successPct}% of ${row.runs} runs succeeded (below ${t.successRatePct}%)`,\n      });\n    }\n\n    // 2. Getting slower. Needs both periods AND a real baseline — a jump from 2s\n    // to 3s is 50% and means nothing, so a tiny baseline is not evidence.\n    const prior = priorByPipeline.get(row.pipelineId);\n    if (row.p95Ms !== null && prior?.p95Ms && prior.p95Ms > 10_000) {\n      const deltaPct = ((row.p95Ms - prior.p95Ms) / prior.p95Ms) * 100;\n      if (deltaPct > t.p95IncreasePct) {\n        findings.push({\n          rule: 'slower_p95',\n          severity: deltaPct > t.p95IncreasePct * 2 ? 'high' : 'medium',\n          evidence: `p95 up ${deltaPct.toFixed(0)}%, ${duration(prior.p95Ms)} → ${duration(row.p95Ms)}`,\n        });\n      }\n    }\n\n    const streak = input.streaks?.get(row.pipelineId);\n\n    // 3. Consecutive failures. The clearest \"this is broken now\" signal there is:\n    // a 70% success rate over a month and three failures in a row are very\n    // different situations, and only the second needs somebody today.\n    if (streak && streak.consecutiveFailures >= t.consecutiveFailures) {\n      findings.push({\n        rule: 'consecutive_failures',\n        severity: 'high',\n        evidence: `${streak.consecutiveFailures} consecutive failures`,\n      });\n    }\n\n    // 4. Nothing has worked lately. Distinct from the rate: a pipeline that\n    // succeeded 90% of the time and then stopped succeeding entirely looks fine\n    // by rate and is completely broken.\n    if (streak && row.runs > 0) {\n      const days = streak.lastSuccessAt\n        ? Math.floor((now.getTime() - streak.lastSuccessAt.getTime()) / 86_400_000)\n        : null;\n      if (days === null) {\n        findings.push({\n          rule: 'no_recent_success',\n          severity: 'high',\n          evidence: `no successful run in this period (${row.runs} attempts)`,\n        });\n      } else if (days >= t.staleDays) {\n        findings.push({\n          rule: 'no_recent_success',\n          severity: days >= t.staleDays * 2 ? 'high' : 'medium',\n          evidence: `last succeeded ${days} days ago`,\n        });\n      }\n    }\n\n    // 5. Broke shortly after somebody changed it. The most useful correlation in\n    // the whole section, because it names a likely cause rather than a symptom —\n    // and it is the one a human would work out by hand from two screens.\n    const changedAt = input.configChanges?.get(row.pipelineId);\n    if (changedAt && row.lastFailureAt) {\n      const gapHours = (new Date(row.lastFailureAt).getTime() - changedAt.getTime()) / 3600_000;\n      if (gapHours >= 0 && gapHours <= t.failureAfterChangeHours) {\n        findings.push({\n          rule: 'failed_after_config_change',\n          severity: 'high',\n          evidence: `failed ${gapHours < 1 ? 'less than an hour' : `${Math.round(gapHours)}h`} after a configuration change`\n            + (row.lastFailureStage ? ` (${row.lastFailureStage})` : ''),\n        });\n      }\n    }\n\n    // 6. Running a plugin version with open Critical findings.\n    if (input.vulnerablePipelines?.has(row.pipelineId)) {\n      findings.push({\n        rule: 'vulnerable_plugin',\n        severity: 'high',\n        evidence: 'runs a plugin version with open Critical vulnerabilities',\n      });\n    }\n\n    // 7. Invisible to DORA. Not a failure — a MEASUREMENT gap, and flagged\n    // because a pipeline nobody can see deploying is the reason a deployment-\n    // frequency number is wrong, and nothing else in the report would say so.\n    if (input.untrackedPipelines?.has(row.pipelineId) && row.runs > 0) {\n      findings.push({\n        rule: 'no_deploy_tracking',\n        severity: 'medium',\n        evidence: 'ran, but produced no deploy data — re-synth to include deploy tags',\n      });\n    }\n\n    if (findings.length > 0) {\n      items.push({\n        pipelineId: row.pipelineId,\n        pipelineName: row.pipelineName,\n        findings,\n        severity: findings.some((f) => f.severity === 'high') ? 'high' : 'medium',\n      });\n    }\n  }\n\n  // High first, then the pipelines with the most wrong with them.\n  return items.sort((a, b) => {\n    if (a.severity !== b.severity) return a.severity === 'high' ? -1 : 1;\n    return b.findings.length - a.findings.length;\n  });\n}\n\n/**\n * Read an org's thresholds out of stored settings, falling back per field.\n *\n * Per FIELD, not per object: an org that set only `successRatePct` keeps the\n * defaults for everything else, rather than silently disabling four rules by\n * configuring one.\n */\nexport function thresholdsFrom(stored: Partial<NeedsAttentionThresholds> | null | undefined): NeedsAttentionThresholds {\n  return { ...DEFAULT_THRESHOLDS, ...(stored ?? {}) };\n}\n"]}

package/lib/api/reporting/plugin-exposure.d.ts

@@ -0,0 +1,129 @@
+import type { ExposureSource } from '../../database/schema/reporting-analytics.js';
+/** How far behind a resolved version is from the newest one available. */
+export type VersionGap = 'major' | 'minor' | 'patch' | 'none';
+/** One resolved step, as the writer takes it. */
+export interface ResolvedStep {
+    orgId: string;
+    pipelineId: string;
+    stageName: string;
+    stepName: string;
+    pluginPublisher?: string | null;
+    pluginName: string;
+    declaredVersion?: string | null;
+    resolvedVersion?: string | null;
+    latestVersion?: string | null;
+    withinPolicy?: boolean;
+}
+/**
+ * How far `resolved` is behind `latest`.
+ *
+ * `null` when either side is unparseable, NOT `'none'`. "We could not tell" and
+ * "it is up to date" are opposite answers, and reporting the second for the first
+ * is how a pipeline on an ancient pre-release version gets a clean bill of health.
+ */
+export declare function versionGap(resolved: string | null | undefined, latest: string | null | undefined): VersionGap | null;
+/**
+ * Replace a pipeline's resolution rows.
+ *
+ * DELETE-then-INSERT for the pipeline, in one transaction, because a step can be
+ * REMOVED from a config: an upsert-only writer would leave the deleted step's row
+ * behind forever, and the outdated-plugin section would keep reporting a step the
+ * pipeline no longer has.
+ */
+export declare function replacePipelineResolution(pipelineId: string, steps: readonly ResolvedStep[]): Promise<number>;
+/**
+ * Refresh the `latest`/gap columns for one plugin across every pipeline that uses
+ * it, without re-resolving anything else.
+ *
+ * Called on publish. A publish changes what "latest" means for every pipeline in
+ * the instance that declares the plugin, and re-resolving each of those pipelines
+ * from scratch would make publishing cost O(pipelines) work — so only the two
+ * columns a publish can change are touched.
+ */
+export declare function refreshLatestForPlugin(pluginName: string, pluginPublisher: string | null, latestVersion: string): Promise<number>;
+/** One flagged version, as the rescan reports it. */
+export interface ExposureInput {
+    orgId: string;
+    pipelineId: string;
+    pluginPublisher?: string | null;
+    pluginName: string;
+    pluginVersion: string;
+    imageDigest?: string | null;
+    source: ExposureSource;
+    criticalCount: number;
+    highCount: number;
+    topFindings?: Array<Record<string, unknown>>;
+}
+/**
+ * Open or refresh exposures.
+ *
+ * Upserts on (pipeline, plugin, version, source) so a nightly rescan REFRESHES the
+ * counts rather than opening a new row every night — otherwise the report would
+ * show one exposure per night of the same problem, which reads as an escalating
+ * situation when nothing changed.
+ *
+ * A refresh deliberately does NOT reset `triage_state`: an org that accepted a
+ * finding with a reason and a deadline has made a decision, and re-raising it every
+ * night is how a team learns to ignore the report. It DOES clear a stale
+ * acceptance, because that is what the deadline was for.
+ */
+export declare function upsertExposures(inputs: readonly ExposureInput[], now?: Date): Promise<number>;
+/**
+ * Close the exposures a pipeline has moved off.
+ *
+ * Called when a deploy records a new step manifest: anything flagged for that
+ * pipeline whose version is NOT in the set it now runs is fixed. Closing by
+ * absence rather than waiting for a rescan to notice is what makes "we fixed it"
+ * show up in the report on the next deploy instead of the next night.
+ */
+export declare function closeFixedExposures(pipelineId: string, liveVersions: ReadonlyArray<{
+    pluginName: string;
+    pluginVersion: string;
+}>, now?: Date): Promise<number>;
+/**
+ * The org's live exposures, for the report section.
+ *
+ * `accepted` rows whose deadline has passed come back as OPEN even if no rescan
+ * has refreshed them yet: a read must not present an expired acceptance as a
+ * current one, and the report is read far more often than the rescan runs.
+ */
+export declare function openExposures(orgId: string): Promise<Array<{
+    pipelineId: string;
+    pluginName: string;
+    pluginVersion: string;
+    pluginPublisher: string | null;
+    source: ExposureSource;
+    criticalCount: number;
+    highCount: number;
+    topFindings: Array<Record<string, unknown>>;
+    triageState: string;
+    flaggedAt: Date;
+}>>;
+/**
+ * Record a triage decision.
+ *
+ * `accepted` REQUIRES a deadline and a reason. A permanent, unexplained mute is
+ * how a finding stops being anybody's problem, and there is no good reason to
+ * support it — the caller gets an error rather than a silently unbounded
+ * acceptance.
+ */
+export declare function triageExposure(orgId: string, id: string, decision: {
+    state: 'open' | 'accepted' | 'false_positive';
+    reason?: string;
+    acceptedUntil?: Date;
+    actor: string;
+}): Promise<boolean>;
+/**
+ * Exposures whose acceptance has lapsed, for the org's security notifications.
+ *
+ * Surfaced rather than silently reopened: somebody decided to accept this until a
+ * date, that date has passed, and the person who decided is the one who should
+ * hear about it.
+ */
+export declare function lapsedAcceptances(orgId: string, now?: Date): Promise<Array<{
+    id: string;
+    pluginName: string;
+    pluginVersion: string;
+    triagedBy: string | null;
+    acceptedUntil: Date | null;
+}>>;