@swarmclawai/swarmclaw 1.9.6 → 1.9.8

package/src/lib/quality/release-readiness.test.ts

@@ -0,0 +1,129 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { buildReleaseReadinessReport } from './release-readiness'
+import type { EvalGateResult } from '@/lib/server/eval/types'
+import type { OperationPulse } from '@/types'
+
+const now = 100_000
+
+function pulse(overrides: Partial<OperationPulse> = {}): OperationPulse {
+  return {
+    generatedAt: now,
+    range: '24h',
+    windowStart: now - 86_400_000,
+    kpis: {
+      activeMissions: 0,
+      runningRuns: 0,
+      failedRuns: 0,
+      pendingApprovals: 0,
+      connectorAttention: 0,
+      gatewayAttention: 0,
+      budgetWarnings: 0,
+    },
+    actions: [],
+    ...overrides,
+  }
+}
+
+function evalGate(overrides: Partial<EvalGateResult> = {}): EvalGateResult {
+  return {
+    agentId: 'agent_1',
+    scope: {
+      type: 'suite',
+      id: 'core',
+      label: 'core',
+      scenarioIds: ['coding-prime'],
+    },
+    status: 'pass',
+    generatedAt: now,
+    baseline: null,
+    latestRuns: [],
+    currentScore: 10,
+    currentMaxScore: 10,
+    currentPercent: 100,
+    regressionPoints: 0,
+    minPercent: 80,
+    maxRegressionPoints: 5,
+    checks: [{ code: 'score_threshold_met', status: 'pass', message: 'Current score meets the 80% gate.' }],
+    ...overrides,
+  }
+}
+
+describe('release readiness report', () => {
+  it('passes when eval gate and operations pulse are clean', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse(),
+      evalGate: evalGate(),
+    })
+
+    assert.equal(report.status, 'ready')
+    assert.equal(report.score, 100)
+    assert.equal(report.blockerCount, 0)
+    assert.equal(report.warningCount, 0)
+    assert.ok(report.checks.some((check) => check.code === 'eval_gate_passed'))
+  })
+
+  it('warns when no eval gate is selected', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse(),
+      evalGate: null,
+    })
+
+    assert.equal(report.status, 'warning')
+    assert.equal(report.blockerCount, 0)
+    assert.equal(report.warningCount, 1)
+    assert.ok(report.score < 100)
+    assert.ok(report.checks.some((check) => check.code === 'eval_gate_missing'))
+  })
+
+  it('blocks when eval regression gate fails', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse(),
+      evalGate: evalGate({
+        status: 'fail',
+        currentPercent: 60,
+        checks: [{ code: 'score_below_threshold', status: 'fail', message: 'Current score is below the 80% gate.' }],
+      }),
+    })
+
+    assert.equal(report.status, 'blocked')
+    assert.equal(report.blockerCount, 1)
+    assert.ok(report.score <= 70)
+    assert.ok(report.checks.some((check) => check.code === 'eval_gate_failed'))
+  })
+
+  it('blocks on failed runs and pending approvals, then surfaces pulse actions', () => {
+    const report = buildReleaseReadinessReport({
+      pulse: pulse({
+        kpis: {
+          activeMissions: 1,
+          runningRuns: 1,
+          failedRuns: 2,
+          pendingApprovals: 3,
+          connectorAttention: 1,
+          gatewayAttention: 1,
+          budgetWarnings: 1,
+        },
+        actions: [{
+          id: 'run:failed',
+          kind: 'run',
+          severity: 'high',
+          title: 'Review failed run',
+          summary: 'Run failed',
+          href: '/quality?tab=runs',
+          evidence: ['run'],
+          createdAt: now,
+        }],
+      }),
+      evalGate: evalGate(),
+    })
+
+    assert.equal(report.status, 'blocked')
+    assert.equal(report.blockerCount, 2)
+    assert.ok(report.warningCount >= 4)
+    assert.equal(report.nextActions[0]?.id, 'run:failed')
+    assert.ok(report.checks.some((check) => check.code === 'failed_runs_present'))
+    assert.ok(report.checks.some((check) => check.code === 'pending_approvals_present'))
+  })
+})

package/src/lib/quality/release-readiness.ts

@@ -0,0 +1,187 @@
+import type { EvalGateResult } from '@/lib/server/eval/types'
+import type { OperationPulse, OperationPulseAction, OperationPulseRange } from '@/types'
+
+export type ReleaseReadinessStatus = 'ready' | 'warning' | 'blocked'
+
+export interface ReleaseReadinessCheck {
+  code: string
+  status: ReleaseReadinessStatus
+  title: string
+  summary: string
+  href?: string
+  evidence?: string[]
+}
+
+export interface ReleaseReadinessReport {
+  generatedAt: number
+  range: OperationPulseRange
+  status: ReleaseReadinessStatus
+  score: number
+  blockerCount: number
+  warningCount: number
+  pulse: OperationPulse
+  evalGate: EvalGateResult | null
+  checks: ReleaseReadinessCheck[]
+  nextActions: OperationPulseAction[]
+}
+
+const BLOCKER_PENALTY = 30
+const WARNING_PENALTY = 10
+
+function readinessStatus(checks: ReleaseReadinessCheck[]): ReleaseReadinessStatus {
+  if (checks.some((check) => check.status === 'blocked')) return 'blocked'
+  if (checks.some((check) => check.status === 'warning')) return 'warning'
+  return 'ready'
+}
+
+function readinessScore(checks: ReleaseReadinessCheck[]): number {
+  const penalty = checks.reduce((sum, check) => {
+    if (check.status === 'blocked') return sum + BLOCKER_PENALTY
+    if (check.status === 'warning') return sum + WARNING_PENALTY
+    return sum
+  }, 0)
+  return Math.max(0, 100 - penalty)
+}
+
+function plural(count: number, singular: string, pluralLabel = `${singular}s`): string {
+  return `${count} ${count === 1 ? singular : pluralLabel}`
+}
+
+function addCheck(checks: ReleaseReadinessCheck[], check: ReleaseReadinessCheck): void {
+  checks.push(check)
+}
+
+export function buildReleaseReadinessReport(input: {
+  pulse: OperationPulse
+  evalGate?: EvalGateResult | null
+}): ReleaseReadinessReport {
+  const checks: ReleaseReadinessCheck[] = []
+  const evalGate = input.evalGate ?? null
+
+  if (!evalGate) {
+    addCheck(checks, {
+      code: 'eval_gate_missing',
+      status: 'warning',
+      title: 'Select an eval gate',
+      summary: 'No eval regression gate is included in this readiness report.',
+      href: '/quality?tab=evals',
+    })
+  } else if (evalGate.status === 'fail') {
+    addCheck(checks, {
+      code: 'eval_gate_failed',
+      status: 'blocked',
+      title: 'Eval gate failed',
+      summary: `${evalGate.scope.label} is not passing the configured eval release gate.`,
+      href: '/quality?tab=evals',
+      evidence: evalGate.checks
+        .filter((check) => check.status === 'fail')
+        .map((check) => check.message),
+    })
+  } else if (evalGate.status === 'warn') {
+    addCheck(checks, {
+      code: 'eval_gate_warning',
+      status: 'warning',
+      title: 'Eval gate needs a baseline',
+      summary: `${evalGate.scope.label} passes the score threshold but still has release-gate warnings.`,
+      href: '/quality?tab=evals',
+      evidence: evalGate.checks
+        .filter((check) => check.status === 'warn')
+        .map((check) => check.message),
+    })
+  } else {
+    addCheck(checks, {
+      code: 'eval_gate_passed',
+      status: 'ready',
+      title: 'Eval gate passed',
+      summary: `${evalGate.scope.label} meets the configured score and regression checks.`,
+      href: '/quality?tab=evals',
+      evidence: [`${evalGate.currentPercent ?? 'n/a'}% current score`],
+    })
+  }
+
+  if (input.pulse.kpis.failedRuns > 0) {
+    addCheck(checks, {
+      code: 'failed_runs_present',
+      status: 'blocked',
+      title: 'Failed runs need review',
+      summary: `${plural(input.pulse.kpis.failedRuns, 'failed run')} found in the ${input.pulse.range} operations window.`,
+      href: '/quality?tab=runs',
+    })
+  }
+
+  if (input.pulse.kpis.pendingApprovals > 0) {
+    addCheck(checks, {
+      code: 'pending_approvals_present',
+      status: 'blocked',
+      title: 'Pending approvals need decisions',
+      summary: `${plural(input.pulse.kpis.pendingApprovals, 'approval')} still waiting on an operator.`,
+      href: '/quality?tab=approvals',
+    })
+  }
+
+  if (input.pulse.kpis.runningRuns > 0) {
+    addCheck(checks, {
+      code: 'active_runs_present',
+      status: 'warning',
+      title: 'Runs are still active',
+      summary: `${plural(input.pulse.kpis.runningRuns, 'run')} queued or running while this report was generated.`,
+      href: '/runs',
+    })
+  }
+
+  if (input.pulse.kpis.connectorAttention > 0) {
+    addCheck(checks, {
+      code: 'connector_attention_present',
+      status: 'warning',
+      title: 'Connector readiness needs attention',
+      summary: `${plural(input.pulse.kpis.connectorAttention, 'connector')} reporting degraded readiness.`,
+      href: '/connectors',
+    })
+  }
+
+  if (input.pulse.kpis.gatewayAttention > 0) {
+    addCheck(checks, {
+      code: 'gateway_attention_present',
+      status: 'warning',
+      title: 'Gateway readiness needs attention',
+      summary: `${plural(input.pulse.kpis.gatewayAttention, 'gateway')} reporting topology or environment warnings.`,
+      href: '/providers',
+    })
+  }
+
+  if (input.pulse.kpis.budgetWarnings > 0) {
+    addCheck(checks, {
+      code: 'budget_warnings_present',
+      status: 'warning',
+      title: 'Mission budget pressure',
+      summary: `${plural(input.pulse.kpis.budgetWarnings, 'mission')} near a configured budget limit.`,
+      href: '/missions',
+    })
+  }
+
+  if (input.pulse.kpis.activeMissions > 0) {
+    addCheck(checks, {
+      code: 'active_missions_present',
+      status: 'warning',
+      title: 'Missions are still active',
+      summary: `${plural(input.pulse.kpis.activeMissions, 'mission')} running or paused in the operations window.`,
+      href: '/missions',
+    })
+  }
+
+  const blockerCount = checks.filter((check) => check.status === 'blocked').length
+  const warningCount = checks.filter((check) => check.status === 'warning').length
+
+  return {
+    generatedAt: input.pulse.generatedAt,
+    range: input.pulse.range,
+    status: readinessStatus(checks),
+    score: readinessScore(checks),
+    blockerCount,
+    warningCount,
+    pulse: input.pulse,
+    evalGate,
+    checks,
+    nextActions: input.pulse.actions.slice(0, 8),
+  }
+}

package/src/lib/server/eval/baseline.test.ts

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import {
+  evaluateEvalGate,
+  setEvalBaseline,
+} from './baseline'
+import type { EvalBaseline, EvalRun } from './types'
+
+function makeRun(overrides: Partial<EvalRun> = {}): EvalRun {
+  return {
+    id: 'run-1',
+    scenarioId: 'coding-prime',
+    agentId: 'agent-1',
+    status: 'completed',
+    startedAt: 1,
+    endedAt: 2,
+    score: 8,
+    maxScore: 10,
+    details: [],
+    ...overrides,
+  }
+}
+
+function depsFor(runs: EvalRun[], baseline: EvalBaseline | null = null, saved: EvalBaseline[] = []) {
+  return {
+    now: () => 123,
+    listRunsByAgent: (agentId: string) => runs.filter((run) => run.agentId === agentId),
+    getBaselineForScope: () => baseline,
+    saveBaseline: (next: EvalBaseline) => { saved.push(next) },
+  }
+}
+
+test('setEvalBaseline snapshots the latest scenario score and gate defaults', () => {
+  const saved: EvalBaseline[] = []
+  const baseline = setEvalBaseline(
+    {
+      agentId: 'agent-1',
+      scenarioId: 'coding-prime',
+      minPercent: 75,
+      maxRegressionPoints: 3,
+      label: 'Release candidate',
+    },
+    depsFor([
+      makeRun({ id: 'older', score: 4, startedAt: 1, endedAt: 2 }),
+      makeRun({ id: 'latest', score: 8, startedAt: 5, endedAt: 6 }),
+    ], null, saved),
+  )
+
+  assert.equal(saved.length, 1)
+  assert.equal(baseline.scope.type, 'scenario')
+  assert.equal(baseline.scope.id, 'coding-prime')
+  assert.equal(baseline.baselinePercent, 80)
+  assert.equal(baseline.minPercent, 75)
+  assert.equal(baseline.maxRegressionPoints, 3)
+  assert.deepEqual(baseline.runIds, ['latest'])
+})
+
+test('evaluateEvalGate warns until a baseline is approved', () => {
+  const gate = evaluateEvalGate(
+    { agentId: 'agent-1', scenarioId: 'coding-prime', minPercent: 70 },
+    depsFor([makeRun({ score: 8, maxScore: 10 })]),
+  )
+
+  assert.equal(gate.currentPercent, 80)
+  assert.equal(gate.status, 'warn')
+  assert.ok(gate.checks.some((check) => check.code === 'baseline_missing' && check.status === 'warn'))
+})
+
+test('evaluateEvalGate fails when regression exceeds the baseline allowance', () => {
+  const baseline = setEvalBaseline(
+    { agentId: 'agent-1', scenarioId: 'coding-prime', minPercent: 70, maxRegressionPoints: 2 },
+    depsFor([makeRun({ id: 'baseline', score: 9, maxScore: 10 })]),
+  )
+
+  const gate = evaluateEvalGate(
+    { agentId: 'agent-1', scenarioId: 'coding-prime' },
+    depsFor([makeRun({ id: 'current', score: 6, maxScore: 10, startedAt: 10, endedAt: 11 })], baseline),
+  )
+
+  assert.equal(gate.currentPercent, 60)
+  assert.equal(gate.regressionPoints, 30)
+  assert.equal(gate.status, 'fail')
+  assert.ok(gate.checks.some((check) => check.code === 'regression_limit_exceeded'))
+})
+
+test('evaluateEvalGate passes when score and regression checks pass', () => {
+  const baseline = setEvalBaseline(
+    { agentId: 'agent-1', scenarioId: 'coding-prime', minPercent: 70, maxRegressionPoints: 5 },
+    depsFor([makeRun({ id: 'baseline', score: 8, maxScore: 10 })]),
+  )
+
+  const gate = evaluateEvalGate(
+    { agentId: 'agent-1', scenarioId: 'coding-prime' },
+    depsFor([makeRun({ id: 'current', score: 8, maxScore: 10, startedAt: 10, endedAt: 11 })], baseline),
+  )
+
+  assert.equal(gate.status, 'pass')
+  assert.equal(gate.regressionPoints, 0)
+  assert.ok(gate.checks.some((check) => check.code === 'score_threshold_met'))
+})
+
+test('suite gates require latest runs for every scenario in scope before baselining', () => {
+  assert.throws(
+    () => setEvalBaseline(
+      { agentId: 'agent-1', suite: 'core' },
+      depsFor([makeRun({ scenarioId: 'coding-prime' })]),
+    ),
+    /Baseline requires latest runs for every scenario in scope/,
+  )
+})

package/src/lib/server/eval/baseline.ts

@@ -0,0 +1,274 @@
+import {
+  getEvalBaselineForScope,
+  listEvalBaselines,
+  listEvalRunsByAgent,
+  saveEvalBaseline,
+} from './store'
+import { getScenario, getSuiteScenarios } from './scenarios'
+import type {
+  EvalBaseline,
+  EvalGateCheck,
+  EvalGateResult,
+  EvalGateScope,
+  EvalGateScopeType,
+  EvalRun,
+} from './types'
+
+const DEFAULT_MIN_PERCENT = 80
+const DEFAULT_MAX_REGRESSION_POINTS = 5
+const MAX_LOOKBACK_RUNS = 1_000
+
+export interface EvalGateInput {
+  agentId: string
+  scenarioId?: string | null
+  suite?: string | null
+  minPercent?: number | null
+  maxRegressionPoints?: number | null
+}
+
+export interface SetEvalBaselineInput extends EvalGateInput {
+  label?: string | null
+  notes?: string | null
+}
+
+interface EvalGateDeps {
+  now?: () => number
+  listRunsByAgent?: (agentId: string, limit: number) => EvalRun[]
+  getBaselineForScope?: (agentId: string, scopeType: EvalGateScopeType, scopeId: string) => EvalBaseline | null
+  saveBaseline?: (baseline: EvalBaseline) => void
+  listBaselines?: (filters?: { agentId?: string; limit?: number }) => EvalBaseline[]
+}
+
+interface EvalAggregate {
+  runs: EvalRun[]
+  missingScenarioIds: string[]
+  score: number
+  maxScore: number
+  percent: number | null
+}
+
+function normalizePercent(value: number | null | undefined, fallback: number): number {
+  if (!Number.isFinite(value) || value == null) return fallback
+  return Math.max(0, Math.min(100, Math.round(value)))
+}
+
+function normalizeRegressionPoints(value: number | null | undefined, fallback: number): number {
+  if (!Number.isFinite(value) || value == null) return fallback
+  return Math.max(0, Math.round(value))
+}
+
+function scorePercent(score: number, maxScore: number): number | null {
+  if (!Number.isFinite(score) || !Number.isFinite(maxScore) || maxScore <= 0) return null
+  return Math.round((score / maxScore) * 100)
+}
+
+function maxScoreForScenario(scenarioId: string): number {
+  const scenario = getScenario(scenarioId)
+  return scenario?.scoringCriteria.reduce((sum, criterion) => sum + criterion.weight, 0) ?? 0
+}
+
+export function resolveEvalGateScope(input: Pick<EvalGateInput, 'scenarioId' | 'suite'>): EvalGateScope {
+  const scenarioId = input.scenarioId?.trim()
+  if (scenarioId) {
+    const scenario = getScenario(scenarioId)
+    if (!scenario) throw new Error(`Unknown eval scenario: ${scenarioId}`)
+    return {
+      type: 'scenario',
+      id: scenario.id,
+      label: scenario.name,
+      scenarioIds: [scenario.id],
+    }
+  }
+
+  const suite = input.suite?.trim() || 'core'
+  const scenarios = getSuiteScenarios(suite)
+  if (scenarios.length === 0) throw new Error(`Unknown or empty eval suite: ${suite}`)
+  return {
+    type: 'suite',
+    id: suite,
+    label: suite,
+    scenarioIds: scenarios.map((scenario) => scenario.id),
+  }
+}
+
+export function evalBaselineId(agentId: string, scope: EvalGateScope): string {
+  return `eval-baseline:${agentId}:${scope.type}:${scope.id}`
+}
+
+function latestRunsForScope(runs: EvalRun[], scope: EvalGateScope): EvalRun[] {
+  const scenarioSet = new Set(scope.scenarioIds)
+  const latest = new Map<string, EvalRun>()
+
+  for (const run of runs) {
+    if (!scenarioSet.has(run.scenarioId)) continue
+    if (run.status === 'pending' || run.status === 'running') continue
+    const previous = latest.get(run.scenarioId)
+    if (!previous || (run.endedAt ?? run.startedAt) > (previous.endedAt ?? previous.startedAt)) {
+      latest.set(run.scenarioId, run)
+    }
+  }
+
+  return scope.scenarioIds
+    .map((scenarioId) => latest.get(scenarioId))
+    .filter(Boolean) as EvalRun[]
+}
+
+function aggregateRuns(scope: EvalGateScope, runs: EvalRun[]): EvalAggregate {
+  const byScenario = new Map(runs.map((run) => [run.scenarioId, run]))
+  const missingScenarioIds = scope.scenarioIds.filter((scenarioId) => !byScenario.has(scenarioId))
+  const score = scope.scenarioIds.reduce((sum, scenarioId) => sum + (byScenario.get(scenarioId)?.score ?? 0), 0)
+  const maxScore = scope.scenarioIds.reduce((sum, scenarioId) => {
+    const runMaxScore = byScenario.get(scenarioId)?.maxScore
+    return sum + (Number.isFinite(runMaxScore) && runMaxScore != null ? runMaxScore : maxScoreForScenario(scenarioId))
+  }, 0)
+  return {
+    runs,
+    missingScenarioIds,
+    score,
+    maxScore,
+    percent: scorePercent(score, maxScore),
+  }
+}
+
+function statusFromChecks(checks: EvalGateCheck[]): EvalGateResult['status'] {
+  if (checks.some((check) => check.status === 'fail')) return 'fail'
+  if (checks.some((check) => check.status === 'warn')) return 'warn'
+  return 'pass'
+}
+
+export function listEvalBaselinesForAgent(agentId?: string | null, deps: EvalGateDeps = {}): EvalBaseline[] {
+  const list = deps.listBaselines || listEvalBaselines
+  return list({ agentId: agentId || undefined, limit: 200 })
+}
+
+export function setEvalBaseline(input: SetEvalBaselineInput, deps: EvalGateDeps = {}): EvalBaseline {
+  if (!input.agentId.trim()) throw new Error('agentId is required')
+
+  const now = deps.now?.() ?? Date.now()
+  const scope = resolveEvalGateScope(input)
+  const runs = latestRunsForScope(
+    (deps.listRunsByAgent || listEvalRunsByAgent)(input.agentId, MAX_LOOKBACK_RUNS),
+    scope,
+  )
+  const aggregate = aggregateRuns(scope, runs)
+  if (aggregate.runs.length === 0) {
+    throw new Error('Run the selected eval before setting a baseline.')
+  }
+  if (aggregate.missingScenarioIds.length > 0) {
+    throw new Error(`Baseline requires latest runs for every scenario in scope. Missing: ${aggregate.missingScenarioIds.join(', ')}`)
+  }
+
+  const existing = (deps.getBaselineForScope || getEvalBaselineForScope)(input.agentId, scope.type, scope.id)
+  const baseline: EvalBaseline = {
+    id: existing?.id || evalBaselineId(input.agentId, scope),
+    agentId: input.agentId,
+    scope,
+    baselineScore: aggregate.score,
+    baselineMaxScore: aggregate.maxScore,
+    baselinePercent: aggregate.percent ?? 0,
+    minPercent: normalizePercent(input.minPercent, aggregate.percent ?? DEFAULT_MIN_PERCENT),
+    maxRegressionPoints: normalizeRegressionPoints(input.maxRegressionPoints, existing?.maxRegressionPoints ?? DEFAULT_MAX_REGRESSION_POINTS),
+    runIds: aggregate.runs.map((run) => run.id),
+    label: input.label?.trim() || existing?.label || null,
+    notes: input.notes?.trim() || existing?.notes || null,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+  }
+
+  ;(deps.saveBaseline || saveEvalBaseline)(baseline)
+  return baseline
+}
+
+export function evaluateEvalGate(input: EvalGateInput, deps: EvalGateDeps = {}): EvalGateResult {
+  if (!input.agentId.trim()) throw new Error('agentId is required')
+
+  const generatedAt = deps.now?.() ?? Date.now()
+  const scope = resolveEvalGateScope(input)
+  const baseline = (deps.getBaselineForScope || getEvalBaselineForScope)(input.agentId, scope.type, scope.id)
+  const runs = latestRunsForScope(
+    (deps.listRunsByAgent || listEvalRunsByAgent)(input.agentId, MAX_LOOKBACK_RUNS),
+    scope,
+  )
+  const aggregate = aggregateRuns(scope, runs)
+  const minPercent = normalizePercent(input.minPercent, baseline?.minPercent ?? DEFAULT_MIN_PERCENT)
+  const maxRegressionPoints = normalizeRegressionPoints(input.maxRegressionPoints, baseline?.maxRegressionPoints ?? DEFAULT_MAX_REGRESSION_POINTS)
+  const regressionPoints = baseline && aggregate.percent != null
+    ? Math.max(0, baseline.baselinePercent - aggregate.percent)
+    : null
+
+  const checks: EvalGateCheck[] = []
+  if (aggregate.runs.length === 0) {
+    checks.push({
+      code: 'no_eval_runs',
+      status: 'fail',
+      message: 'No completed eval runs are available for this gate.',
+    })
+  }
+  if (aggregate.missingScenarioIds.length > 0) {
+    checks.push({
+      code: 'missing_scope_runs',
+      status: 'fail',
+      message: `${aggregate.missingScenarioIds.length} scenario${aggregate.missingScenarioIds.length === 1 ? '' : 's'} have no latest run in this gate.`,
+      detail: aggregate.missingScenarioIds.join(', '),
+    })
+  }
+  if (aggregate.runs.some((run) => run.status === 'failed')) {
+    checks.push({
+      code: 'failed_eval_run',
+      status: 'fail',
+      message: 'At least one latest eval run failed.',
+    })
+  }
+  if (aggregate.percent == null || aggregate.percent < minPercent) {
+    checks.push({
+      code: 'score_below_threshold',
+      status: 'fail',
+      message: `Current score is below the ${minPercent}% gate.`,
+      detail: aggregate.percent == null ? 'n/a' : `${aggregate.percent}%`,
+    })
+  } else {
+    checks.push({
+      code: 'score_threshold_met',
+      status: 'pass',
+      message: `Current score meets the ${minPercent}% gate.`,
+      detail: `${aggregate.percent}%`,
+    })
+  }
+  if (!baseline) {
+    checks.push({
+      code: 'baseline_missing',
+      status: 'warn',
+      message: 'No approved baseline is set for this gate.',
+    })
+  } else if (regressionPoints != null && regressionPoints > maxRegressionPoints) {
+    checks.push({
+      code: 'regression_limit_exceeded',
+      status: 'fail',
+      message: `Regression exceeds the ${maxRegressionPoints} point allowance.`,
+      detail: `${regressionPoints} points below baseline`,
+    })
+  } else if (regressionPoints != null) {
+    checks.push({
+      code: 'regression_within_limit',
+      status: 'pass',
+      message: `Regression is within the ${maxRegressionPoints} point allowance.`,
+      detail: `${regressionPoints} point${regressionPoints === 1 ? '' : 's'} below baseline`,
+    })
+  }
+
+  return {
+    agentId: input.agentId,
+    scope,
+    status: statusFromChecks(checks),
+    generatedAt,
+    baseline,
+    latestRuns: aggregate.runs,
+    currentScore: aggregate.score,
+    currentMaxScore: aggregate.maxScore,
+    currentPercent: aggregate.percent,
+    regressionPoints,
+    minPercent,
+    maxRegressionPoints,
+    checks,
+  }
+}