chainlesschain 0.66.0 → 0.132.0

package/src/lib/sso-manager.js

@@ -839,3 +839,335 @@ export function getStats(db) {
     },
   };
 }
+
+// ===== V2 Surface (cli 0.130.0) — in-memory governance =====
+export const PROVIDER_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  DEPRECATED: "deprecated",
+  RETIRED: "retired",
+});
+export const LOGIN_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  AUTHENTICATING: "authenticating",
+  AUTHENTICATED: "authenticated",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const _PM_V2 = PROVIDER_MATURITY_V2;
+const _LL_V2 = LOGIN_LIFECYCLE_V2;
+const _PM_TRANS_V2 = new Map([
+  [_PM_V2.PENDING, new Set([_PM_V2.ACTIVE, _PM_V2.RETIRED])],
+  [_PM_V2.ACTIVE, new Set([_PM_V2.DEPRECATED, _PM_V2.RETIRED])],
+  [_PM_V2.DEPRECATED, new Set([_PM_V2.ACTIVE, _PM_V2.RETIRED])],
+  [_PM_V2.RETIRED, new Set()],
+]);
+const _LL_TRANS_V2 = new Map([
+  [_LL_V2.QUEUED, new Set([_LL_V2.AUTHENTICATING, _LL_V2.CANCELLED])],
+  [
+    _LL_V2.AUTHENTICATING,
+    new Set([_LL_V2.AUTHENTICATED, _LL_V2.FAILED, _LL_V2.CANCELLED]),
+  ],
+  [_LL_V2.AUTHENTICATED, new Set()],
+  [_LL_V2.FAILED, new Set()],
+  [_LL_V2.CANCELLED, new Set()],
+]);
+const _LL_TERM_V2 = new Set([
+  _LL_V2.AUTHENTICATED,
+  _LL_V2.FAILED,
+  _LL_V2.CANCELLED,
+]);
+
+const SSO_DEFAULT_MAX_ACTIVE_PROVIDERS_PER_OWNER = 8;
+const SSO_DEFAULT_MAX_PENDING_LOGINS_PER_PROVIDER = 16;
+const SSO_DEFAULT_PROVIDER_IDLE_MS = 30 * 24 * 60 * 60 * 1000;
+const SSO_DEFAULT_LOGIN_STUCK_MS = 5 * 60 * 1000;
+
+const _ssoProvidersV2 = new Map();
+const _ssoLoginsV2 = new Map();
+let _ssoConfigV2 = {
+  maxActiveProvidersPerOwner: SSO_DEFAULT_MAX_ACTIVE_PROVIDERS_PER_OWNER,
+  maxPendingLoginsPerProvider: SSO_DEFAULT_MAX_PENDING_LOGINS_PER_PROVIDER,
+  providerIdleMs: SSO_DEFAULT_PROVIDER_IDLE_MS,
+  loginStuckMs: SSO_DEFAULT_LOGIN_STUCK_MS,
+};
+
+function _ssoPosIntV2(n, label) {
+  if (typeof n !== "number" || !isFinite(n) || isNaN(n))
+    throw new Error(`${label} must be positive integer`);
+  const v = Math.floor(n);
+  if (v <= 0) throw new Error(`${label} must be positive integer`);
+  return v;
+}
+
+export function _resetStateSsoManagerV2() {
+  _ssoProvidersV2.clear();
+  _ssoLoginsV2.clear();
+  _ssoConfigV2 = {
+    maxActiveProvidersPerOwner: SSO_DEFAULT_MAX_ACTIVE_PROVIDERS_PER_OWNER,
+    maxPendingLoginsPerProvider: SSO_DEFAULT_MAX_PENDING_LOGINS_PER_PROVIDER,
+    providerIdleMs: SSO_DEFAULT_PROVIDER_IDLE_MS,
+    loginStuckMs: SSO_DEFAULT_LOGIN_STUCK_MS,
+  };
+}
+
+export function setMaxActiveProvidersPerOwnerV2(n) {
+  _ssoConfigV2.maxActiveProvidersPerOwner = _ssoPosIntV2(
+    n,
+    "maxActiveProvidersPerOwner",
+  );
+}
+export function setMaxPendingLoginsPerProviderV2(n) {
+  _ssoConfigV2.maxPendingLoginsPerProvider = _ssoPosIntV2(
+    n,
+    "maxPendingLoginsPerProvider",
+  );
+}
+export function setProviderIdleMsV2(n) {
+  _ssoConfigV2.providerIdleMs = _ssoPosIntV2(n, "providerIdleMs");
+}
+export function setLoginStuckMsV2(n) {
+  _ssoConfigV2.loginStuckMs = _ssoPosIntV2(n, "loginStuckMs");
+}
+export function getMaxActiveProvidersPerOwnerV2() {
+  return _ssoConfigV2.maxActiveProvidersPerOwner;
+}
+export function getMaxPendingLoginsPerProviderV2() {
+  return _ssoConfigV2.maxPendingLoginsPerProvider;
+}
+export function getProviderIdleMsV2() {
+  return _ssoConfigV2.providerIdleMs;
+}
+export function getLoginStuckMsV2() {
+  return _ssoConfigV2.loginStuckMs;
+}
+
+function _copyProviderV2(p) {
+  return { ...p, metadata: { ...(p.metadata || {}) } };
+}
+function _copyLoginV2(l) {
+  return { ...l, metadata: { ...(l.metadata || {}) } };
+}
+
+export function registerProviderV2({
+  id,
+  owner,
+  protocol,
+  displayName,
+  metadata,
+} = {}) {
+  if (!id || typeof id !== "string") throw new Error("id required");
+  if (!owner || typeof owner !== "string") throw new Error("owner required");
+  if (!protocol || typeof protocol !== "string")
+    throw new Error("protocol required");
+  if (_ssoProvidersV2.has(id))
+    throw new Error(`provider ${id} already registered`);
+  const now = Date.now();
+  const p = {
+    id,
+    owner,
+    protocol,
+    displayName: displayName || id,
+    status: _PM_V2.PENDING,
+    activatedAt: null,
+    retiredAt: null,
+    lastSeenAt: now,
+    createdAt: now,
+    metadata: metadata && typeof metadata === "object" ? { ...metadata } : {},
+  };
+  _ssoProvidersV2.set(id, p);
+  return _copyProviderV2(p);
+}
+
+function _activeProviderCountForOwnerV2(owner) {
+  let c = 0;
+  for (const p of _ssoProvidersV2.values())
+    if (p.owner === owner && p.status === _PM_V2.ACTIVE) c++;
+  return c;
+}
+
+function _transitionProviderV2(id, next) {
+  const p = _ssoProvidersV2.get(id);
+  if (!p) throw new Error(`provider ${id} not found`);
+  const allowed = _PM_TRANS_V2.get(p.status);
+  if (!allowed || !allowed.has(next))
+    throw new Error(`invalid transition ${p.status} -> ${next}`);
+  if (next === _PM_V2.ACTIVE && p.status === _PM_V2.PENDING) {
+    if (
+      _activeProviderCountForOwnerV2(p.owner) >=
+      _ssoConfigV2.maxActiveProvidersPerOwner
+    ) {
+      throw new Error(
+        `owner ${p.owner} active-provider cap reached (${_ssoConfigV2.maxActiveProvidersPerOwner})`,
+      );
+    }
+  }
+  const now = Date.now();
+  p.status = next;
+  if (next === _PM_V2.ACTIVE && !p.activatedAt) p.activatedAt = now;
+  if (next === _PM_V2.RETIRED && !p.retiredAt) p.retiredAt = now;
+  p.lastSeenAt = now;
+  return _copyProviderV2(p);
+}
+
+export function activateProviderV2(id) {
+  return _transitionProviderV2(id, _PM_V2.ACTIVE);
+}
+export function deprecateProviderV2(id) {
+  return _transitionProviderV2(id, _PM_V2.DEPRECATED);
+}
+export function retireProviderV2(id) {
+  return _transitionProviderV2(id, _PM_V2.RETIRED);
+}
+export function touchProviderV2(id) {
+  const p = _ssoProvidersV2.get(id);
+  if (!p) throw new Error(`provider ${id} not found`);
+  p.lastSeenAt = Date.now();
+  return _copyProviderV2(p);
+}
+export function getProviderV2(id) {
+  const p = _ssoProvidersV2.get(id);
+  return p ? _copyProviderV2(p) : null;
+}
+export function listProvidersV2({ owner, status, protocol } = {}) {
+  const out = [];
+  for (const p of _ssoProvidersV2.values()) {
+    if (owner && p.owner !== owner) continue;
+    if (status && p.status !== status) continue;
+    if (protocol && p.protocol !== protocol) continue;
+    out.push(_copyProviderV2(p));
+  }
+  return out;
+}
+
+function _pendingLoginCountForProviderV2(providerId) {
+  let c = 0;
+  for (const l of _ssoLoginsV2.values()) {
+    if (l.providerId !== providerId) continue;
+    if (l.status === _LL_V2.QUEUED || l.status === _LL_V2.AUTHENTICATING) c++;
+  }
+  return c;
+}
+
+export function createLoginV2({ id, providerId, subject, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id required");
+  if (!providerId || typeof providerId !== "string")
+    throw new Error("providerId required");
+  if (_ssoLoginsV2.has(id)) throw new Error(`login ${id} already exists`);
+  const provider = _ssoProvidersV2.get(providerId);
+  if (!provider) throw new Error(`provider ${providerId} not found`);
+  if (provider.status === _PM_V2.RETIRED)
+    throw new Error(`provider ${providerId} retired`);
+  if (
+    _pendingLoginCountForProviderV2(providerId) >=
+    _ssoConfigV2.maxPendingLoginsPerProvider
+  ) {
+    throw new Error(
+      `provider ${providerId} pending-login cap reached (${_ssoConfigV2.maxPendingLoginsPerProvider})`,
+    );
+  }
+  const now = Date.now();
+  const l = {
+    id,
+    providerId,
+    subject: subject || "anonymous",
+    status: _LL_V2.QUEUED,
+    startedAt: null,
+    settledAt: null,
+    createdAt: now,
+    metadata: metadata && typeof metadata === "object" ? { ...metadata } : {},
+  };
+  _ssoLoginsV2.set(id, l);
+  return _copyLoginV2(l);
+}
+
+function _transitionLoginV2(id, next, extra = {}) {
+  const l = _ssoLoginsV2.get(id);
+  if (!l) throw new Error(`login ${id} not found`);
+  const allowed = _LL_TRANS_V2.get(l.status);
+  if (!allowed || !allowed.has(next))
+    throw new Error(`invalid transition ${l.status} -> ${next}`);
+  const now = Date.now();
+  l.status = next;
+  if (next === _LL_V2.AUTHENTICATING && !l.startedAt) l.startedAt = now;
+  if (_LL_TERM_V2.has(next) && !l.settledAt) l.settledAt = now;
+  if (extra.error) l.metadata.error = extra.error;
+  return _copyLoginV2(l);
+}
+
+export function startLoginV2(id) {
+  return _transitionLoginV2(id, _LL_V2.AUTHENTICATING);
+}
+export function completeLoginV2(id) {
+  return _transitionLoginV2(id, _LL_V2.AUTHENTICATED);
+}
+export function failLoginV2(id, error) {
+  return _transitionLoginV2(id, _LL_V2.FAILED, { error });
+}
+export function cancelLoginV2(id) {
+  return _transitionLoginV2(id, _LL_V2.CANCELLED);
+}
+
+export function getLoginV2(id) {
+  const l = _ssoLoginsV2.get(id);
+  return l ? _copyLoginV2(l) : null;
+}
+export function listLoginsV2({ providerId, status, subject } = {}) {
+  const out = [];
+  for (const l of _ssoLoginsV2.values()) {
+    if (providerId && l.providerId !== providerId) continue;
+    if (status && l.status !== status) continue;
+    if (subject && l.subject !== subject) continue;
+    out.push(_copyLoginV2(l));
+  }
+  return out;
+}
+
+export function autoDeprecateIdleProvidersV2({ now } = {}) {
+  const t = typeof now === "number" ? now : Date.now();
+  const flipped = [];
+  for (const p of _ssoProvidersV2.values()) {
+    if (p.status !== _PM_V2.ACTIVE) continue;
+    if (t - p.lastSeenAt > _ssoConfigV2.providerIdleMs) {
+      p.status = _PM_V2.DEPRECATED;
+      p.lastSeenAt = t;
+      flipped.push(_copyProviderV2(p));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckLoginsV2({ now } = {}) {
+  const t = typeof now === "number" ? now : Date.now();
+  const flipped = [];
+  for (const l of _ssoLoginsV2.values()) {
+    if (l.status !== _LL_V2.AUTHENTICATING) continue;
+    if (l.startedAt && t - l.startedAt > _ssoConfigV2.loginStuckMs) {
+      l.status = _LL_V2.FAILED;
+      l.settledAt = t;
+      l.metadata.error = "stuck-timeout";
+      flipped.push(_copyLoginV2(l));
+    }
+  }
+  return flipped;
+}
+
+export function getSsoManagerStatsV2() {
+  const providersByStatus = {};
+  for (const s of Object.values(_PM_V2)) providersByStatus[s] = 0;
+  for (const p of _ssoProvidersV2.values()) providersByStatus[p.status]++;
+  const loginsByStatus = {};
+  for (const s of Object.values(_LL_V2)) loginsByStatus[s] = 0;
+  for (const l of _ssoLoginsV2.values()) loginsByStatus[l.status]++;
+  return {
+    totalProvidersV2: _ssoProvidersV2.size,
+    totalLoginsV2: _ssoLoginsV2.size,
+    maxActiveProvidersPerOwner: _ssoConfigV2.maxActiveProvidersPerOwner,
+    maxPendingLoginsPerProvider: _ssoConfigV2.maxPendingLoginsPerProvider,
+    providerIdleMs: _ssoConfigV2.providerIdleMs,
+    loginStuckMs: _ssoConfigV2.loginStuckMs,
+    providersByStatus,
+    loginsByStatus,
+  };
+}

package/src/lib/stress-tester.js

@@ -380,4 +380,334 @@ export function _resetState() {
   _runs.clear();
   _results.clear();
   _seq = 0;
+  _maxConcurrentTests = DEFAULT_MAX_CONCURRENT_TESTS;
+}
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Canonical Surface (Phase 59 — Federation Stress Test)
+ *   Strictly additive; legacy exports above remain unchanged.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const RUN_STATUS_V2 = Object.freeze({
+  RUNNING: "running",
+  COMPLETE: "complete",
+  STOPPED: "stopped",
+  FAILED: "failed",
+});
+
+export const LEVEL_NAME_V2 = Object.freeze({
+  LIGHT: "light",
+  MEDIUM: "medium",
+  HEAVY: "heavy",
+  EXTREME: "extreme",
+});
+
+export const BOTTLENECK_KIND_V2 = Object.freeze({
+  ERROR_RATE: "error-rate",
+  TAIL_LATENCY: "tail-latency",
+  RESPONSE_TIME: "response-time",
+  THROUGHPUT: "throughput",
+});
+
+export const BOTTLENECK_SEVERITY_V2 = Object.freeze({
+  LOW: "low",
+  MEDIUM: "medium",
+  HIGH: "high",
+});
+
+const DEFAULT_MAX_CONCURRENT_TESTS = 3;
+let _maxConcurrentTests = DEFAULT_MAX_CONCURRENT_TESTS;
+
+export const STRESS_DEFAULT_MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_TESTS;
+
+export function setMaxConcurrentTests(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 1) {
+    throw new Error("maxConcurrentTests must be a positive integer");
+  }
+  _maxConcurrentTests = Math.floor(n);
+  return _maxConcurrentTests;
+}
+
+export function getMaxConcurrentTests() {
+  return _maxConcurrentTests;
+}
+
+const _terminalRunStatuses = new Set([
+  RUN_STATUS_V2.COMPLETE,
+  RUN_STATUS_V2.STOPPED,
+  RUN_STATUS_V2.FAILED,
+]);
+
+// Run state machine: running → { complete, stopped, failed }
+const _allowedRunTransitions = new Map([
+  [
+    RUN_STATUS_V2.RUNNING,
+    new Set([
+      RUN_STATUS_V2.COMPLETE,
+      RUN_STATUS_V2.STOPPED,
+      RUN_STATUS_V2.FAILED,
+    ]),
+  ],
+  [RUN_STATUS_V2.COMPLETE, new Set([])],
+  [RUN_STATUS_V2.STOPPED, new Set([])],
+  [RUN_STATUS_V2.FAILED, new Set([])],
+]);
+
+export function getActiveTestCount() {
+  let count = 0;
+  for (const r of _runs.values()) {
+    if (r.status === RUN_STATUS_V2.RUNNING) count++;
+  }
+  return count;
+}
+
+/**
+ * startStressTestV2 — asynchronous lifecycle variant. Creates the run row in
+ * RUNNING state without computing metrics; caller is expected to call
+ * completeStressTest, stopStressTestV2, or failStressTest afterwards.
+ */
+export function startStressTestV2(db, config = {}) {
+  const levelName = config.level || LEVEL_NAME_V2.MEDIUM;
+  const level = resolveLevel(levelName);
+  if (!level) {
+    throw new Error(
+      `Unknown load level: ${levelName} (known: ${Object.values(LEVEL_NAME_V2).join("/")})`,
+    );
+  }
+
+  const concurrency = Number(config.concurrency ?? level.concurrency);
+  const requestsPerSecond = Number(
+    config.requestsPerSecond ?? level.requestsPerSecond,
+  );
+  const duration = Number(config.duration ?? level.duration);
+  if (concurrency <= 0 || duration <= 0 || requestsPerSecond <= 0) {
+    throw new Error("concurrency/duration/requestsPerSecond must all be > 0");
+  }
+
+  const activeCount = getActiveTestCount();
+  if (activeCount >= _maxConcurrentTests) {
+    throw new Error(
+      `Max concurrent stress tests reached: ${activeCount}/${_maxConcurrentTests}`,
+    );
+  }
+
+  const testId = crypto.randomUUID();
+  const now = Date.now();
+
+  const run = {
+    testId,
+    loadLevel: level.name,
+    concurrency,
+    requestsPerSecond,
+    duration,
+    status: RUN_STATUS_V2.RUNNING,
+    startedAt: now,
+    completedAt: null,
+    errorMessage: null,
+    _seq: ++_seq,
+  };
+
+  _runs.set(testId, run);
+  db.prepare(
+    `INSERT INTO stress_test_runs (test_id, load_level, concurrency, requests_per_second, duration, status, started_at, completed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    testId,
+    level.name,
+    concurrency,
+    requestsPerSecond,
+    duration,
+    run.status,
+    now,
+    null,
+  );
+
+  const { _seq: _omit, ...rest } = run;
+  void _omit;
+  return rest;
+}
+
+export function completeStressTest(db, testId) {
+  const run = _runs.get(testId);
+  if (!run) throw new Error(`Stress test not found: ${testId}`);
+
+  const allowed = _allowedRunTransitions.get(run.status);
+  if (!allowed || !allowed.has(RUN_STATUS_V2.COMPLETE)) {
+    throw new Error(`Invalid run status transition: ${run.status} → complete`);
+  }
+
+  const seed = _hashSeed(testId);
+  const metrics = _synthesizeMetrics(
+    {
+      concurrency: run.concurrency,
+      requestsPerSecond: run.requestsPerSecond,
+      duration: run.duration,
+    },
+    seed,
+  );
+  const bottlenecks = _deriveBottlenecks(metrics, {
+    requestsPerSecond: run.requestsPerSecond,
+  });
+  const recommendations = _capacityRecommendations(
+    metrics,
+    { requestsPerSecond: run.requestsPerSecond },
+    bottlenecks,
+  );
+
+  const now = Date.now();
+  const resultId = crypto.randomUUID();
+  const result = {
+    resultId,
+    testId,
+    ...metrics,
+    bottlenecks,
+    capacityRecommendations: recommendations,
+    createdAt: now,
+  };
+  _results.set(testId, result);
+
+  db.prepare(
+    `INSERT INTO stress_test_results (result_id, test_id, tps, avg_response_time, p50_response_time, p95_response_time, p99_response_time, error_rate, bottlenecks, capacity_recommendations, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    resultId,
+    testId,
+    metrics.tps,
+    metrics.avgResponseTime,
+    metrics.p50ResponseTime,
+    metrics.p95ResponseTime,
+    metrics.p99ResponseTime,
+    metrics.errorRate,
+    JSON.stringify(bottlenecks),
+    JSON.stringify(recommendations),
+    now,
+  );
+
+  run.status = RUN_STATUS_V2.COMPLETE;
+  run.completedAt = now;
+  db.prepare(
+    `UPDATE stress_test_runs SET status = ?, completed_at = ? WHERE test_id = ?`,
+  ).run(RUN_STATUS_V2.COMPLETE, now, testId);
+
+  const { _seq: _omit, ...rest } = run;
+  void _omit;
+  return { ...rest, result };
+}
+
+export function stopStressTestV2(db, testId) {
+  return setRunStatus(db, testId, RUN_STATUS_V2.STOPPED);
+}
+
+export function failStressTest(db, testId, errorMessage) {
+  return setRunStatus(db, testId, RUN_STATUS_V2.FAILED, { errorMessage });
+}
+
+export function setRunStatus(db, testId, newStatus, patch = {}) {
+  const run = _runs.get(testId);
+  if (!run) throw new Error(`Stress test not found: ${testId}`);
+
+  const validStatuses = Object.values(RUN_STATUS_V2);
+  if (!validStatuses.includes(newStatus)) {
+    throw new Error(`Unknown run status: ${newStatus}`);
+  }
+
+  const allowed = _allowedRunTransitions.get(run.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid run status transition: ${run.status} → ${newStatus}`,
+    );
+  }
+
+  run.status = newStatus;
+  if (typeof patch.errorMessage === "string") {
+    run.errorMessage = patch.errorMessage;
+  }
+  if (_terminalRunStatuses.has(newStatus)) {
+    run.completedAt = Date.now();
+  }
+
+  db.prepare(
+    `UPDATE stress_test_runs SET status = ?, completed_at = ? WHERE test_id = ?`,
+  ).run(newStatus, run.completedAt, testId);
+
+  const { _seq: _omit, ...rest } = run;
+  void _omit;
+  return rest;
+}
+
+/**
+ * recommendLevelV2 — suggest the largest pre-defined level whose targetRps is
+ * still ≤ the caller's target. Returns `light` for any sub-light target,
+ * `extreme` for anything ≥ extreme.
+ */
+export function recommendLevelV2(targetRps) {
+  if (
+    typeof targetRps !== "number" ||
+    !Number.isFinite(targetRps) ||
+    targetRps <= 0
+  ) {
+    throw new Error("targetRps must be a positive number");
+  }
+  const levels = Object.values(LOAD_LEVELS)
+    .slice()
+    .sort((a, b) => a.requestsPerSecond - b.requestsPerSecond);
+  let chosen = levels[0];
+  for (const level of levels) {
+    if (targetRps >= level.requestsPerSecond) chosen = level;
+  }
+  return { ...chosen };
+}
+
+export function getStressStatsV2() {
+  const runs = [..._runs.values()];
+  const results = [..._results.values()];
+
+  const byStatus = {};
+  for (const s of Object.values(RUN_STATUS_V2)) byStatus[s] = 0;
+  for (const r of runs) byStatus[r.status] = (byStatus[r.status] || 0) + 1;
+
+  const byLevel = {};
+  for (const l of Object.values(LEVEL_NAME_V2)) byLevel[l] = 0;
+  for (const r of runs) byLevel[r.loadLevel] = (byLevel[r.loadLevel] || 0) + 1;
+
+  const byKind = {};
+  for (const k of Object.values(BOTTLENECK_KIND_V2)) byKind[k] = 0;
+  const bySeverity = {};
+  for (const s of Object.values(BOTTLENECK_SEVERITY_V2)) bySeverity[s] = 0;
+
+  let totalTps = 0;
+  let totalP95 = 0;
+  let metricSamples = 0;
+  let totalBottlenecks = 0;
+
+  for (const result of results) {
+    totalTps += result.tps || 0;
+    totalP95 += result.p95ResponseTime || 0;
+    metricSamples++;
+    for (const b of result.bottlenecks || []) {
+      totalBottlenecks++;
+      if (byKind[b.kind] !== undefined) byKind[b.kind]++;
+      if (bySeverity[b.severity] !== undefined) bySeverity[b.severity]++;
+    }
+  }
+
+  return {
+    totalTests: runs.length,
+    activeTests: getActiveTestCount(),
+    maxConcurrentTests: _maxConcurrentTests,
+    byStatus,
+    byLevel,
+    bottlenecks: {
+      total: totalBottlenecks,
+      byKind,
+      bySeverity,
+    },
+    aggregateMetrics: {
+      samples: metricSamples,
+      avgTps:
+        metricSamples > 0 ? Number((totalTps / metricSamples).toFixed(2)) : 0,
+      avgP95:
+        metricSamples > 0 ? Number((totalP95 / metricSamples).toFixed(2)) : 0,
+    },
+  };
 }