chainlesschain 0.81.0 → 0.132.0

package/src/lib/autonomous-developer.js

@@ -522,3 +522,353 @@ export function _resetState() {
   _adrs.clear();
   _seq = 0;
 }
+
+/* ── V2 Surface (Autonomous Developer) ─────────────────────
+ * Strictly additive. Two parallel state machines:
+ *   - ADR maturity (4 states, superseded terminal)
+ *   - Dev session V2 lifecycle (5 states, 3 terminals)
+ * Per-author active-ADR cap + per-developer running-session cap.
+ * Auto-flip: stale draft ADRs → superseded; stuck running sessions → failed.
+ */
+
+export const ADR_MATURITY_V2 = Object.freeze({
+  DRAFT: "draft",
+  ACCEPTED: "accepted",
+  DEPRECATED: "deprecated",
+  SUPERSEDED: "superseded",
+});
+
+export const DEV_SESSION_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELED: "canceled",
+});
+
+const _ADR_TRANSITIONS_V2 = new Map([
+  [
+    ADR_MATURITY_V2.DRAFT,
+    new Set([ADR_MATURITY_V2.ACCEPTED, ADR_MATURITY_V2.SUPERSEDED]),
+  ],
+  [
+    ADR_MATURITY_V2.ACCEPTED,
+    new Set([ADR_MATURITY_V2.DEPRECATED, ADR_MATURITY_V2.SUPERSEDED]),
+  ],
+  [
+    ADR_MATURITY_V2.DEPRECATED,
+    new Set([ADR_MATURITY_V2.ACCEPTED, ADR_MATURITY_V2.SUPERSEDED]),
+  ],
+]);
+const _ADR_TERMINAL_V2 = new Set([ADR_MATURITY_V2.SUPERSEDED]);
+
+const _SESSION_TRANSITIONS_V2 = new Map([
+  [
+    DEV_SESSION_V2.QUEUED,
+    new Set([
+      DEV_SESSION_V2.RUNNING,
+      DEV_SESSION_V2.CANCELED,
+      DEV_SESSION_V2.FAILED,
+    ]),
+  ],
+  [
+    DEV_SESSION_V2.RUNNING,
+    new Set([
+      DEV_SESSION_V2.COMPLETED,
+      DEV_SESSION_V2.FAILED,
+      DEV_SESSION_V2.CANCELED,
+    ]),
+  ],
+]);
+const _SESSION_TERMINAL_V2 = new Set([
+  DEV_SESSION_V2.COMPLETED,
+  DEV_SESSION_V2.FAILED,
+  DEV_SESSION_V2.CANCELED,
+]);
+
+export const AD_DEFAULT_MAX_ACTIVE_ADRS_PER_AUTHOR = 20;
+export const AD_DEFAULT_MAX_RUNNING_SESSIONS_PER_DEVELOPER = 3;
+export const AD_DEFAULT_ADR_STALE_MS = 90 * 86400000;
+export const AD_DEFAULT_SESSION_STUCK_MS = 2 * 3600000;
+
+let _adMaxActiveAdrsPerAuthor = AD_DEFAULT_MAX_ACTIVE_ADRS_PER_AUTHOR;
+let _adMaxRunningSessionsPerDeveloper =
+  AD_DEFAULT_MAX_RUNNING_SESSIONS_PER_DEVELOPER;
+let _adAdrStaleMs = AD_DEFAULT_ADR_STALE_MS;
+let _adSessionStuckMs = AD_DEFAULT_SESSION_STUCK_MS;
+
+const _adrsV2 = new Map();
+const _sessionsV2 = new Map();
+
+function _positiveIntV2(n, label) {
+  const f = Math.floor(n);
+  if (!Number.isFinite(f) || f <= 0)
+    throw new Error(`${label} must be a positive integer`);
+  return f;
+}
+
+function _now() {
+  return Date.now();
+}
+
+export function getMaxActiveAdrsPerAuthor() {
+  return _adMaxActiveAdrsPerAuthor;
+}
+export function setMaxActiveAdrsPerAuthor(n) {
+  _adMaxActiveAdrsPerAuthor = _positiveIntV2(n, "maxActiveAdrsPerAuthor");
+  return _adMaxActiveAdrsPerAuthor;
+}
+export function getMaxRunningSessionsPerDeveloper() {
+  return _adMaxRunningSessionsPerDeveloper;
+}
+export function setMaxRunningSessionsPerDeveloper(n) {
+  _adMaxRunningSessionsPerDeveloper = _positiveIntV2(
+    n,
+    "maxRunningSessionsPerDeveloper",
+  );
+  return _adMaxRunningSessionsPerDeveloper;
+}
+export function getAdrStaleMs() {
+  return _adAdrStaleMs;
+}
+export function setAdrStaleMs(n) {
+  _adAdrStaleMs = _positiveIntV2(n, "adrStaleMs");
+  return _adAdrStaleMs;
+}
+export function getSessionStuckMs() {
+  return _adSessionStuckMs;
+}
+export function setSessionStuckMs(n) {
+  _adSessionStuckMs = _positiveIntV2(n, "sessionStuckMs");
+  return _adSessionStuckMs;
+}
+
+export function getActiveAdrCount(author) {
+  let c = 0;
+  for (const a of _adrsV2.values()) {
+    if (_ADR_TERMINAL_V2.has(a.status)) continue;
+    if (author !== undefined && a.author !== author) continue;
+    c++;
+  }
+  return c;
+}
+
+export function getRunningSessionCount(developer) {
+  let c = 0;
+  for (const s of _sessionsV2.values()) {
+    if (s.status !== DEV_SESSION_V2.RUNNING) continue;
+    if (developer !== undefined && s.developer !== developer) continue;
+    c++;
+  }
+  return c;
+}
+
+export function createAdrV2({
+  id,
+  author,
+  title,
+  initialStatus,
+  metadata,
+} = {}) {
+  if (!id) throw new Error("id required");
+  if (!author) throw new Error("author required");
+  if (!title) throw new Error("title required");
+  if (_adrsV2.has(id)) throw new Error(`ADR ${id} already exists`);
+  const status = initialStatus ?? ADR_MATURITY_V2.DRAFT;
+  if (!Object.values(ADR_MATURITY_V2).includes(status))
+    throw new Error(`invalid initial status ${status}`);
+  if (
+    !_ADR_TERMINAL_V2.has(status) &&
+    getActiveAdrCount(author) >= _adMaxActiveAdrsPerAuthor
+  )
+    throw new Error(`author ${author} active ADR cap reached`);
+  const now = _now();
+  const a = {
+    id,
+    author,
+    title,
+    status,
+    metadata: metadata ? { ...metadata } : {},
+    createdAt: now,
+    updatedAt: now,
+    acceptedAt: status === ADR_MATURITY_V2.ACCEPTED ? now : null,
+  };
+  _adrsV2.set(id, a);
+  return { ...a, metadata: { ...a.metadata } };
+}
+
+export function getAdrV2(id) {
+  const a = _adrsV2.get(id);
+  return a ? { ...a, metadata: { ...a.metadata } } : null;
+}
+
+export function listAdrsV2({ author, status } = {}) {
+  const out = [];
+  for (const a of _adrsV2.values()) {
+    if (author !== undefined && a.author !== author) continue;
+    if (status !== undefined && a.status !== status) continue;
+    out.push({ ...a, metadata: { ...a.metadata } });
+  }
+  return out;
+}
+
+export function setAdrMaturityV2(id, nextStatus, { reason, metadata } = {}) {
+  const a = _adrsV2.get(id);
+  if (!a) throw new Error(`ADR ${id} not found`);
+  if (_ADR_TERMINAL_V2.has(a.status))
+    throw new Error(`ADR ${id} is terminal (${a.status})`);
+  const allowed = _ADR_TRANSITIONS_V2.get(a.status);
+  if (!allowed || !allowed.has(nextStatus))
+    throw new Error(`illegal transition ${a.status} → ${nextStatus}`);
+  a.status = nextStatus;
+  a.updatedAt = _now();
+  if (reason !== undefined) a.reason = reason;
+  if (metadata) a.metadata = { ...a.metadata, ...metadata };
+  if (nextStatus === ADR_MATURITY_V2.ACCEPTED && !a.acceptedAt)
+    a.acceptedAt = a.updatedAt;
+  return { ...a, metadata: { ...a.metadata } };
+}
+
+export function acceptAdr(id, opts) {
+  return setAdrMaturityV2(id, ADR_MATURITY_V2.ACCEPTED, opts);
+}
+export function deprecateAdr(id, opts) {
+  return setAdrMaturityV2(id, ADR_MATURITY_V2.DEPRECATED, opts);
+}
+export function supersedeAdr(id, opts) {
+  return setAdrMaturityV2(id, ADR_MATURITY_V2.SUPERSEDED, opts);
+}
+
+export function enqueueSessionV2({ id, developer, goal, metadata } = {}) {
+  if (!id) throw new Error("id required");
+  if (!developer) throw new Error("developer required");
+  if (!goal) throw new Error("goal required");
+  if (_sessionsV2.has(id)) throw new Error(`session ${id} already exists`);
+  const now = _now();
+  const s = {
+    id,
+    developer,
+    goal,
+    status: DEV_SESSION_V2.QUEUED,
+    metadata: metadata ? { ...metadata } : {},
+    createdAt: now,
+    updatedAt: now,
+    startedAt: null,
+  };
+  _sessionsV2.set(id, s);
+  return { ...s, metadata: { ...s.metadata } };
+}
+
+export function getSessionV2(id) {
+  const s = _sessionsV2.get(id);
+  return s ? { ...s, metadata: { ...s.metadata } } : null;
+}
+
+export function listSessionsV2({ developer, status } = {}) {
+  const out = [];
+  for (const s of _sessionsV2.values()) {
+    if (developer !== undefined && s.developer !== developer) continue;
+    if (status !== undefined && s.status !== status) continue;
+    out.push({ ...s, metadata: { ...s.metadata } });
+  }
+  return out;
+}
+
+export function setSessionStatusV2(id, nextStatus, { reason, metadata } = {}) {
+  const s = _sessionsV2.get(id);
+  if (!s) throw new Error(`session ${id} not found`);
+  if (_SESSION_TERMINAL_V2.has(s.status))
+    throw new Error(`session ${id} is terminal (${s.status})`);
+  const allowed = _SESSION_TRANSITIONS_V2.get(s.status);
+  if (!allowed || !allowed.has(nextStatus))
+    throw new Error(`illegal transition ${s.status} → ${nextStatus}`);
+  if (nextStatus === DEV_SESSION_V2.RUNNING) {
+    if (
+      getRunningSessionCount(s.developer) >= _adMaxRunningSessionsPerDeveloper
+    )
+      throw new Error(`developer ${s.developer} running session cap reached`);
+  }
+  s.status = nextStatus;
+  s.updatedAt = _now();
+  if (reason !== undefined) s.reason = reason;
+  if (metadata) s.metadata = { ...s.metadata, ...metadata };
+  if (nextStatus === DEV_SESSION_V2.RUNNING && !s.startedAt)
+    s.startedAt = s.updatedAt;
+  return { ...s, metadata: { ...s.metadata } };
+}
+
+export function startSessionV2(id, opts) {
+  return setSessionStatusV2(id, DEV_SESSION_V2.RUNNING, opts);
+}
+export function completeSessionV2(id, opts) {
+  return setSessionStatusV2(id, DEV_SESSION_V2.COMPLETED, opts);
+}
+export function failSessionV2(id, opts) {
+  return setSessionStatusV2(id, DEV_SESSION_V2.FAILED, opts);
+}
+export function cancelSessionV2(id, opts) {
+  return setSessionStatusV2(id, DEV_SESSION_V2.CANCELED, opts);
+}
+
+export function autoSupersedeStaleDrafts({ now } = {}) {
+  const cutoff = (now ?? _now()) - _adAdrStaleMs;
+  const flipped = [];
+  for (const a of _adrsV2.values()) {
+    if (a.status !== ADR_MATURITY_V2.DRAFT) continue;
+    if ((a.updatedAt ?? a.createdAt) > cutoff) continue;
+    a.status = ADR_MATURITY_V2.SUPERSEDED;
+    a.updatedAt = now ?? _now();
+    a.reason = "auto_supersede_stale_draft";
+    flipped.push(a.id);
+  }
+  return flipped;
+}
+
+export function autoFailStuckSessions({ now } = {}) {
+  const cutoff = (now ?? _now()) - _adSessionStuckMs;
+  const flipped = [];
+  for (const s of _sessionsV2.values()) {
+    if (s.status !== DEV_SESSION_V2.RUNNING) continue;
+    if (!s.startedAt || s.startedAt > cutoff) continue;
+    s.status = DEV_SESSION_V2.FAILED;
+    s.updatedAt = now ?? _now();
+    s.reason = "auto_fail_stuck";
+    flipped.push(s.id);
+  }
+  return flipped;
+}
+
+function _zeroByEnum(enumObj) {
+  const out = {};
+  for (const v of Object.values(enumObj)) out[v] = 0;
+  return out;
+}
+
+export function getAutonomousDeveloperStatsV2() {
+  const adrs = [..._adrsV2.values()];
+  const sessions = [..._sessionsV2.values()];
+  const adrsByStatus = _zeroByEnum(ADR_MATURITY_V2);
+  for (const a of adrs) adrsByStatus[a.status]++;
+  const sessionsByStatus = _zeroByEnum(DEV_SESSION_V2);
+  for (const s of sessions) sessionsByStatus[s.status]++;
+  return {
+    totalAdrsV2: adrs.length,
+    totalSessionsV2: sessions.length,
+    maxActiveAdrsPerAuthor: _adMaxActiveAdrsPerAuthor,
+    maxRunningSessionsPerDeveloper: _adMaxRunningSessionsPerDeveloper,
+    adrStaleMs: _adAdrStaleMs,
+    sessionStuckMs: _adSessionStuckMs,
+    adrsByStatus,
+    sessionsByStatus,
+  };
+}
+
+export function _resetStateV2() {
+  _adrsV2.clear();
+  _sessionsV2.clear();
+  _adMaxActiveAdrsPerAuthor = AD_DEFAULT_MAX_ACTIVE_ADRS_PER_AUTHOR;
+  _adMaxRunningSessionsPerDeveloper =
+    AD_DEFAULT_MAX_RUNNING_SESSIONS_PER_DEVELOPER;
+  _adAdrStaleMs = AD_DEFAULT_ADR_STALE_MS;
+  _adSessionStuckMs = AD_DEFAULT_SESSION_STUCK_MS;
+}

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();
+}