chainlesschain 0.66.0 → 0.132.0

package/src/lib/mcp-registry.js

@@ -345,3 +345,336 @@ export function getServer(idOrName) {
     ) || null
   );
 }
+
+// ===== V2 Surface (cli 0.131.0) — in-memory governance =====
+export const MCP_SERVER_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  DEGRADED: "degraded",
+  RETIRED: "retired",
+});
+export const MCP_INVOCATION_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  DISPATCHING: "dispatching",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const _MS_V2 = MCP_SERVER_MATURITY_V2;
+const _MI_V2 = MCP_INVOCATION_LIFECYCLE_V2;
+const _MS_TRANS_V2 = new Map([
+  [_MS_V2.PENDING, new Set([_MS_V2.ACTIVE, _MS_V2.RETIRED])],
+  [_MS_V2.ACTIVE, new Set([_MS_V2.DEGRADED, _MS_V2.RETIRED])],
+  [_MS_V2.DEGRADED, new Set([_MS_V2.ACTIVE, _MS_V2.RETIRED])],
+  [_MS_V2.RETIRED, new Set()],
+]);
+const _MI_TRANS_V2 = new Map([
+  [_MI_V2.QUEUED, new Set([_MI_V2.DISPATCHING, _MI_V2.CANCELLED])],
+  [
+    _MI_V2.DISPATCHING,
+    new Set([_MI_V2.COMPLETED, _MI_V2.FAILED, _MI_V2.CANCELLED]),
+  ],
+  [_MI_V2.COMPLETED, new Set()],
+  [_MI_V2.FAILED, new Set()],
+  [_MI_V2.CANCELLED, new Set()],
+]);
+const _MI_TERM_V2 = new Set([
+  _MI_V2.COMPLETED,
+  _MI_V2.FAILED,
+  _MI_V2.CANCELLED,
+]);
+
+const MCP_DEFAULT_MAX_ACTIVE_SERVERS_PER_OWNER = 10;
+const MCP_DEFAULT_MAX_PENDING_INVOCATIONS_PER_SERVER = 20;
+const MCP_DEFAULT_SERVER_IDLE_MS = 7 * 24 * 60 * 60 * 1000;
+const MCP_DEFAULT_INVOCATION_STUCK_MS = 2 * 60 * 1000;
+
+const _mcpServersV2 = new Map();
+const _mcpInvocationsV2 = new Map();
+let _mcpConfigV2 = {
+  maxActiveServersPerOwner: MCP_DEFAULT_MAX_ACTIVE_SERVERS_PER_OWNER,
+  maxPendingInvocationsPerServer:
+    MCP_DEFAULT_MAX_PENDING_INVOCATIONS_PER_SERVER,
+  serverIdleMs: MCP_DEFAULT_SERVER_IDLE_MS,
+  invocationStuckMs: MCP_DEFAULT_INVOCATION_STUCK_MS,
+};
+
+function _mcpPosIntV2(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 _resetStateMcpRegistryV2() {
+  _mcpServersV2.clear();
+  _mcpInvocationsV2.clear();
+  _mcpConfigV2 = {
+    maxActiveServersPerOwner: MCP_DEFAULT_MAX_ACTIVE_SERVERS_PER_OWNER,
+    maxPendingInvocationsPerServer:
+      MCP_DEFAULT_MAX_PENDING_INVOCATIONS_PER_SERVER,
+    serverIdleMs: MCP_DEFAULT_SERVER_IDLE_MS,
+    invocationStuckMs: MCP_DEFAULT_INVOCATION_STUCK_MS,
+  };
+}
+
+export function setMaxActiveServersPerOwnerV2(n) {
+  _mcpConfigV2.maxActiveServersPerOwner = _mcpPosIntV2(
+    n,
+    "maxActiveServersPerOwner",
+  );
+}
+export function setMaxPendingInvocationsPerServerV2(n) {
+  _mcpConfigV2.maxPendingInvocationsPerServer = _mcpPosIntV2(
+    n,
+    "maxPendingInvocationsPerServer",
+  );
+}
+export function setServerIdleMsV2(n) {
+  _mcpConfigV2.serverIdleMs = _mcpPosIntV2(n, "serverIdleMs");
+}
+export function setInvocationStuckMsV2(n) {
+  _mcpConfigV2.invocationStuckMs = _mcpPosIntV2(n, "invocationStuckMs");
+}
+export function getMaxActiveServersPerOwnerV2() {
+  return _mcpConfigV2.maxActiveServersPerOwner;
+}
+export function getMaxPendingInvocationsPerServerV2() {
+  return _mcpConfigV2.maxPendingInvocationsPerServer;
+}
+export function getServerIdleMsV2() {
+  return _mcpConfigV2.serverIdleMs;
+}
+export function getInvocationStuckMsV2() {
+  return _mcpConfigV2.invocationStuckMs;
+}
+
+function _copyServerV2(s) {
+  return { ...s, metadata: { ...(s.metadata || {}) } };
+}
+function _copyInvocationV2(i) {
+  return { ...i, metadata: { ...(i.metadata || {}) } };
+}
+
+export function registerServerV2({
+  id,
+  owner,
+  transport,
+  name,
+  metadata,
+} = {}) {
+  if (!id || typeof id !== "string") throw new Error("id required");
+  if (!owner || typeof owner !== "string") throw new Error("owner required");
+  if (!transport || typeof transport !== "string")
+    throw new Error("transport required");
+  if (_mcpServersV2.has(id)) throw new Error(`server ${id} already registered`);
+  const now = Date.now();
+  const s = {
+    id,
+    owner,
+    transport,
+    name: name || id,
+    status: _MS_V2.PENDING,
+    activatedAt: null,
+    retiredAt: null,
+    lastSeenAt: now,
+    createdAt: now,
+    metadata: metadata && typeof metadata === "object" ? { ...metadata } : {},
+  };
+  _mcpServersV2.set(id, s);
+  return _copyServerV2(s);
+}
+
+function _activeServerCountForOwnerV2(owner) {
+  let c = 0;
+  for (const s of _mcpServersV2.values())
+    if (s.owner === owner && s.status === _MS_V2.ACTIVE) c++;
+  return c;
+}
+
+function _transitionServerV2(id, next) {
+  const s = _mcpServersV2.get(id);
+  if (!s) throw new Error(`server ${id} not found`);
+  const allowed = _MS_TRANS_V2.get(s.status);
+  if (!allowed || !allowed.has(next))
+    throw new Error(`invalid transition ${s.status} -> ${next}`);
+  if (next === _MS_V2.ACTIVE && s.status === _MS_V2.PENDING) {
+    if (
+      _activeServerCountForOwnerV2(s.owner) >=
+      _mcpConfigV2.maxActiveServersPerOwner
+    ) {
+      throw new Error(
+        `owner ${s.owner} active-server cap reached (${_mcpConfigV2.maxActiveServersPerOwner})`,
+      );
+    }
+  }
+  const now = Date.now();
+  s.status = next;
+  if (next === _MS_V2.ACTIVE && !s.activatedAt) s.activatedAt = now;
+  if (next === _MS_V2.RETIRED && !s.retiredAt) s.retiredAt = now;
+  s.lastSeenAt = now;
+  return _copyServerV2(s);
+}
+
+export function activateServerV2(id) {
+  return _transitionServerV2(id, _MS_V2.ACTIVE);
+}
+export function degradeServerV2(id) {
+  return _transitionServerV2(id, _MS_V2.DEGRADED);
+}
+export function retireServerV2(id) {
+  return _transitionServerV2(id, _MS_V2.RETIRED);
+}
+export function touchServerV2(id) {
+  const s = _mcpServersV2.get(id);
+  if (!s) throw new Error(`server ${id} not found`);
+  s.lastSeenAt = Date.now();
+  return _copyServerV2(s);
+}
+export function getServerV2(id) {
+  const s = _mcpServersV2.get(id);
+  return s ? _copyServerV2(s) : null;
+}
+export function listServersV2({ owner, status, transport } = {}) {
+  const out = [];
+  for (const s of _mcpServersV2.values()) {
+    if (owner && s.owner !== owner) continue;
+    if (status && s.status !== status) continue;
+    if (transport && s.transport !== transport) continue;
+    out.push(_copyServerV2(s));
+  }
+  return out;
+}
+
+function _pendingInvocationCountForServerV2(serverId) {
+  let c = 0;
+  for (const i of _mcpInvocationsV2.values()) {
+    if (i.serverId !== serverId) continue;
+    if (i.status === _MI_V2.QUEUED || i.status === _MI_V2.DISPATCHING) c++;
+  }
+  return c;
+}
+
+export function createInvocationV2({ id, serverId, tool, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id required");
+  if (!serverId || typeof serverId !== "string")
+    throw new Error("serverId required");
+  if (_mcpInvocationsV2.has(id))
+    throw new Error(`invocation ${id} already exists`);
+  const server = _mcpServersV2.get(serverId);
+  if (!server) throw new Error(`server ${serverId} not found`);
+  if (server.status === _MS_V2.RETIRED)
+    throw new Error(`server ${serverId} retired`);
+  if (
+    _pendingInvocationCountForServerV2(serverId) >=
+    _mcpConfigV2.maxPendingInvocationsPerServer
+  ) {
+    throw new Error(
+      `server ${serverId} pending-invocation cap reached (${_mcpConfigV2.maxPendingInvocationsPerServer})`,
+    );
+  }
+  const now = Date.now();
+  const i = {
+    id,
+    serverId,
+    tool: tool || "unknown",
+    status: _MI_V2.QUEUED,
+    startedAt: null,
+    settledAt: null,
+    createdAt: now,
+    metadata: metadata && typeof metadata === "object" ? { ...metadata } : {},
+  };
+  _mcpInvocationsV2.set(id, i);
+  return _copyInvocationV2(i);
+}
+
+function _transitionInvocationV2(id, next, extra = {}) {
+  const inv = _mcpInvocationsV2.get(id);
+  if (!inv) throw new Error(`invocation ${id} not found`);
+  const allowed = _MI_TRANS_V2.get(inv.status);
+  if (!allowed || !allowed.has(next))
+    throw new Error(`invalid transition ${inv.status} -> ${next}`);
+  const now = Date.now();
+  inv.status = next;
+  if (next === _MI_V2.DISPATCHING && !inv.startedAt) inv.startedAt = now;
+  if (_MI_TERM_V2.has(next) && !inv.settledAt) inv.settledAt = now;
+  if (extra.error) inv.metadata.error = extra.error;
+  return _copyInvocationV2(inv);
+}
+
+export function dispatchInvocationV2(id) {
+  return _transitionInvocationV2(id, _MI_V2.DISPATCHING);
+}
+export function completeInvocationV2(id) {
+  return _transitionInvocationV2(id, _MI_V2.COMPLETED);
+}
+export function failInvocationV2(id, error) {
+  return _transitionInvocationV2(id, _MI_V2.FAILED, { error });
+}
+export function cancelInvocationV2(id) {
+  return _transitionInvocationV2(id, _MI_V2.CANCELLED);
+}
+export function getInvocationV2(id) {
+  const i = _mcpInvocationsV2.get(id);
+  return i ? _copyInvocationV2(i) : null;
+}
+export function listInvocationsV2({ serverId, status, tool } = {}) {
+  const out = [];
+  for (const i of _mcpInvocationsV2.values()) {
+    if (serverId && i.serverId !== serverId) continue;
+    if (status && i.status !== status) continue;
+    if (tool && i.tool !== tool) continue;
+    out.push(_copyInvocationV2(i));
+  }
+  return out;
+}
+
+export function autoDegradeIdleServersV2({ now } = {}) {
+  const t = typeof now === "number" ? now : Date.now();
+  const flipped = [];
+  for (const s of _mcpServersV2.values()) {
+    if (s.status !== _MS_V2.ACTIVE) continue;
+    if (t - s.lastSeenAt > _mcpConfigV2.serverIdleMs) {
+      s.status = _MS_V2.DEGRADED;
+      s.lastSeenAt = t;
+      flipped.push(_copyServerV2(s));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckInvocationsV2({ now } = {}) {
+  const t = typeof now === "number" ? now : Date.now();
+  const flipped = [];
+  for (const i of _mcpInvocationsV2.values()) {
+    if (i.status !== _MI_V2.DISPATCHING) continue;
+    if (i.startedAt && t - i.startedAt > _mcpConfigV2.invocationStuckMs) {
+      i.status = _MI_V2.FAILED;
+      i.settledAt = t;
+      i.metadata.error = "stuck-timeout";
+      flipped.push(_copyInvocationV2(i));
+    }
+  }
+  return flipped;
+}
+
+export function getMcpRegistryStatsV2() {
+  const serversByStatus = {};
+  for (const s of Object.values(_MS_V2)) serversByStatus[s] = 0;
+  for (const s of _mcpServersV2.values()) serversByStatus[s.status]++;
+  const invocationsByStatus = {};
+  for (const s of Object.values(_MI_V2)) invocationsByStatus[s] = 0;
+  for (const i of _mcpInvocationsV2.values()) invocationsByStatus[i.status]++;
+  return {
+    totalServersV2: _mcpServersV2.size,
+    totalInvocationsV2: _mcpInvocationsV2.size,
+    maxActiveServersPerOwner: _mcpConfigV2.maxActiveServersPerOwner,
+    maxPendingInvocationsPerServer: _mcpConfigV2.maxPendingInvocationsPerServer,
+    serverIdleMs: _mcpConfigV2.serverIdleMs,
+    invocationStuckMs: _mcpConfigV2.invocationStuckMs,
+    serversByStatus,
+    invocationsByStatus,
+  };
+}

package/src/lib/memory-manager.js

@@ -209,3 +209,333 @@ export function updateMemoryFile(memoryDir, content) {
   fs.writeFileSync(filePath, content, "utf8");
   return { path: filePath };
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — Memory governance layer.
+ * Tracks per-category entry maturity + consolidation job lifecycle
+ * independent of legacy SQLite memory_entries table.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const ENTRY_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  PARKED: "parked",
+  ARCHIVED: "archived",
+});
+
+export const CONSOLIDATION_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  SUCCEEDED: "succeeded",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const ENTRY_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["active", "archived"])],
+  ["active", new Set(["parked", "archived"])],
+  ["parked", new Set(["active", "archived"])],
+  ["archived", new Set()],
+]);
+const ENTRY_TERMINALS_V2 = new Set(["archived"]);
+
+const JOB_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["running", "cancelled"])],
+  ["running", new Set(["succeeded", "failed", "cancelled"])],
+  ["succeeded", new Set()],
+  ["failed", new Set()],
+  ["cancelled", new Set()],
+]);
+const JOB_TERMINALS_V2 = new Set(["succeeded", "failed", "cancelled"]);
+
+export const MEMORY_DEFAULT_MAX_ACTIVE_ENTRIES_PER_CATEGORY = 200;
+export const MEMORY_DEFAULT_MAX_RUNNING_JOBS_PER_SOURCE = 2;
+export const MEMORY_DEFAULT_ENTRY_IDLE_MS = 1000 * 60 * 60 * 24 * 90; // 90 days
+export const MEMORY_DEFAULT_JOB_STUCK_MS = 1000 * 60 * 10; // 10 minutes
+
+const _entriesV2 = new Map();
+const _jobsV2 = new Map();
+let _maxActiveEntriesPerCategoryV2 =
+  MEMORY_DEFAULT_MAX_ACTIVE_ENTRIES_PER_CATEGORY;
+let _maxRunningJobsPerSourceV2 = MEMORY_DEFAULT_MAX_RUNNING_JOBS_PER_SOURCE;
+let _entryIdleMsV2 = MEMORY_DEFAULT_ENTRY_IDLE_MS;
+let _jobStuckMsV2 = MEMORY_DEFAULT_JOB_STUCK_MS;
+
+function _posIntMemoryV2(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 getMaxActiveEntriesPerCategoryV2() {
+  return _maxActiveEntriesPerCategoryV2;
+}
+export function setMaxActiveEntriesPerCategoryV2(n) {
+  _maxActiveEntriesPerCategoryV2 = _posIntMemoryV2(
+    n,
+    "maxActiveEntriesPerCategory",
+  );
+}
+export function getMaxRunningJobsPerSourceV2() {
+  return _maxRunningJobsPerSourceV2;
+}
+export function setMaxRunningJobsPerSourceV2(n) {
+  _maxRunningJobsPerSourceV2 = _posIntMemoryV2(n, "maxRunningJobsPerSource");
+}
+export function getEntryIdleMsV2() {
+  return _entryIdleMsV2;
+}
+export function setEntryIdleMsV2(n) {
+  _entryIdleMsV2 = _posIntMemoryV2(n, "entryIdleMs");
+}
+export function getJobStuckMsV2() {
+  return _jobStuckMsV2;
+}
+export function setJobStuckMsV2(n) {
+  _jobStuckMsV2 = _posIntMemoryV2(n, "jobStuckMs");
+}
+
+export function getActiveEntryCountV2(category) {
+  let n = 0;
+  for (const e of _entriesV2.values()) {
+    if (e.category === category && e.status === "active") n += 1;
+  }
+  return n;
+}
+
+export function getRunningJobCountV2(source) {
+  let n = 0;
+  for (const j of _jobsV2.values()) {
+    if (j.source === source && j.status === "running") n += 1;
+  }
+  return n;
+}
+
+function _copyEntryV2(e) {
+  return { ...e, metadata: { ...e.metadata } };
+}
+function _copyJobV2(j) {
+  return { ...j, metadata: { ...j.metadata } };
+}
+
+export function registerEntryV2(
+  id,
+  { category, summary, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!category || typeof category !== "string")
+    throw new Error("category must be a string");
+  if (!summary || typeof summary !== "string")
+    throw new Error("summary must be a string");
+  if (_entriesV2.has(id)) throw new Error(`entry ${id} already exists`);
+  const e = {
+    id,
+    category,
+    summary,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: { ...metadata },
+  };
+  _entriesV2.set(id, e);
+  return _copyEntryV2(e);
+}
+
+export function getEntryV2(id) {
+  const e = _entriesV2.get(id);
+  return e ? _copyEntryV2(e) : null;
+}
+
+export function listEntriesV2({ category, status } = {}) {
+  const out = [];
+  for (const e of _entriesV2.values()) {
+    if (category && e.category !== category) continue;
+    if (status && e.status !== status) continue;
+    out.push(_copyEntryV2(e));
+  }
+  return out;
+}
+
+export function setEntryStatusV2(id, next, { now = Date.now() } = {}) {
+  const e = _entriesV2.get(id);
+  if (!e) throw new Error(`entry ${id} not found`);
+  if (!ENTRY_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown entry status: ${next}`);
+  if (ENTRY_TERMINALS_V2.has(e.status))
+    throw new Error(`entry ${id} is in terminal state ${e.status}`);
+  const allowed = ENTRY_TRANSITIONS_V2.get(e.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition entry from ${e.status} to ${next}`);
+  if (next === "active") {
+    if (e.status === "pending") {
+      const count = getActiveEntryCountV2(e.category);
+      if (count >= _maxActiveEntriesPerCategoryV2)
+        throw new Error(
+          `category ${e.category} already at active-entry cap (${_maxActiveEntriesPerCategoryV2})`,
+        );
+    }
+    if (!e.activatedAt) e.activatedAt = now;
+  }
+  if (next === "archived" && !e.archivedAt) e.archivedAt = now;
+  e.status = next;
+  e.lastSeenAt = now;
+  return _copyEntryV2(e);
+}
+
+export function activateEntryV2(id, opts) {
+  return setEntryStatusV2(id, "active", opts);
+}
+export function parkEntryV2(id, opts) {
+  return setEntryStatusV2(id, "parked", opts);
+}
+export function archiveEntryV2(id, opts) {
+  return setEntryStatusV2(id, "archived", opts);
+}
+
+export function touchEntryV2(id, { now = Date.now() } = {}) {
+  const e = _entriesV2.get(id);
+  if (!e) throw new Error(`entry ${id} not found`);
+  e.lastSeenAt = now;
+  return _copyEntryV2(e);
+}
+
+export function createConsolidationJobV2(
+  id,
+  { source, scope, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!source || typeof source !== "string")
+    throw new Error("source must be a string");
+  if (!scope || typeof scope !== "string")
+    throw new Error("scope must be a string");
+  if (_jobsV2.has(id)) throw new Error(`job ${id} already exists`);
+  const j = {
+    id,
+    source,
+    scope,
+    status: "queued",
+    createdAt: now,
+    lastSeenAt: now,
+    startedAt: null,
+    finishedAt: null,
+    metadata: { ...metadata },
+  };
+  _jobsV2.set(id, j);
+  return _copyJobV2(j);
+}
+
+export function getConsolidationJobV2(id) {
+  const j = _jobsV2.get(id);
+  return j ? _copyJobV2(j) : null;
+}
+
+export function listConsolidationJobsV2({ source, status } = {}) {
+  const out = [];
+  for (const j of _jobsV2.values()) {
+    if (source && j.source !== source) continue;
+    if (status && j.status !== status) continue;
+    out.push(_copyJobV2(j));
+  }
+  return out;
+}
+
+export function setJobStatusV2(id, next, { now = Date.now() } = {}) {
+  const j = _jobsV2.get(id);
+  if (!j) throw new Error(`job ${id} not found`);
+  if (!JOB_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown job status: ${next}`);
+  if (JOB_TERMINALS_V2.has(j.status))
+    throw new Error(`job ${id} is in terminal state ${j.status}`);
+  const allowed = JOB_TRANSITIONS_V2.get(j.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition job from ${j.status} to ${next}`);
+  if (next === "running") {
+    if (j.status === "queued") {
+      const count = getRunningJobCountV2(j.source);
+      if (count >= _maxRunningJobsPerSourceV2)
+        throw new Error(
+          `source ${j.source} already at running-job cap (${_maxRunningJobsPerSourceV2})`,
+        );
+    }
+    if (!j.startedAt) j.startedAt = now;
+  }
+  if (JOB_TERMINALS_V2.has(next) && !j.finishedAt) j.finishedAt = now;
+  j.status = next;
+  j.lastSeenAt = now;
+  return _copyJobV2(j);
+}
+
+export function startConsolidationJobV2(id, opts) {
+  return setJobStatusV2(id, "running", opts);
+}
+export function succeedConsolidationJobV2(id, opts) {
+  return setJobStatusV2(id, "succeeded", opts);
+}
+export function failConsolidationJobV2(id, opts) {
+  return setJobStatusV2(id, "failed", opts);
+}
+export function cancelConsolidationJobV2(id, opts) {
+  return setJobStatusV2(id, "cancelled", opts);
+}
+
+export function autoParkIdleEntriesV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const e of _entriesV2.values()) {
+    if (e.status !== "active") continue;
+    if (now - e.lastSeenAt > _entryIdleMsV2) {
+      e.status = "parked";
+      e.lastSeenAt = now;
+      flipped.push(_copyEntryV2(e));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckJobsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const j of _jobsV2.values()) {
+    if (j.status !== "running") continue;
+    if (now - j.lastSeenAt > _jobStuckMsV2) {
+      j.status = "failed";
+      j.lastSeenAt = now;
+      if (!j.finishedAt) j.finishedAt = now;
+      flipped.push(_copyJobV2(j));
+    }
+  }
+  return flipped;
+}
+
+export function getMemoryManagerStatsV2() {
+  const entriesByStatus = {};
+  for (const v of Object.values(ENTRY_MATURITY_V2)) entriesByStatus[v] = 0;
+  for (const e of _entriesV2.values()) entriesByStatus[e.status] += 1;
+
+  const jobsByStatus = {};
+  for (const v of Object.values(CONSOLIDATION_LIFECYCLE_V2))
+    jobsByStatus[v] = 0;
+  for (const j of _jobsV2.values()) jobsByStatus[j.status] += 1;
+
+  return {
+    totalEntriesV2: _entriesV2.size,
+    totalJobsV2: _jobsV2.size,
+    maxActiveEntriesPerCategory: _maxActiveEntriesPerCategoryV2,
+    maxRunningJobsPerSource: _maxRunningJobsPerSourceV2,
+    entryIdleMs: _entryIdleMsV2,
+    jobStuckMs: _jobStuckMsV2,
+    entriesByStatus,
+    jobsByStatus,
+  };
+}
+
+export function _resetStateMemoryManagerV2() {
+  _entriesV2.clear();
+  _jobsV2.clear();
+  _maxActiveEntriesPerCategoryV2 =
+    MEMORY_DEFAULT_MAX_ACTIVE_ENTRIES_PER_CATEGORY;
+  _maxRunningJobsPerSourceV2 = MEMORY_DEFAULT_MAX_RUNNING_JOBS_PER_SOURCE;
+  _entryIdleMsV2 = MEMORY_DEFAULT_ENTRY_IDLE_MS;
+  _jobStuckMsV2 = MEMORY_DEFAULT_JOB_STUCK_MS;
+}