chainlesschain 0.81.0 → 0.143.0

package/src/lib/dao-governance.js

@@ -863,3 +863,108 @@ export function _resetState() {
     maxSingleAllocation: 100000,
   };
 }
+
+
+// ===== V2 Surface: DAO Governance overlay (CLI v0.136.0) =====
+export const DAO_ORG_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", DISSOLVED: "dissolved",
+});
+export const DAO_PROPOSAL_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", VOTING: "voting", PASSED: "passed", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _daoOrgTrans = new Map([
+  [DAO_ORG_MATURITY_V2.PENDING, new Set([DAO_ORG_MATURITY_V2.ACTIVE, DAO_ORG_MATURITY_V2.DISSOLVED])],
+  [DAO_ORG_MATURITY_V2.ACTIVE, new Set([DAO_ORG_MATURITY_V2.PAUSED, DAO_ORG_MATURITY_V2.DISSOLVED])],
+  [DAO_ORG_MATURITY_V2.PAUSED, new Set([DAO_ORG_MATURITY_V2.ACTIVE, DAO_ORG_MATURITY_V2.DISSOLVED])],
+  [DAO_ORG_MATURITY_V2.DISSOLVED, new Set()],
+]);
+const _daoOrgTerminal = new Set([DAO_ORG_MATURITY_V2.DISSOLVED]);
+const _daoPropTrans = new Map([
+  [DAO_PROPOSAL_LIFECYCLE_V2.QUEUED, new Set([DAO_PROPOSAL_LIFECYCLE_V2.VOTING, DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED])],
+  [DAO_PROPOSAL_LIFECYCLE_V2.VOTING, new Set([DAO_PROPOSAL_LIFECYCLE_V2.PASSED, DAO_PROPOSAL_LIFECYCLE_V2.FAILED, DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED])],
+  [DAO_PROPOSAL_LIFECYCLE_V2.PASSED, new Set()],
+  [DAO_PROPOSAL_LIFECYCLE_V2.FAILED, new Set()],
+  [DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _daoOrgs = new Map();
+const _daoProps = new Map();
+let _daoMaxActivePerOwner = 8;
+let _daoMaxPendingPerOrg = 50;
+let _daoOrgIdleMs = 7 * 24 * 60 * 60 * 1000;
+let _daoPropStuckMs = 2 * 60 * 1000;
+
+function _daoPos(n, lbl) { const v = Math.floor(Number(n)); if (!Number.isFinite(v) || v <= 0) throw new Error(`${lbl} must be positive integer`); return v; }
+
+export function setMaxActiveDaoOrgsPerOwnerV2(n) { _daoMaxActivePerOwner = _daoPos(n, "maxActiveDaoOrgsPerOwner"); }
+export function getMaxActiveDaoOrgsPerOwnerV2() { return _daoMaxActivePerOwner; }
+export function setMaxPendingDaoProposalsPerOrgV2(n) { _daoMaxPendingPerOrg = _daoPos(n, "maxPendingDaoProposalsPerOrg"); }
+export function getMaxPendingDaoProposalsPerOrgV2() { return _daoMaxPendingPerOrg; }
+export function setDaoOrgIdleMsV2(n) { _daoOrgIdleMs = _daoPos(n, "daoOrgIdleMs"); }
+export function getDaoOrgIdleMsV2() { return _daoOrgIdleMs; }
+export function setDaoProposalStuckMsV2(n) { _daoPropStuckMs = _daoPos(n, "daoProposalStuckMs"); }
+export function getDaoProposalStuckMsV2() { return _daoPropStuckMs; }
+
+export function _resetStateDaoGovernanceV2() {
+  _daoOrgs.clear(); _daoProps.clear();
+  _daoMaxActivePerOwner = 8; _daoMaxPendingPerOrg = 50;
+  _daoOrgIdleMs = 7 * 24 * 60 * 60 * 1000; _daoPropStuckMs = 2 * 60 * 1000;
+}
+
+export function registerDaoOrgV2({ id, owner, name, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_daoOrgs.has(id)) throw new Error(`dao org ${id} already registered`);
+  const now = Date.now();
+  const o = { id, owner, name: name || id, status: DAO_ORG_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, dissolvedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _daoOrgs.set(id, o);
+  return { ...o, metadata: { ...o.metadata } };
+}
+function _daoCheckO(from, to) { const a = _daoOrgTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid dao org transition ${from} → ${to}`); }
+function _daoCountActive(owner) { let n = 0; for (const o of _daoOrgs.values()) if (o.owner === owner && o.status === DAO_ORG_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateDaoOrgV2(id) {
+  const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`);
+  _daoCheckO(o.status, DAO_ORG_MATURITY_V2.ACTIVE);
+  const recovery = o.status === DAO_ORG_MATURITY_V2.PAUSED;
+  if (!recovery) { const a = _daoCountActive(o.owner); if (a >= _daoMaxActivePerOwner) throw new Error(`max active dao orgs per owner (${_daoMaxActivePerOwner}) reached for ${o.owner}`); }
+  const now = Date.now(); o.status = DAO_ORG_MATURITY_V2.ACTIVE; o.updatedAt = now; o.lastTouchedAt = now; if (!o.activatedAt) o.activatedAt = now;
+  return { ...o, metadata: { ...o.metadata } };
+}
+export function pauseDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`); _daoCheckO(o.status, DAO_ORG_MATURITY_V2.PAUSED); o.status = DAO_ORG_MATURITY_V2.PAUSED; o.updatedAt = Date.now(); return { ...o, metadata: { ...o.metadata } }; }
+export function dissolveDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`); _daoCheckO(o.status, DAO_ORG_MATURITY_V2.DISSOLVED); const now = Date.now(); o.status = DAO_ORG_MATURITY_V2.DISSOLVED; o.updatedAt = now; if (!o.dissolvedAt) o.dissolvedAt = now; return { ...o, metadata: { ...o.metadata } }; }
+export function touchDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`); if (_daoOrgTerminal.has(o.status)) throw new Error(`cannot touch terminal dao org ${id}`); const now = Date.now(); o.lastTouchedAt = now; o.updatedAt = now; return { ...o, metadata: { ...o.metadata } }; }
+export function getDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) return null; return { ...o, metadata: { ...o.metadata } }; }
+export function listDaoOrgsV2() { return [..._daoOrgs.values()].map((o) => ({ ...o, metadata: { ...o.metadata } })); }
+
+function _daoCountPending(oid) { let n = 0; for (const p of _daoProps.values()) if (p.orgId === oid && (p.status === DAO_PROPOSAL_LIFECYCLE_V2.QUEUED || p.status === DAO_PROPOSAL_LIFECYCLE_V2.VOTING)) n++; return n; }
+
+export function createDaoProposalV2({ id, orgId, title, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!orgId || typeof orgId !== "string") throw new Error("orgId is required");
+  if (_daoProps.has(id)) throw new Error(`dao proposal ${id} already exists`);
+  if (!_daoOrgs.has(orgId)) throw new Error(`dao org ${orgId} not found`);
+  const pending = _daoCountPending(orgId);
+  if (pending >= _daoMaxPendingPerOrg) throw new Error(`max pending dao proposals per org (${_daoMaxPendingPerOrg}) reached for ${orgId}`);
+  const now = Date.now();
+  const p = { id, orgId, title: title || id, status: DAO_PROPOSAL_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _daoProps.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+function _daoCheckP(from, to) { const a = _daoPropTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid dao proposal transition ${from} → ${to}`); }
+export function startDaoProposalV2(id) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.VOTING); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.VOTING; p.updatedAt = now; if (!p.startedAt) p.startedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function passDaoProposalV2(id) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.PASSED); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.PASSED; p.updatedAt = now; if (!p.settledAt) p.settledAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function failDaoProposalV2(id, reason) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.FAILED); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.FAILED; p.updatedAt = now; if (!p.settledAt) p.settledAt = now; if (reason) p.metadata.failReason = String(reason); return { ...p, metadata: { ...p.metadata } }; }
+export function cancelDaoProposalV2(id, reason) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED; p.updatedAt = now; if (!p.settledAt) p.settledAt = now; if (reason) p.metadata.cancelReason = String(reason); return { ...p, metadata: { ...p.metadata } }; }
+export function getDaoProposalV2(id) { const p = _daoProps.get(id); if (!p) return null; return { ...p, metadata: { ...p.metadata } }; }
+export function listDaoProposalsV2() { return [..._daoProps.values()].map((p) => ({ ...p, metadata: { ...p.metadata } })); }
+
+export function autoPauseIdleDaoOrgsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const o of _daoOrgs.values()) if (o.status === DAO_ORG_MATURITY_V2.ACTIVE && (t - o.lastTouchedAt) >= _daoOrgIdleMs) { o.status = DAO_ORG_MATURITY_V2.PAUSED; o.updatedAt = t; flipped.push(o.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckDaoProposalsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const p of _daoProps.values()) if (p.status === DAO_PROPOSAL_LIFECYCLE_V2.VOTING && p.startedAt != null && (t - p.startedAt) >= _daoPropStuckMs) { p.status = DAO_PROPOSAL_LIFECYCLE_V2.FAILED; p.updatedAt = t; if (!p.settledAt) p.settledAt = t; p.metadata.failReason = "auto-fail-stuck"; flipped.push(p.id); } return { flipped, count: flipped.length }; }
+
+export function getDaoGovernanceGovStatsV2() {
+  const orgsByStatus = {}; for (const s of Object.values(DAO_ORG_MATURITY_V2)) orgsByStatus[s] = 0; for (const o of _daoOrgs.values()) orgsByStatus[o.status]++;
+  const proposalsByStatus = {}; for (const s of Object.values(DAO_PROPOSAL_LIFECYCLE_V2)) proposalsByStatus[s] = 0; for (const p of _daoProps.values()) proposalsByStatus[p.status]++;
+  return { totalOrgsV2: _daoOrgs.size, totalProposalsV2: _daoProps.size, maxActiveDaoOrgsPerOwner: _daoMaxActivePerOwner, maxPendingDaoProposalsPerOrg: _daoMaxPendingPerOrg, daoOrgIdleMs: _daoOrgIdleMs, daoProposalStuckMs: _daoPropStuckMs, orgsByStatus, proposalsByStatus };
+}

package/src/lib/dbevo.js

@@ -667,3 +667,341 @@ export function _resetState() {
   _suggestions.clear();
   _slowQueryThresholdMs = 100;
 }
+
+/* ═════════════════════════════════════════════════════════ *
+ *  Phase 80 V2 — Schema Baseline + Migration-Run Lifecycle
+ * ═════════════════════════════════════════════════════════ */
+
+export const SCHEMA_BASELINE_V2 = Object.freeze({
+  DRAFT: "draft",
+  VALIDATED: "validated",
+  ACTIVE: "active",
+  DEPRECATED: "deprecated",
+  RETIRED: "retired",
+});
+
+export const MIGRATION_RUN_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  APPLIED: "applied",
+  FAILED: "failed",
+  ROLLED_BACK: "rolled_back",
+});
+
+const BASELINE_TRANSITIONS_V2 = new Map([
+  ["draft", new Set(["validated", "retired"])],
+  ["validated", new Set(["active", "retired"])],
+  ["active", new Set(["deprecated", "retired"])],
+  ["deprecated", new Set(["active", "retired"])],
+]);
+const BASELINE_TERMINALS_V2 = new Set(["retired"]);
+
+const RUN_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["running", "failed"])],
+  ["running", new Set(["applied", "failed", "rolled_back"])],
+  ["applied", new Set(["rolled_back"])],
+]);
+const RUN_TERMINALS_V2 = new Set(["failed", "rolled_back"]);
+
+export const DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB = 1;
+export const DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB = 1;
+export const DBEVO_DEFAULT_BASELINE_IDLE_MS = 180 * 86400000; // 180 days
+export const DBEVO_DEFAULT_MIGRATION_STUCK_MS = 30 * 60000; // 30 minutes
+
+let _maxActiveBaselinesPerDbV2 = DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB;
+let _maxRunningMigrationsPerDbV2 = DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB;
+let _baselineIdleMsV2 = DBEVO_DEFAULT_BASELINE_IDLE_MS;
+let _migrationStuckMsV2 = DBEVO_DEFAULT_MIGRATION_STUCK_MS;
+
+function _positiveIntV2(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0)
+    throw new Error(`${label} must be a positive integer`);
+  return v;
+}
+
+export function getDefaultMaxActiveBaselinesPerDbV2() {
+  return DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB;
+}
+export function getMaxActiveBaselinesPerDbV2() {
+  return _maxActiveBaselinesPerDbV2;
+}
+export function setMaxActiveBaselinesPerDbV2(n) {
+  return (_maxActiveBaselinesPerDbV2 = _positiveIntV2(
+    n,
+    "maxActiveBaselinesPerDb",
+  ));
+}
+export function getDefaultMaxRunningMigrationsPerDbV2() {
+  return DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB;
+}
+export function getMaxRunningMigrationsPerDbV2() {
+  return _maxRunningMigrationsPerDbV2;
+}
+export function setMaxRunningMigrationsPerDbV2(n) {
+  return (_maxRunningMigrationsPerDbV2 = _positiveIntV2(
+    n,
+    "maxRunningMigrationsPerDb",
+  ));
+}
+export function getDefaultBaselineIdleMsV2() {
+  return DBEVO_DEFAULT_BASELINE_IDLE_MS;
+}
+export function getBaselineIdleMsV2() {
+  return _baselineIdleMsV2;
+}
+export function setBaselineIdleMsV2(ms) {
+  return (_baselineIdleMsV2 = _positiveIntV2(ms, "baselineIdleMs"));
+}
+export function getDefaultMigrationStuckMsV2() {
+  return DBEVO_DEFAULT_MIGRATION_STUCK_MS;
+}
+export function getMigrationStuckMsV2() {
+  return _migrationStuckMsV2;
+}
+export function setMigrationStuckMsV2(ms) {
+  return (_migrationStuckMsV2 = _positiveIntV2(ms, "migrationStuckMs"));
+}
+
+const _baselinesV2 = new Map();
+const _runsV2 = new Map();
+
+export function registerBaselineV2(
+  _db,
+  { baselineId, databaseId, version, initialStatus, metadata } = {},
+) {
+  if (!baselineId) throw new Error("baselineId is required");
+  if (!databaseId) throw new Error("databaseId is required");
+  if (!version) throw new Error("version is required");
+  if (_baselinesV2.has(baselineId))
+    throw new Error(`Baseline ${baselineId} already exists`);
+  const status = initialStatus || SCHEMA_BASELINE_V2.DRAFT;
+  if (!Object.values(SCHEMA_BASELINE_V2).includes(status))
+    throw new Error(`Invalid initial status: ${status}`);
+  if (BASELINE_TERMINALS_V2.has(status))
+    throw new Error(`Cannot register in terminal status: ${status}`);
+  if (status === SCHEMA_BASELINE_V2.ACTIVE) {
+    if (getActiveBaselineCount(databaseId) >= _maxActiveBaselinesPerDbV2)
+      throw new Error(
+        `Database ${databaseId} reached active-baseline cap (${_maxActiveBaselinesPerDbV2})`,
+      );
+  }
+  const now = Date.now();
+  const record = {
+    baselineId,
+    databaseId,
+    version,
+    status,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+    lastTouchedAt: now,
+  };
+  _baselinesV2.set(baselineId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getBaselineV2(baselineId) {
+  const r = _baselinesV2.get(baselineId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setBaselineStatusV2(_db, baselineId, newStatus, patch = {}) {
+  const record = _baselinesV2.get(baselineId);
+  if (!record) throw new Error(`Unknown baseline: ${baselineId}`);
+  if (!Object.values(SCHEMA_BASELINE_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = BASELINE_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === SCHEMA_BASELINE_V2.ACTIVE) {
+    if (getActiveBaselineCount(record.databaseId) >= _maxActiveBaselinesPerDbV2)
+      throw new Error(
+        `Database ${record.databaseId} reached active-baseline cap (${_maxActiveBaselinesPerDbV2})`,
+      );
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function validateBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.VALIDATED, { reason });
+}
+export function activateBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.ACTIVE, { reason });
+}
+export function deprecateBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.DEPRECATED, { reason });
+}
+export function retireBaseline(db, id, reason) {
+  return setBaselineStatusV2(db, id, SCHEMA_BASELINE_V2.RETIRED, { reason });
+}
+
+export function touchBaselineActivity(baselineId) {
+  const record = _baselinesV2.get(baselineId);
+  if (!record) throw new Error(`Unknown baseline: ${baselineId}`);
+  record.lastTouchedAt = Date.now();
+  record.updatedAt = record.lastTouchedAt;
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function enqueueMigrationRunV2(
+  _db,
+  { runId, databaseId, migrationId, direction, metadata } = {},
+) {
+  if (!runId) throw new Error("runId is required");
+  if (!databaseId) throw new Error("databaseId is required");
+  if (!migrationId) throw new Error("migrationId is required");
+  if (!direction) throw new Error("direction is required");
+  if (!Object.values(MIGRATION_DIRECTION).includes(direction))
+    throw new Error(`Invalid direction: ${direction}`);
+  if (_runsV2.has(runId)) throw new Error(`Run ${runId} already exists`);
+  const now = Date.now();
+  const record = {
+    runId,
+    databaseId,
+    migrationId,
+    direction,
+    status: MIGRATION_RUN_V2.QUEUED,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+  };
+  _runsV2.set(runId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getMigrationRunV2(runId) {
+  const r = _runsV2.get(runId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setMigrationRunStatusV2(_db, runId, newStatus, patch = {}) {
+  const record = _runsV2.get(runId);
+  if (!record) throw new Error(`Unknown run: ${runId}`);
+  if (!Object.values(MIGRATION_RUN_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = RUN_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === MIGRATION_RUN_V2.RUNNING) {
+    if (
+      getRunningMigrationCount(record.databaseId) >=
+      _maxRunningMigrationsPerDbV2
+    )
+      throw new Error(
+        `Database ${record.databaseId} reached running-migration cap (${_maxRunningMigrationsPerDbV2})`,
+      );
+    if (!record.startedAt) record.startedAt = Date.now();
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function startMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.RUNNING, { reason });
+}
+export function applyMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.APPLIED, { reason });
+}
+export function failMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.FAILED, { reason });
+}
+export function rollbackMigrationRun(db, id, reason) {
+  return setMigrationRunStatusV2(db, id, MIGRATION_RUN_V2.ROLLED_BACK, {
+    reason,
+  });
+}
+
+export function getActiveBaselineCount(databaseId) {
+  let n = 0;
+  for (const r of _baselinesV2.values()) {
+    if (r.status !== SCHEMA_BASELINE_V2.ACTIVE) continue;
+    if (databaseId && r.databaseId !== databaseId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function getRunningMigrationCount(databaseId) {
+  let n = 0;
+  for (const r of _runsV2.values()) {
+    if (r.status !== MIGRATION_RUN_V2.RUNNING) continue;
+    if (databaseId && r.databaseId !== databaseId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function autoRetireIdleBaselines(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _baselinesV2.values()) {
+    if (
+      r.status === SCHEMA_BASELINE_V2.DEPRECATED ||
+      r.status === SCHEMA_BASELINE_V2.DRAFT ||
+      r.status === SCHEMA_BASELINE_V2.VALIDATED
+    ) {
+      if (now - r.lastTouchedAt > _baselineIdleMsV2) {
+        r.status = SCHEMA_BASELINE_V2.RETIRED;
+        r.updatedAt = now;
+        r.lastReason = "idle_timeout";
+        flipped.push(r.baselineId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function autoFailStuckMigrationRuns(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _runsV2.values()) {
+    if (r.status === MIGRATION_RUN_V2.RUNNING) {
+      const anchor = r.startedAt || r.createdAt;
+      if (now - anchor > _migrationStuckMsV2) {
+        r.status = MIGRATION_RUN_V2.FAILED;
+        r.updatedAt = now;
+        r.lastReason = "migration_timeout";
+        flipped.push(r.runId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function getDbEvoStatsV2() {
+  const baselinesByStatus = {};
+  for (const s of Object.values(SCHEMA_BASELINE_V2)) baselinesByStatus[s] = 0;
+  const runsByStatus = {};
+  for (const s of Object.values(MIGRATION_RUN_V2)) runsByStatus[s] = 0;
+  for (const r of _baselinesV2.values()) baselinesByStatus[r.status]++;
+  for (const r of _runsV2.values()) runsByStatus[r.status]++;
+  return {
+    totalBaselinesV2: _baselinesV2.size,
+    totalRunsV2: _runsV2.size,
+    maxActiveBaselinesPerDb: _maxActiveBaselinesPerDbV2,
+    maxRunningMigrationsPerDb: _maxRunningMigrationsPerDbV2,
+    baselineIdleMs: _baselineIdleMsV2,
+    migrationStuckMs: _migrationStuckMsV2,
+    baselinesByStatus,
+    runsByStatus,
+  };
+}
+
+export function _resetStateV2() {
+  _maxActiveBaselinesPerDbV2 = DBEVO_DEFAULT_MAX_ACTIVE_BASELINES_PER_DB;
+  _maxRunningMigrationsPerDbV2 = DBEVO_DEFAULT_MAX_RUNNING_MIGRATIONS_PER_DB;
+  _baselineIdleMsV2 = DBEVO_DEFAULT_BASELINE_IDLE_MS;
+  _migrationStuckMsV2 = DBEVO_DEFAULT_MIGRATION_STUCK_MS;
+  _baselinesV2.clear();
+  _runsV2.clear();
+}