chainlesschain 0.66.0 → 0.132.0

package/src/lib/bi-engine.js

@@ -297,3 +297,341 @@ export function _resetState() {
   _reports.clear();
   _scheduledReports.clear();
 }
+
+// ─── Phase 95 V2 surface (strictly additive) ───────────────────────
+
+export const CHART_TYPE = Object.freeze({
+  TABLE: "table",
+  BAR: "bar",
+  LINE: "line",
+  PIE: "pie",
+  AREA: "area",
+  SCATTER: "scatter",
+  HEATMAP: "heatmap",
+  FUNNEL: "funnel",
+  GAUGE: "gauge",
+});
+
+export const ANOMALY_METHOD = Object.freeze({
+  Z_SCORE: "z_score",
+  IQR: "iqr",
+});
+
+export const REPORT_FORMAT = Object.freeze({
+  PDF: "pdf",
+  EXCEL: "excel",
+  CSV: "csv",
+  JSON: "json",
+});
+
+export const REPORT_STATUS = Object.freeze({
+  DRAFT: "draft",
+  GENERATED: "generated",
+  SCHEDULED: "scheduled",
+  ARCHIVED: "archived",
+});
+
+export const DASHBOARD_LAYOUT = Object.freeze({
+  GRID: "grid",
+  FLOW: "flow",
+  TABS: "tabs",
+});
+
+const _reportStatusV2 = new Map();
+const _statusHistoryV2 = new Map();
+
+const _allowedReportTransitions = Object.freeze({
+  draft: new Set(["generated", "archived"]),
+  generated: new Set(["scheduled", "archived", "draft"]),
+  scheduled: new Set(["generated", "archived"]),
+  archived: new Set(["draft"]),
+});
+
+function _quantile(sorted, q) {
+  if (sorted.length === 0) return NaN;
+  const pos = (sorted.length - 1) * q;
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + (pos - lo) * (sorted[hi] - sorted[lo]);
+}
+
+export function nlQueryV2({ query, schema } = {}) {
+  if (!query || typeof query !== "string") {
+    throw new Error("query must be a non-empty string");
+  }
+  const normalized = query.replace(/['"]/g, "").trim().toLowerCase();
+  const tokens = normalized.split(/\s+/);
+
+  // Detect table name from schema (first match) or fall back to "data"
+  let table = "data";
+  const knownTables =
+    schema && Array.isArray(schema.tables)
+      ? schema.tables.map((t) => String(t).toLowerCase())
+      : [];
+  for (const t of knownTables) {
+    if (tokens.includes(t)) {
+      table = t;
+      break;
+    }
+  }
+
+  // Detect aggregate intent
+  let aggregate = null;
+  let intent = "list";
+  let visualization = CHART_TYPE.TABLE;
+
+  if (/\b(count|how many)\b/.test(normalized)) {
+    aggregate = "COUNT(*)";
+    intent = "count";
+    visualization = CHART_TYPE.BAR;
+  } else if (/\b(sum|total)\b/.test(normalized)) {
+    aggregate = "SUM(value)";
+    intent = "sum";
+    visualization = CHART_TYPE.GAUGE;
+  } else if (/\b(avg|average|mean)\b/.test(normalized)) {
+    aggregate = "AVG(value)";
+    intent = "avg";
+    visualization = CHART_TYPE.GAUGE;
+  } else if (/\b(trend|over time|timeline|history)\b/.test(normalized)) {
+    intent = "trend";
+    visualization = CHART_TYPE.LINE;
+  } else if (/\b(distribution|breakdown)\b/.test(normalized)) {
+    intent = "distribution";
+    visualization = CHART_TYPE.PIE;
+  }
+
+  // Detect top N
+  let limit = null;
+  const topMatch = normalized.match(/\btop\s+(\d+)\b/);
+  if (topMatch) {
+    limit = parseInt(topMatch[1], 10);
+    if (intent === "list") {
+      intent = "top";
+      visualization = CHART_TYPE.BAR;
+    }
+  }
+
+  // Build SQL
+  let sql;
+  if (aggregate) {
+    sql = `SELECT ${aggregate} FROM ${table}`;
+  } else {
+    sql = `SELECT * FROM ${table}`;
+  }
+  if (limit !== null) {
+    sql += ` ORDER BY value DESC LIMIT ${limit}`;
+  } else if (intent === "trend") {
+    sql += ` ORDER BY created_at ASC`;
+  }
+
+  return {
+    id: crypto.randomUUID(),
+    query,
+    intent,
+    sql,
+    table,
+    aggregate,
+    limit,
+    visualization,
+  };
+}
+
+export function detectAnomalyV2({
+  data,
+  method = ANOMALY_METHOD.Z_SCORE,
+  threshold,
+} = {}) {
+  if (!Array.isArray(data) || data.length === 0) {
+    throw new Error("data must be a non-empty array of numbers");
+  }
+  const valid = Object.values(ANOMALY_METHOD);
+  if (!valid.includes(method)) {
+    throw new Error(
+      `Invalid method '${method}'. Expected one of ${valid.join(", ")}`,
+    );
+  }
+
+  if (method === ANOMALY_METHOD.Z_SCORE) {
+    const t = threshold == null ? 2 : threshold;
+    const legacy = detectAnomaly(data, { threshold: t });
+    return { method, threshold: t, ...legacy };
+  }
+
+  // IQR method
+  const sorted = [...data].sort((a, b) => a - b);
+  const q1 = _quantile(sorted, 0.25);
+  const q3 = _quantile(sorted, 0.75);
+  const iqr = q3 - q1;
+  const multiplier = threshold == null ? 1.5 : threshold;
+  const lowerBound = q1 - multiplier * iqr;
+  const upperBound = q3 + multiplier * iqr;
+
+  const anomalies = [];
+  for (let i = 0; i < data.length; i++) {
+    if (data[i] < lowerBound || data[i] > upperBound) {
+      anomalies.push({ index: i, value: data[i] });
+    }
+  }
+
+  return {
+    method,
+    threshold: multiplier,
+    q1,
+    q3,
+    iqr,
+    lowerBound,
+    upperBound,
+    anomalies,
+  };
+}
+
+export function predictTrendV2({ data, periods = 3, method = "linear" } = {}) {
+  if (!Array.isArray(data) || data.length < 2) {
+    throw new Error("data must be an array with at least 2 points");
+  }
+  if (method !== "linear") {
+    throw new Error(`Invalid method '${method}'. Only 'linear' is supported`);
+  }
+
+  const legacy = predictTrend(data, periods);
+
+  // Compute R² (coefficient of determination)
+  const n = data.length;
+  const meanY = data.reduce((s, v) => s + v, 0) / n;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (let i = 0; i < n; i++) {
+    const predicted = legacy.slope * i + (meanY - legacy.slope * ((n - 1) / 2));
+    ssRes += (data[i] - predicted) ** 2;
+    ssTot += (data[i] - meanY) ** 2;
+  }
+  let r2 = ssTot === 0 ? 1 : 1 - ssRes / ssTot;
+  if (r2 < 0) r2 = 0;
+  if (r2 > 1) r2 = 1;
+
+  return {
+    method,
+    ...legacy,
+    r2: Math.round(r2 * 1000) / 1000,
+    confidence: r2 >= 0.7 ? "high" : r2 >= 0.4 ? "medium" : "low",
+  };
+}
+
+export function recommendChart({ intent, dataShape } = {}) {
+  if (intent) {
+    const i = String(intent).toLowerCase();
+    if (i.includes("trend") || i.includes("time")) return CHART_TYPE.LINE;
+    if (i.includes("distribution") || i.includes("share"))
+      return CHART_TYPE.PIE;
+    if (i.includes("compare") || i.includes("top")) return CHART_TYPE.BAR;
+    if (i.includes("correlation")) return CHART_TYPE.SCATTER;
+    if (i.includes("funnel")) return CHART_TYPE.FUNNEL;
+    if (i.includes("heat")) return CHART_TYPE.HEATMAP;
+    if (i.includes("gauge") || i.includes("kpi")) return CHART_TYPE.GAUGE;
+  }
+  if (dataShape) {
+    if (dataShape.dimensions === 1 && dataShape.categorical)
+      return CHART_TYPE.PIE;
+    if (dataShape.timeseries) return CHART_TYPE.LINE;
+    if (dataShape.dimensions === 2) return CHART_TYPE.SCATTER;
+  }
+  return CHART_TYPE.TABLE;
+}
+
+export function createDashboardV2(db, { name, widgets = [], layout } = {}) {
+  if (!name) throw new Error("name is required");
+  let layoutSpec;
+  if (!layout) {
+    layoutSpec = { type: DASHBOARD_LAYOUT.GRID, columns: 2 };
+  } else if (typeof layout === "string") {
+    const valid = Object.values(DASHBOARD_LAYOUT);
+    if (!valid.includes(layout)) {
+      throw new Error(
+        `Invalid layout '${layout}'. Expected one of ${valid.join(", ")}`,
+      );
+    }
+    layoutSpec = { type: layout, columns: 2 };
+  } else {
+    const type = layout.type || DASHBOARD_LAYOUT.GRID;
+    const valid = Object.values(DASHBOARD_LAYOUT);
+    if (!valid.includes(type)) {
+      throw new Error(
+        `Invalid layout type '${type}'. Expected one of ${valid.join(", ")}`,
+      );
+    }
+    layoutSpec = { ...layout, type };
+  }
+  return createDashboard(db, name, widgets, layoutSpec);
+}
+
+export function updateReportStatus(db, { reportId, status } = {}) {
+  const valid = Object.values(REPORT_STATUS);
+  if (!valid.includes(status)) {
+    throw new Error(
+      `Invalid status '${status}'. Expected one of ${valid.join(", ")}`,
+    );
+  }
+  const current = _reportStatusV2.get(reportId) || REPORT_STATUS.DRAFT;
+  const allowed = _allowedReportTransitions[current];
+  if (!allowed.has(status) && current !== status) {
+    throw new Error(`Invalid status transition: ${current} → ${status}`);
+  }
+  _reportStatusV2.set(reportId, status);
+  const hist = _statusHistoryV2.get(reportId) || [];
+  hist.push({
+    from: current,
+    to: status,
+    at: new Date().toISOString(),
+  });
+  _statusHistoryV2.set(reportId, hist);
+  return { reportId, status, previous: current };
+}
+
+export function getReportStatus(reportId) {
+  return _reportStatusV2.get(reportId) || REPORT_STATUS.DRAFT;
+}
+
+export function getReportStatusHistory(reportId) {
+  return (_statusHistoryV2.get(reportId) || []).slice();
+}
+
+export function getBIStatsV2(db) {
+  const dashboards = db.prepare(`SELECT id FROM bi_dashboards`).all();
+  const reports = db.prepare(`SELECT id, format FROM bi_reports`).all();
+  const scheduled = db.prepare(`SELECT id FROM bi_scheduled`).all();
+
+  const byStatus = {
+    draft: 0,
+    generated: 0,
+    scheduled: 0,
+    archived: 0,
+  };
+  for (const r of reports) {
+    const s = _reportStatusV2.get(r.id) || REPORT_STATUS.DRAFT;
+    byStatus[s] = (byStatus[s] || 0) + 1;
+  }
+
+  const byFormat = {};
+  for (const r of reports) {
+    const f = r.format || "pdf";
+    byFormat[f] = (byFormat[f] || 0) + 1;
+  }
+
+  return {
+    dashboards: dashboards.length,
+    reports: {
+      total: reports.length,
+      byStatus,
+      byFormat,
+    },
+    scheduled: scheduled.length,
+    templates: _templates.length,
+    chartTypes: Object.values(CHART_TYPE).length,
+  };
+}
+
+export function _resetV2State() {
+  _reportStatusV2.clear();
+  _statusHistoryV2.clear();
+}

package/src/lib/code-agent.js

@@ -440,3 +440,326 @@ export function _resetState() {
   _reviews.clear();
   _scaffolds.clear();
 }
+
+/* ═════════════════════════════════════════════════════════ *
+ *  Phase 86 V2 — Code Agent Maturity + Generation Job
+ * ═════════════════════════════════════════════════════════ */
+
+export const AGENT_MATURITY_V2 = Object.freeze({
+  DRAFT: "draft",
+  ACTIVE: "active",
+  DEPRECATED: "deprecated",
+  RETIRED: "retired",
+});
+
+export const GEN_JOB_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  SUCCEEDED: "succeeded",
+  FAILED: "failed",
+  CANCELED: "canceled",
+});
+
+const AGENT_TRANSITIONS_V2 = new Map([
+  ["draft", new Set(["active", "retired"])],
+  ["active", new Set(["deprecated", "retired"])],
+  ["deprecated", new Set(["active", "retired"])],
+]);
+const AGENT_TERMINALS_V2 = new Set(["retired"]);
+
+const JOB_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["running", "canceled", "failed"])],
+  ["running", new Set(["succeeded", "failed", "canceled"])],
+]);
+const JOB_TERMINALS_V2 = new Set(["succeeded", "failed", "canceled"]);
+
+export const CGA_DEFAULT_MAX_ACTIVE_AGENTS_PER_OWNER = 15;
+export const CGA_DEFAULT_MAX_RUNNING_JOBS_PER_OWNER = 3;
+export const CGA_DEFAULT_AGENT_IDLE_MS = 60 * 86400000; // 60 days
+export const CGA_DEFAULT_JOB_STUCK_MS = 15 * 60000; // 15 minutes
+
+let _maxActiveAgentsPerOwnerV2 = CGA_DEFAULT_MAX_ACTIVE_AGENTS_PER_OWNER;
+let _maxRunningJobsPerOwnerV2 = CGA_DEFAULT_MAX_RUNNING_JOBS_PER_OWNER;
+let _agentIdleMsV2 = CGA_DEFAULT_AGENT_IDLE_MS;
+let _jobStuckMsV2 = CGA_DEFAULT_JOB_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 getDefaultMaxActiveAgentsPerOwnerV2() {
+  return CGA_DEFAULT_MAX_ACTIVE_AGENTS_PER_OWNER;
+}
+export function getMaxActiveAgentsPerOwnerV2() {
+  return _maxActiveAgentsPerOwnerV2;
+}
+export function setMaxActiveAgentsPerOwnerV2(n) {
+  return (_maxActiveAgentsPerOwnerV2 = _positiveIntV2(
+    n,
+    "maxActiveAgentsPerOwner",
+  ));
+}
+export function getDefaultMaxRunningJobsPerOwnerV2() {
+  return CGA_DEFAULT_MAX_RUNNING_JOBS_PER_OWNER;
+}
+export function getMaxRunningJobsPerOwnerV2() {
+  return _maxRunningJobsPerOwnerV2;
+}
+export function setMaxRunningJobsPerOwnerV2(n) {
+  return (_maxRunningJobsPerOwnerV2 = _positiveIntV2(
+    n,
+    "maxRunningJobsPerOwner",
+  ));
+}
+export function getDefaultAgentIdleMsV2() {
+  return CGA_DEFAULT_AGENT_IDLE_MS;
+}
+export function getAgentIdleMsV2() {
+  return _agentIdleMsV2;
+}
+export function setAgentIdleMsV2(ms) {
+  return (_agentIdleMsV2 = _positiveIntV2(ms, "agentIdleMs"));
+}
+export function getDefaultJobStuckMsV2() {
+  return CGA_DEFAULT_JOB_STUCK_MS;
+}
+export function getJobStuckMsV2() {
+  return _jobStuckMsV2;
+}
+export function setJobStuckMsV2(ms) {
+  return (_jobStuckMsV2 = _positiveIntV2(ms, "jobStuckMs"));
+}
+
+const _agentsV2 = new Map();
+const _jobsV2 = new Map();
+
+export function registerAgentV2(
+  _db,
+  { agentId, ownerId, name, initialStatus, metadata } = {},
+) {
+  if (!agentId) throw new Error("agentId is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (_agentsV2.has(agentId))
+    throw new Error(`Agent ${agentId} already exists`);
+  const status = initialStatus || AGENT_MATURITY_V2.DRAFT;
+  if (!Object.values(AGENT_MATURITY_V2).includes(status))
+    throw new Error(`Invalid initial status: ${status}`);
+  if (AGENT_TERMINALS_V2.has(status))
+    throw new Error(`Cannot register in terminal status: ${status}`);
+  if (status === AGENT_MATURITY_V2.ACTIVE) {
+    if (getActiveAgentCount(ownerId) >= _maxActiveAgentsPerOwnerV2)
+      throw new Error(
+        `Owner ${ownerId} reached active-agent cap (${_maxActiveAgentsPerOwnerV2})`,
+      );
+  }
+  const now = Date.now();
+  const record = {
+    agentId,
+    ownerId,
+    name: name || agentId,
+    status,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+    lastInvokedAt: now,
+  };
+  _agentsV2.set(agentId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getAgentV2(agentId) {
+  const r = _agentsV2.get(agentId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setAgentMaturityV2(_db, agentId, newStatus, patch = {}) {
+  const record = _agentsV2.get(agentId);
+  if (!record) throw new Error(`Unknown agent: ${agentId}`);
+  if (!Object.values(AGENT_MATURITY_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = AGENT_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === AGENT_MATURITY_V2.ACTIVE) {
+    if (getActiveAgentCount(record.ownerId) >= _maxActiveAgentsPerOwnerV2)
+      throw new Error(
+        `Owner ${record.ownerId} reached active-agent cap (${_maxActiveAgentsPerOwnerV2})`,
+      );
+  }
+  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 activateAgent(db, id, reason) {
+  return setAgentMaturityV2(db, id, AGENT_MATURITY_V2.ACTIVE, { reason });
+}
+export function deprecateAgent(db, id, reason) {
+  return setAgentMaturityV2(db, id, AGENT_MATURITY_V2.DEPRECATED, { reason });
+}
+export function retireAgent(db, id, reason) {
+  return setAgentMaturityV2(db, id, AGENT_MATURITY_V2.RETIRED, { reason });
+}
+
+export function touchAgentInvocation(agentId) {
+  const record = _agentsV2.get(agentId);
+  if (!record) throw new Error(`Unknown agent: ${agentId}`);
+  record.lastInvokedAt = Date.now();
+  record.updatedAt = record.lastInvokedAt;
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function enqueueGenJobV2(
+  _db,
+  { jobId, ownerId, agentId, prompt, metadata } = {},
+) {
+  if (!jobId) throw new Error("jobId is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (!agentId) throw new Error("agentId is required");
+  if (!prompt) throw new Error("prompt is required");
+  if (_jobsV2.has(jobId)) throw new Error(`Job ${jobId} already exists`);
+  const now = Date.now();
+  const record = {
+    jobId,
+    ownerId,
+    agentId,
+    prompt,
+    status: GEN_JOB_V2.QUEUED,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+  };
+  _jobsV2.set(jobId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getGenJobV2(jobId) {
+  const r = _jobsV2.get(jobId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setGenJobStatusV2(_db, jobId, newStatus, patch = {}) {
+  const record = _jobsV2.get(jobId);
+  if (!record) throw new Error(`Unknown job: ${jobId}`);
+  if (!Object.values(GEN_JOB_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = JOB_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === GEN_JOB_V2.RUNNING) {
+    if (getRunningJobCount(record.ownerId) >= _maxRunningJobsPerOwnerV2)
+      throw new Error(
+        `Owner ${record.ownerId} reached running-job cap (${_maxRunningJobsPerOwnerV2})`,
+      );
+    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 startGenJob(db, id, reason) {
+  return setGenJobStatusV2(db, id, GEN_JOB_V2.RUNNING, { reason });
+}
+export function succeedGenJob(db, id, reason) {
+  return setGenJobStatusV2(db, id, GEN_JOB_V2.SUCCEEDED, { reason });
+}
+export function failGenJob(db, id, reason) {
+  return setGenJobStatusV2(db, id, GEN_JOB_V2.FAILED, { reason });
+}
+export function cancelGenJob(db, id, reason) {
+  return setGenJobStatusV2(db, id, GEN_JOB_V2.CANCELED, { reason });
+}
+
+export function getActiveAgentCount(ownerId) {
+  let n = 0;
+  for (const r of _agentsV2.values()) {
+    if (r.status !== AGENT_MATURITY_V2.ACTIVE) continue;
+    if (ownerId && r.ownerId !== ownerId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function getRunningJobCount(ownerId) {
+  let n = 0;
+  for (const r of _jobsV2.values()) {
+    if (r.status !== GEN_JOB_V2.RUNNING) continue;
+    if (ownerId && r.ownerId !== ownerId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function autoRetireIdleAgents(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _agentsV2.values()) {
+    if (
+      r.status === AGENT_MATURITY_V2.ACTIVE ||
+      r.status === AGENT_MATURITY_V2.DEPRECATED
+    ) {
+      if (now - r.lastInvokedAt > _agentIdleMsV2) {
+        r.status = AGENT_MATURITY_V2.RETIRED;
+        r.updatedAt = now;
+        r.lastReason = "idle_timeout";
+        flipped.push(r.agentId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function autoFailStuckGenJobs(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _jobsV2.values()) {
+    if (r.status === GEN_JOB_V2.RUNNING) {
+      const anchor = r.startedAt || r.createdAt;
+      if (now - anchor > _jobStuckMsV2) {
+        r.status = GEN_JOB_V2.FAILED;
+        r.updatedAt = now;
+        r.lastReason = "job_timeout";
+        flipped.push(r.jobId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function getCodeAgentStatsV2() {
+  const agentsByStatus = {};
+  for (const s of Object.values(AGENT_MATURITY_V2)) agentsByStatus[s] = 0;
+  const jobsByStatus = {};
+  for (const s of Object.values(GEN_JOB_V2)) jobsByStatus[s] = 0;
+  for (const r of _agentsV2.values()) agentsByStatus[r.status]++;
+  for (const r of _jobsV2.values()) jobsByStatus[r.status]++;
+  return {
+    totalAgentsV2: _agentsV2.size,
+    totalJobsV2: _jobsV2.size,
+    maxActiveAgentsPerOwner: _maxActiveAgentsPerOwnerV2,
+    maxRunningJobsPerOwner: _maxRunningJobsPerOwnerV2,
+    agentIdleMs: _agentIdleMsV2,
+    jobStuckMs: _jobStuckMsV2,
+    agentsByStatus,
+    jobsByStatus,
+  };
+}
+
+export function _resetStateV2() {
+  _maxActiveAgentsPerOwnerV2 = CGA_DEFAULT_MAX_ACTIVE_AGENTS_PER_OWNER;
+  _maxRunningJobsPerOwnerV2 = CGA_DEFAULT_MAX_RUNNING_JOBS_PER_OWNER;
+  _agentIdleMsV2 = CGA_DEFAULT_AGENT_IDLE_MS;
+  _jobStuckMsV2 = CGA_DEFAULT_JOB_STUCK_MS;
+  _agentsV2.clear();
+  _jobsV2.clear();
+}