@boxxy/pepys 0.0.1 → 0.1.4

package/src/generated/boxxy-work.sql

@@ -0,0 +1,71 @@
+-- Generated by `pepys build`. Do not edit.
+
+CREATE TABLE "boxxy_item" (
+  "id" TEXT NOT NULL,
+  "kind" TEXT NOT NULL,
+  "repo" TEXT NOT NULL,
+  "title" TEXT NOT NULL,
+  "design_mode" TEXT,
+  "filed_at" TEXT NOT NULL,
+  "closed_at" TEXT,
+  "close_reason" TEXT,
+  "updated_at" TEXT NOT NULL,
+  PRIMARY KEY ("id")
+);
+
+CREATE TABLE "boxxy_attempt" (
+  "id" TEXT NOT NULL,
+  "item_id" TEXT NOT NULL,
+  "phase" TEXT NOT NULL,
+  "number" INTEGER NOT NULL,
+  "round" INTEGER NOT NULL,
+  "mode" TEXT NOT NULL,
+  "pool" TEXT NOT NULL,
+  "recipe_hash" TEXT NOT NULL,
+  "rules_version" TEXT NOT NULL,
+  "atc_session" TEXT,
+  "state" TEXT NOT NULL,
+  "outcome" TEXT,
+  "failure" TEXT,
+  "claimed_at" TEXT NOT NULL,
+  "started_at" TEXT,
+  "closed_out_at" TEXT,
+  "ended_at" TEXT,
+  "sleeps" TEXT NOT NULL,
+  "updated_at" TEXT NOT NULL,
+  PRIMARY KEY ("id")
+);
+
+CREATE INDEX "boxxy_attempt_item_id_idx" ON "boxxy_attempt" ("item_id");
+
+CREATE TABLE "boxxy_attempt_session" (
+  "attempt_id" TEXT NOT NULL,
+  "session_id" TEXT NOT NULL,
+  "key" TEXT NOT NULL,
+  "product" TEXT,
+  "caller_issuer" TEXT,
+  "caller_subject" TEXT,
+  "bound_at" TEXT NOT NULL,
+  PRIMARY KEY ("attempt_id", "session_id")
+);
+
+CREATE INDEX "boxxy_attempt_session_session_id_idx" ON "boxxy_attempt_session" ("session_id");
+
+CREATE VIEW "entity" AS
+SELECT
+  "id" AS "id",
+  'boxxy:item' AS "kind",
+  "title" AS "title",
+  NULL AS "url",
+  NULL AS "actor",
+  "updated_at" AS "updated_at"
+FROM "boxxy_item"
+UNION ALL
+SELECT
+  "id" AS "id",
+  'boxxy:attempt' AS "kind",
+  "phase" AS "title",
+  NULL AS "url",
+  NULL AS "actor",
+  "updated_at" AS "updated_at"
+FROM "boxxy_attempt";

package/src/index.ts

@@ -0,0 +1,17 @@
+export { buildBoxxyPlugin } from './build-boxxy-plugin.ts';
+
+export type {
+  DeliveryInput,
+  DeliveryReadRow,
+  DeliveryReads,
+  ForeignReads,
+  GithubPullRequestConsumer,
+  OpaqueConsumer,
+  StageTimeReads,
+  TelemetryModelRequestConsumer,
+  TelemetryTurnCostConsumer,
+} from './queries/types.ts';
+
+export { boxxySource } from './boxxy-source.ts';
+export type { BoxxyQueryClient, UncheckedQueryClient } from './types.ts';
+export { boxxyWorkConsumer } from './work/boxxy-work-consumer.ts';

package/src/queries/build-cost-to-land-query.ts

@@ -0,0 +1,127 @@
+import { costToLandSchema } from '@boxxy/model';
+import { defineQuery } from '@pepys/kit';
+import type { EntityID, QueryCall } from '@pepys/kit';
+import { z } from 'zod';
+import { boxxyWorkConsumer } from '../work/boxxy-work-consumer.ts';
+import { buildCostToLand } from './build-cost-to-land.ts';
+import { findItemEntityID } from './find-item-entity-id.ts';
+import type {
+  ForeignReads,
+  GithubPullRequestConsumer,
+  TelemetryModelRequestConsumer,
+  TelemetryTurnCostConsumer,
+} from './types.ts';
+
+// The cost query over the boxxy consumer and the telemetry and GitHub consumers. Each statement
+// reads plain rows, and the builder does the caller match, the windows and the sums.
+export function buildCostToLandQuery(foreign: ForeignReads) {
+  return defineQuery({
+    name: 'boxxy_cost_to_land',
+    description:
+      'Returns what one boxxy item cost to land: the model requests, tokens and cost of every attempt at the item, per phase, product and model, with rework apart. `landedAt` is null until a pull request of the item merges.',
+    input: z.object({ item: z.string().describe('The item, as `boxxy:item:<id>`') }),
+    output: costToLandSchema,
+    reads: [
+      boxxyWorkConsumer,
+      foreign.telemetryModelRequest,
+      foreign.telemetryTurnCost,
+      foreign.githubPullRequest,
+    ],
+    handler: async (call) => {
+      const item = findItemEntityID(call.input.item);
+
+      if (item === undefined) {
+        return buildCostToLand({
+          item: call.input.item,
+          attempts: [],
+          bindings: [],
+          requests: [],
+          turns: [],
+          pullRequests: [],
+        });
+      }
+
+      return buildCostToLand({ item: call.input.item, ...(await readCostRows(call.db, item)) });
+    },
+  });
+}
+
+type CostDB = QueryCall<
+  unknown,
+  readonly [
+    typeof boxxyWorkConsumer,
+    TelemetryModelRequestConsumer,
+    TelemetryTurnCostConsumer,
+    GithubPullRequestConsumer,
+  ]
+>['db'];
+
+async function readCostRows(db: CostDB, item: EntityID) {
+  const sessions = db
+    .selectFrom('boxxy_attempt_session as own')
+    .innerJoin('boxxy_attempt as attempt', 'attempt.id', 'own.attempt_id')
+    .where('attempt.item_id', '=', item)
+    .select('own.session_id');
+
+  const attempts = await db
+    .selectFrom('boxxy_attempt')
+    .where('item_id', '=', item)
+    .select([
+      'id',
+      'phase',
+      'number',
+      'round',
+      'state',
+      'outcome',
+      'failure',
+      'claimed_at',
+      'ended_at',
+      'sleeps',
+    ])
+    .orderBy('number')
+    .orderBy('id')
+    .execute();
+
+  const bindings = await db
+    .selectFrom('boxxy_attempt_session')
+    .where('session_id', 'in', sessions)
+    .select(['attempt_id', 'session_id', 'bound_at', 'caller_issuer', 'caller_subject'])
+    .execute();
+
+  const requests = await db
+    .selectFrom('telemetry_model_request')
+    .where('session_id', 'in', sessions)
+    .select([
+      'session_id',
+      'origin_issuer',
+      'origin_subject',
+      'product',
+      'model',
+      'cost_basis',
+      'cost_usd',
+      'input_tokens',
+      'cache_read_tokens',
+      'cache_creation_tokens',
+      'output_tokens',
+      'at',
+    ])
+    .execute();
+
+  const turns = await db
+    .selectFrom('telemetry_turn_cost')
+    .where('session_id', 'in', sessions)
+    .select(['session_id', 'origin_issuer', 'origin_subject', 'product', 'model', 'cost_usd', 'at'])
+    .execute();
+
+  const pullRequests = await db
+    .selectFrom('link_effective as produced')
+    .innerJoin('boxxy_attempt as attempt', 'attempt.id', 'produced.from_id')
+    .leftJoin('github_pull_request as pull_request', 'pull_request.id', 'produced.to_id')
+    .where('produced.type', '=', 'produced')
+    .where('attempt.item_id', '=', item)
+    .select(['produced.to_id as id', 'pull_request.merged_at'])
+    .distinct()
+    .execute();
+
+  return { attempts, bindings, requests, turns, pullRequests };
+}

package/src/queries/build-cost-to-land.ts

@@ -0,0 +1,226 @@
+import type { CostToLand } from '@boxxy/model';
+import { noCapacityFailure } from './constants.ts';
+import type {
+  AttemptReadRow,
+  BindingReadRow,
+  PullRequestReadRow,
+  RequestReadRow,
+  TurnReadRow,
+} from './types.ts';
+
+interface CostParts {
+  readonly item: string;
+  readonly attempts: readonly AttemptReadRow[];
+  readonly bindings: readonly BindingReadRow[];
+  readonly requests: readonly RequestReadRow[];
+  readonly turns: readonly TurnReadRow[];
+  readonly pullRequests: readonly PullRequestReadRow[];
+}
+
+// What one item cost to land, from the rows its statements read. Every attempt of the item counts,
+// whatever its state or outcome, but a `no-capacity` one. Each telemetry row counts for at most one
+// attempt, by the rule of `findOwner`.
+export function buildCostToLand(parts: CostParts): CostToLand {
+  const attempts = parts.attempts.filter((attempt) => attempt.failure !== noCapacityFailure);
+  const owners = { attempts, bindings: parts.bindings };
+  const requestLines = collectRequestLines(owners, parts.requests);
+  const turnLines = collectTurnLines(owners, parts.turns);
+  const lines = [...requestLines, ...turnLines];
+
+  return {
+    item: parts.item,
+    landedAt: findLandedAt(parts.pullRequests),
+    attempts: attempts.length,
+    lines,
+    totals: {
+      requests: sumOf(lines.map((line) => line.requests)),
+      costUSD: sumOf(lines.map((line) => line.costUSD ?? 0)),
+      reworkCostUSD: sumOf(lines.filter((line) => line.rework).map((line) => line.costUSD ?? 0)),
+      requestsWithoutCost: countRequestsWithoutCost(requestLines, turnLines),
+    },
+  };
+}
+
+type CostLine = CostToLand['lines'][number];
+
+interface Owners {
+  readonly attempts: readonly AttemptReadRow[];
+  readonly bindings: readonly BindingReadRow[];
+}
+
+// One line per phase, rework flag, product, model and cost basis. A group whose every cost is
+// unknown has a null cost, never 0.
+function collectRequestLines(owners: Owners, requests: readonly RequestReadRow[]): CostLine[] {
+  const lines = new Map<string, CostLine>();
+
+  for (const request of requests) {
+    const attempt = findOwner(owners, request);
+
+    if (attempt !== undefined) {
+      const costBasis = pickRequestBasis(request.cost_basis);
+      const rework = attempt.round > 1;
+
+      const key = JSON.stringify([
+        attempt.phase,
+        rework,
+        request.product,
+        request.model,
+        costBasis,
+      ]);
+
+      const line = lines.get(key) ?? {
+        phase: attempt.phase,
+        rework,
+        product: request.product,
+        model: request.model,
+        requests: 0,
+        inputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        outputTokens: 0,
+        costUSD: null,
+        costBasis,
+      };
+
+      lines.set(key, {
+        ...line,
+        requests: line.requests + 1,
+        inputTokens: line.inputTokens + request.input_tokens,
+        cacheReadTokens: line.cacheReadTokens + request.cache_read_tokens,
+        cacheCreationTokens: line.cacheCreationTokens + request.cache_creation_tokens,
+        outputTokens: line.outputTokens + request.output_tokens,
+        costUSD: request.cost_usd === null ? line.costUSD : (line.costUSD ?? 0) + request.cost_usd,
+      });
+    }
+  }
+
+  return [...lines.values()].toSorted(compareLines);
+}
+
+interface TelemetryRow {
+  readonly session_id: string;
+  readonly origin_issuer: string | null;
+  readonly origin_subject: string | null;
+  readonly at: string;
+}
+
+// The attempt that owns the row's time in its session, when the row's proven origin is that
+// attempt's caller. Times compare as instants: GitHub and some telemetry write `…:00Z`, and boxxy
+// `…:00.000Z`, so a text compare would misorder them.
+function findOwner(owners: Owners, row: TelemetryRow): AttemptReadRow | undefined {
+  const bindings = owners.bindings
+    .filter((binding) => binding.session_id === row.session_id)
+    .toSorted(
+      (left, right) =>
+        Date.parse(left.bound_at) - Date.parse(right.bound_at) ||
+        compareText(left.attempt_id, right.attempt_id),
+    );
+
+  const at = Date.parse(row.at);
+  const owner = bindings.findLast((binding) => Date.parse(binding.bound_at) <= at) ?? bindings[0];
+
+  if (
+    owner === undefined ||
+    owner.caller_issuer === null ||
+    owner.caller_issuer !== row.origin_issuer ||
+    owner.caller_subject !== row.origin_subject
+  ) {
+    return undefined;
+  }
+
+  return owners.attempts.find((attempt) => attempt.id === owner.attempt_id);
+}
+
+function compareText(left: string, right: string): number {
+  if (left === right) {
+    return 0;
+  }
+
+  return left < right ? -1 : 1;
+}
+
+// `reported` and `none` are the values of the telemetry table's `cost_basis`.
+function pickRequestBasis(basis: string): 'reported' | 'none' {
+  if (basis === 'reported' || basis === 'none') {
+    return basis;
+  }
+
+  throw new Error(
+    `a model request has the cost basis ${basis}, which the cost query does not know`,
+  );
+}
+
+// phase, rework, product, model with a null model first, then the cost basis
+function compareLines(left: CostLine, right: CostLine): number {
+  return (
+    compareText(left.phase, right.phase) ||
+    Number(left.rework) - Number(right.rework) ||
+    compareText(left.product, right.product) ||
+    compareText(left.model ?? '', right.model ?? '') ||
+    compareText(left.costBasis, right.costBasis)
+  );
+}
+
+// One `turn` line per phase, rework flag, product and model: a turn cost has no token count.
+function collectTurnLines(owners: Owners, turns: readonly TurnReadRow[]): CostLine[] {
+  const lines = new Map<string, CostLine>();
+
+  for (const turn of turns) {
+    const attempt = findOwner(owners, turn);
+
+    if (attempt !== undefined) {
+      const rework = attempt.round > 1;
+      const key = JSON.stringify([attempt.phase, rework, turn.product, turn.model]);
+      const line = lines.get(key);
+
+      lines.set(key, {
+        phase: attempt.phase,
+        rework,
+        product: turn.product,
+        model: turn.model,
+        requests: 0,
+        inputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        outputTokens: 0,
+        costUSD: (line?.costUSD ?? 0) + turn.cost_usd,
+        costBasis: 'turn',
+      });
+    }
+  }
+
+  return [...lines.values()].toSorted(compareLines);
+}
+
+// The earliest merge of a pull request that an attempt of the item produced: when the item
+// landed. null: it has not landed, and the lines are its cost so far.
+function findLandedAt(pullRequests: readonly PullRequestReadRow[]): string | null {
+  const merges = pullRequests
+    .map((pullRequest) => pullRequest.merged_at)
+    .filter((mergedAt) => mergedAt !== null)
+    .toSorted((left, right) => Date.parse(left) - Date.parse(right));
+
+  return merges[0] ?? null;
+}
+
+function sumOf(values: readonly number[]): number {
+  return values.reduce((sum, value) => sum + value, 0);
+}
+
+// The requests on `none` lines whose phase, rework flag and product have no `turn` line, of any
+// model: their cost is in neither table, and above 0 the total is a lower bound.
+function countRequestsWithoutCost(
+  requestLines: readonly CostLine[],
+  turnLines: readonly CostLine[],
+): number {
+  const covered = new Set(
+    turnLines.map((line) => JSON.stringify([line.phase, line.rework, line.product])),
+  );
+
+  return sumOf(
+    requestLines
+      .filter((line) => line.costBasis === 'none')
+      .filter((line) => !covered.has(JSON.stringify([line.phase, line.rework, line.product])))
+      .map((line) => line.requests),
+  );
+}

package/src/queries/build-stage-time-query.ts

@@ -0,0 +1,59 @@
+import { stageTimeSchema } from '@boxxy/model';
+import { defineQuery } from '@pepys/kit';
+import { z } from 'zod';
+import { boxxyWorkConsumer } from '../work/boxxy-work-consumer.ts';
+import { buildStageTime } from './build-stage-time.ts';
+import { findItemEntityID } from './find-item-entity-id.ts';
+import type { DeliveryReads, StageTimeReads } from './types.ts';
+
+// The stage-time query: the item's attempts, and the delivery times of each pull request an
+// attempt produced. Two statements, so an item with no pull request still has its phase times.
+export function buildStageTimeQuery(delivery: DeliveryReads) {
+  const reads: StageTimeReads = [boxxyWorkConsumer, ...delivery.consumers];
+
+  return defineQuery({
+    name: 'boxxy_stage_time',
+    description:
+      'Returns how long one boxxy item took in each of seven steps (triage, design, build, review, merge, release, deploy), its rework rounds and time, its wait for review and its sleep time. A step that has not happened has null minutes.',
+    input: z.object({
+      item: z.string().describe('The item, as `boxxy:item:<id>`'),
+      environment: z.string().describe('The environment whose deploy counts, such as `production`'),
+    }),
+    output: stageTimeSchema,
+    reads,
+    handler: async (call) => {
+      const item = findItemEntityID(call.input.item);
+      const parts = { item: call.input.item, environment: call.input.environment };
+
+      if (item === undefined) {
+        return buildStageTime({ ...parts, attempts: [], deliveries: [] });
+      }
+
+      const attempts = await call.db
+        .selectFrom('boxxy_attempt')
+        .where('item_id', '=', item)
+        .select([
+          'id',
+          'phase',
+          'number',
+          'round',
+          'state',
+          'outcome',
+          'failure',
+          'claimed_at',
+          'ended_at',
+          'sleeps',
+        ])
+        .orderBy('number')
+        .orderBy('id')
+        .execute();
+
+      const deliveries = await delivery.readDeliveries(call.db, {
+        item,
+        environment: call.input.environment,
+      });
+
+      return buildStageTime({ ...parts, attempts, deliveries });
+    },
+  });
+}

package/src/queries/build-stage-time.ts

@@ -0,0 +1,195 @@
+import { phaseSteps } from '@boxxy/model';
+import type { StageTime } from '@boxxy/model';
+import { z } from 'zod';
+import { noCapacityFailure, outcomeNames } from './constants.ts';
+import type { AttemptReadRow, DeliveryReadRow } from './types.ts';
+
+interface StageParts {
+  readonly item: string;
+  readonly environment: string;
+  readonly attempts: readonly AttemptReadRow[];
+  readonly deliveries: readonly DeliveryReadRow[];
+}
+
+// How long one item took in each step. A `no-capacity` attempt ran no session, so it is in no
+// measure. Every other attempt counts by `ended_at` alone, a `usage-limit`, a lost and an
+// unsettleable one too: the time was spent.
+export function buildStageTime(parts: StageParts): StageTime {
+  const attempts = parts.attempts
+    .filter((attempt) => attempt.failure !== noCapacityFailure)
+    .map((attempt) => toMeasuredAttempt(attempt));
+
+  const settled = attempts.filter((attempt) => attempt.ended_at !== null);
+
+  const phases = phaseSteps.map((step) =>
+    buildPhaseStep(
+      step,
+      settled.filter((attempt) => attempt.phase === step),
+    ),
+  );
+
+  return {
+    item: parts.item,
+    environment: parts.environment,
+    steps: [...phases, ...buildDeliverySteps(settled, parts.deliveries)],
+    rework: {
+      count: settled.filter(
+        (attempt) =>
+          attempt.phase === 'review' && attempt.outcome === outcomeNames.changesRequested,
+      ).length,
+      minutes: sumOf(
+        settled
+          .filter((attempt) => attempt.round > 1)
+          .map((attempt) => measureAttemptMinutes(attempt)),
+      ),
+    },
+    reviewWaitMinutes: measureReviewWait(attempts),
+    sleepMinutes: sumOf(
+      attempts.flatMap((attempt) => attempt.stretches.map((stretch) => measureStretch(stretch))),
+    ),
+    pullRequests: [...new Set(parts.deliveries.map((delivery) => delivery.pullRequest))].toSorted(),
+  };
+}
+
+interface SleepStretch {
+  readonly from: string;
+  readonly to: string | null;
+}
+
+interface MeasuredAttempt extends AttemptReadRow {
+  readonly stretches: readonly SleepStretch[];
+}
+
+function toMeasuredAttempt(attempt: AttemptReadRow): MeasuredAttempt {
+  return { ...attempt, stretches: parseSleeps(attempt.sleeps) };
+}
+
+const sleepsSchema = z.array(z.object({ from: z.string(), to: z.string().nullable() }));
+
+// A JSON column comes back as text from one store and as the parsed list from another.
+function parseSleeps(sleeps: unknown): SleepStretch[] {
+  const value: unknown = typeof sleeps === 'string' ? JSON.parse(sleeps) : sleeps;
+
+  return sleepsSchema.parse(value);
+}
+
+type Step = StageTime['steps'][number];
+
+// A phase's minutes: the sum, over its settled attempts, of claim to end less the attempt's
+// sleep. null when none has settled. Its end is the latest end of the phase.
+function buildPhaseStep(
+  step: (typeof phaseSteps)[number],
+  settled: readonly MeasuredAttempt[],
+): Step {
+  if (settled.length === 0) {
+    return { step, minutes: null, endedAt: null };
+  }
+
+  return {
+    step,
+    minutes: sumOf(settled.map((attempt) => measureAttemptMinutes(attempt))),
+    endedAt: findLatest(settled.map((attempt) => attempt.ended_at)),
+  };
+}
+
+function sumOf(values: readonly number[]): number {
+  return values.reduce((sum, value) => sum + value, 0);
+}
+
+function measureAttemptMinutes(attempt: MeasuredAttempt): number {
+  const sleptMinutes = sumOf(attempt.stretches.map((stretch) => measureStretch(stretch)));
+
+  return measureMinutes(attempt.claimed_at, attempt.ended_at) - sleptMinutes;
+}
+
+// An open stretch counts 0: the query reads no clock.
+function measureStretch(stretch: SleepStretch): number {
+  return measureMinutes(stretch.from, stretch.to);
+}
+
+function measureMinutes(from: string, to: string | null): number {
+  return to === null ? 0 : (Date.parse(to) - Date.parse(from)) / 60_000;
+}
+
+function findLatest(times: readonly (string | null)[]): string | null {
+  return pickTime(times, (left, right) => left > right);
+}
+
+function pickTime(
+  times: readonly (string | null)[],
+  isBetter: (left: number, right: number) => boolean,
+): string | null {
+  let best: string | null = null;
+
+  for (const time of times) {
+    if (time !== null && (best === null || isBetter(Date.parse(time), Date.parse(best)))) {
+      best = time;
+    }
+  }
+
+  return best;
+}
+
+// Merge starts at the latest end of a review that passed. A review that settled `unsettleable`
+// starts no merge step: boxxy could not read whether it passed. Release and deploy start at the
+// step before. An item with two pull requests takes the earliest of each time.
+function buildDeliverySteps(
+  settled: readonly MeasuredAttempt[],
+  deliveries: readonly DeliveryReadRow[],
+): Step[] {
+  const passed = findLatest(
+    settled
+      .filter((attempt) => attempt.phase === 'review' && attempt.outcome === outcomeNames.passed)
+      .map((attempt) => attempt.ended_at),
+  );
+
+  const mergedAt = findEarliest(deliveries.map((delivery) => delivery.mergedAt));
+  const releasedAt = findEarliest(deliveries.map((delivery) => delivery.release?.at ?? null));
+  const deployedAt = findEarliest(deliveries.map((delivery) => delivery.deploy?.at ?? null));
+
+  return [
+    buildDeliveryStep('merge', passed, mergedAt),
+    buildDeliveryStep('release', mergedAt, releasedAt),
+    buildDeliveryStep('deploy', releasedAt, deployedAt),
+  ];
+}
+
+function findEarliest(times: readonly (string | null)[]): string | null {
+  return pickTime(times, (left, right) => left < right);
+}
+
+function buildDeliveryStep(step: Step['step'], from: string | null, to: string | null): Step {
+  return {
+    step,
+    minutes: from === null || to === null ? null : Math.max(0, measureMinutes(from, to)),
+    endedAt: to,
+  };
+}
+
+interface SettledAttempt extends MeasuredAttempt {
+  readonly ended_at: string;
+}
+
+// For each settled build that was built: the claim of the review claimed next at or after the
+// build's end, less that end. An attempt's number counts within its phase, so it cannot order a
+// build against a review. null when no build has a review after it.
+function measureReviewWait(attempts: readonly MeasuredAttempt[]): number | null {
+  const waits = attempts
+    .filter((attempt): attempt is SettledAttempt => attempt.ended_at !== null)
+    .filter((build) => build.phase === 'build' && build.outcome === outcomeNames.built)
+    .flatMap((build) => {
+      const [review] = attempts
+        .filter(
+          (attempt) =>
+            attempt.phase === 'review' && measureMinutes(build.ended_at, attempt.claimed_at) >= 0,
+        )
+        .toSorted(
+          (left, right) =>
+            measureMinutes(right.claimed_at, left.claimed_at) || left.id.localeCompare(right.id),
+        );
+
+      return review === undefined ? [] : [measureMinutes(build.ended_at, review.claimed_at)];
+    });
+
+  return waits.length === 0 ? null : sumOf(waits);
+}