chainlesschain 0.81.0 → 0.132.0

package/src/lib/scim-manager.js

@@ -210,3 +210,332 @@ export function _resetState() {
   _connectors.clear();
   _syncLog.length = 0;
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — SCIM provisioning lifecycle layer.
+ * Tracks identities and sync-job lifecycle independent of legacy
+ * createUser/syncProvision flows above.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const IDENTITY_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending",
+  PROVISIONED: "provisioned",
+  SUSPENDED: "suspended",
+  DEPROVISIONED: "deprovisioned",
+});
+
+export const SYNC_JOB_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  SUCCEEDED: "succeeded",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const IDENTITY_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["provisioned", "deprovisioned"])],
+  ["provisioned", new Set(["suspended", "deprovisioned"])],
+  ["suspended", new Set(["provisioned", "deprovisioned"])],
+  ["deprovisioned", new Set()],
+]);
+const IDENTITY_TERMINALS_V2 = new Set(["deprovisioned"]);
+
+const SYNC_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 SYNC_TERMINALS_V2 = new Set(["succeeded", "failed", "cancelled"]);
+
+export const SCIM_DEFAULT_MAX_PROVISIONED_PER_CONNECTOR = 1000;
+export const SCIM_DEFAULT_MAX_RUNNING_SYNC_PER_CONNECTOR = 2;
+export const SCIM_DEFAULT_IDENTITY_IDLE_MS = 1000 * 60 * 60 * 24 * 90; // 90 days
+export const SCIM_DEFAULT_SYNC_STUCK_MS = 1000 * 60 * 30; // 30 min
+
+const _identitiesV2 = new Map();
+const _syncJobsV2 = new Map();
+let _maxProvisionedPerConnectorV2 = SCIM_DEFAULT_MAX_PROVISIONED_PER_CONNECTOR;
+let _maxRunningSyncPerConnectorV2 = SCIM_DEFAULT_MAX_RUNNING_SYNC_PER_CONNECTOR;
+let _identityIdleMsV2 = SCIM_DEFAULT_IDENTITY_IDLE_MS;
+let _syncStuckMsV2 = SCIM_DEFAULT_SYNC_STUCK_MS;
+
+function _posIntScimV2(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 getMaxProvisionedPerConnectorV2() {
+  return _maxProvisionedPerConnectorV2;
+}
+export function setMaxProvisionedPerConnectorV2(n) {
+  _maxProvisionedPerConnectorV2 = _posIntScimV2(
+    n,
+    "maxProvisionedPerConnector",
+  );
+}
+export function getMaxRunningSyncPerConnectorV2() {
+  return _maxRunningSyncPerConnectorV2;
+}
+export function setMaxRunningSyncPerConnectorV2(n) {
+  _maxRunningSyncPerConnectorV2 = _posIntScimV2(
+    n,
+    "maxRunningSyncPerConnector",
+  );
+}
+export function getIdentityIdleMsV2() {
+  return _identityIdleMsV2;
+}
+export function setIdentityIdleMsV2(n) {
+  _identityIdleMsV2 = _posIntScimV2(n, "identityIdleMs");
+}
+export function getSyncStuckMsV2() {
+  return _syncStuckMsV2;
+}
+export function setSyncStuckMsV2(n) {
+  _syncStuckMsV2 = _posIntScimV2(n, "syncStuckMs");
+}
+
+export function getProvisionedCountV2(connectorId) {
+  let n = 0;
+  for (const i of _identitiesV2.values()) {
+    if (i.connectorId === connectorId && i.status === "provisioned") n += 1;
+  }
+  return n;
+}
+
+export function getRunningSyncCountV2(connectorId) {
+  let n = 0;
+  for (const j of _syncJobsV2.values()) {
+    if (j.connectorId === connectorId && j.status === "running") n += 1;
+  }
+  return n;
+}
+
+function _copyIdentityV2(i) {
+  return { ...i, metadata: { ...i.metadata } };
+}
+function _copySyncV2(j) {
+  return { ...j, metadata: { ...j.metadata } };
+}
+
+export function registerIdentityV2(
+  id,
+  { connectorId, externalId, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!connectorId || typeof connectorId !== "string")
+    throw new Error("connectorId must be a string");
+  if (!externalId || typeof externalId !== "string")
+    throw new Error("externalId must be a string");
+  if (_identitiesV2.has(id)) throw new Error(`identity ${id} already exists`);
+  const i = {
+    id,
+    connectorId,
+    externalId,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    provisionedAt: null,
+    deprovisionedAt: null,
+    metadata: { ...metadata },
+  };
+  _identitiesV2.set(id, i);
+  return _copyIdentityV2(i);
+}
+
+export function getIdentityV2(id) {
+  const i = _identitiesV2.get(id);
+  return i ? _copyIdentityV2(i) : null;
+}
+
+export function listIdentitiesV2({ connectorId, status } = {}) {
+  const out = [];
+  for (const i of _identitiesV2.values()) {
+    if (connectorId && i.connectorId !== connectorId) continue;
+    if (status && i.status !== status) continue;
+    out.push(_copyIdentityV2(i));
+  }
+  return out;
+}
+
+export function setIdentityStatusV2(id, next, { now = Date.now() } = {}) {
+  const i = _identitiesV2.get(id);
+  if (!i) throw new Error(`identity ${id} not found`);
+  if (!IDENTITY_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown identity status: ${next}`);
+  if (IDENTITY_TERMINALS_V2.has(i.status))
+    throw new Error(`identity ${id} is in terminal state ${i.status}`);
+  const allowed = IDENTITY_TRANSITIONS_V2.get(i.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition identity from ${i.status} to ${next}`);
+  if (next === "provisioned") {
+    if (i.status === "pending") {
+      const count = getProvisionedCountV2(i.connectorId);
+      if (count >= _maxProvisionedPerConnectorV2)
+        throw new Error(
+          `connector ${i.connectorId} already at provisioned cap (${_maxProvisionedPerConnectorV2})`,
+        );
+    }
+    if (!i.provisionedAt) i.provisionedAt = now;
+  }
+  if (next === "deprovisioned" && !i.deprovisionedAt) i.deprovisionedAt = now;
+  i.status = next;
+  i.lastSeenAt = now;
+  return _copyIdentityV2(i);
+}
+
+export function provisionIdentityV2(id, opts) {
+  return setIdentityStatusV2(id, "provisioned", opts);
+}
+export function suspendIdentityV2(id, opts) {
+  return setIdentityStatusV2(id, "suspended", opts);
+}
+export function deprovisionIdentityV2(id, opts) {
+  return setIdentityStatusV2(id, "deprovisioned", opts);
+}
+
+export function touchIdentityV2(id, { now = Date.now() } = {}) {
+  const i = _identitiesV2.get(id);
+  if (!i) throw new Error(`identity ${id} not found`);
+  i.lastSeenAt = now;
+  return _copyIdentityV2(i);
+}
+
+export function createSyncJobV2(
+  id,
+  { connectorId, kind = "full", metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!connectorId || typeof connectorId !== "string")
+    throw new Error("connectorId must be a string");
+  if (_syncJobsV2.has(id)) throw new Error(`syncJob ${id} already exists`);
+  const j = {
+    id,
+    connectorId,
+    kind,
+    status: "queued",
+    createdAt: now,
+    lastSeenAt: now,
+    startedAt: null,
+    finishedAt: null,
+    metadata: { ...metadata },
+  };
+  _syncJobsV2.set(id, j);
+  return _copySyncV2(j);
+}
+
+export function getSyncJobV2(id) {
+  const j = _syncJobsV2.get(id);
+  return j ? _copySyncV2(j) : null;
+}
+
+export function listSyncJobsV2({ connectorId, status } = {}) {
+  const out = [];
+  for (const j of _syncJobsV2.values()) {
+    if (connectorId && j.connectorId !== connectorId) continue;
+    if (status && j.status !== status) continue;
+    out.push(_copySyncV2(j));
+  }
+  return out;
+}
+
+export function setSyncJobStatusV2(id, next, { now = Date.now() } = {}) {
+  const j = _syncJobsV2.get(id);
+  if (!j) throw new Error(`syncJob ${id} not found`);
+  if (!SYNC_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown syncJob status: ${next}`);
+  if (SYNC_TERMINALS_V2.has(j.status))
+    throw new Error(`syncJob ${id} is in terminal state ${j.status}`);
+  const allowed = SYNC_TRANSITIONS_V2.get(j.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition syncJob from ${j.status} to ${next}`);
+  if (next === "running" && j.status === "queued") {
+    const count = getRunningSyncCountV2(j.connectorId);
+    if (count >= _maxRunningSyncPerConnectorV2)
+      throw new Error(
+        `connector ${j.connectorId} already at running-sync cap (${_maxRunningSyncPerConnectorV2})`,
+      );
+    if (!j.startedAt) j.startedAt = now;
+  }
+  if (SYNC_TERMINALS_V2.has(next) && !j.finishedAt) j.finishedAt = now;
+  j.status = next;
+  j.lastSeenAt = now;
+  return _copySyncV2(j);
+}
+
+export function startSyncJobV2(id, opts) {
+  return setSyncJobStatusV2(id, "running", opts);
+}
+export function succeedSyncJobV2(id, opts) {
+  return setSyncJobStatusV2(id, "succeeded", opts);
+}
+export function failSyncJobV2(id, opts) {
+  return setSyncJobStatusV2(id, "failed", opts);
+}
+export function cancelSyncJobV2(id, opts) {
+  return setSyncJobStatusV2(id, "cancelled", opts);
+}
+
+export function autoDeprovisionIdleIdentitiesV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const i of _identitiesV2.values()) {
+    if (i.status === "deprovisioned" || i.status === "pending") continue;
+    if (now - i.lastSeenAt > _identityIdleMsV2) {
+      i.status = "deprovisioned";
+      i.lastSeenAt = now;
+      if (!i.deprovisionedAt) i.deprovisionedAt = now;
+      flipped.push(_copyIdentityV2(i));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckSyncJobsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const j of _syncJobsV2.values()) {
+    if (j.status !== "running") continue;
+    const ref = j.startedAt ?? j.lastSeenAt;
+    if (now - ref > _syncStuckMsV2) {
+      j.status = "failed";
+      j.lastSeenAt = now;
+      if (!j.finishedAt) j.finishedAt = now;
+      flipped.push(_copySyncV2(j));
+    }
+  }
+  return flipped;
+}
+
+export function getScimManagerStatsV2() {
+  const identitiesByStatus = {};
+  for (const v of Object.values(IDENTITY_LIFECYCLE_V2))
+    identitiesByStatus[v] = 0;
+  for (const i of _identitiesV2.values()) identitiesByStatus[i.status] += 1;
+
+  const syncJobsByStatus = {};
+  for (const v of Object.values(SYNC_JOB_V2)) syncJobsByStatus[v] = 0;
+  for (const j of _syncJobsV2.values()) syncJobsByStatus[j.status] += 1;
+
+  return {
+    totalIdentitiesV2: _identitiesV2.size,
+    totalSyncJobsV2: _syncJobsV2.size,
+    maxProvisionedPerConnector: _maxProvisionedPerConnectorV2,
+    maxRunningSyncPerConnector: _maxRunningSyncPerConnectorV2,
+    identityIdleMs: _identityIdleMsV2,
+    syncStuckMs: _syncStuckMsV2,
+    identitiesByStatus,
+    syncJobsByStatus,
+  };
+}
+
+export function _resetStateScimManagerV2() {
+  _identitiesV2.clear();
+  _syncJobsV2.clear();
+  _maxProvisionedPerConnectorV2 = SCIM_DEFAULT_MAX_PROVISIONED_PER_CONNECTOR;
+  _maxRunningSyncPerConnectorV2 = SCIM_DEFAULT_MAX_RUNNING_SYNC_PER_CONNECTOR;
+  _identityIdleMsV2 = SCIM_DEFAULT_IDENTITY_IDLE_MS;
+  _syncStuckMsV2 = SCIM_DEFAULT_SYNC_STUCK_MS;
+}

package/src/lib/session-manager.js

@@ -262,3 +262,332 @@ export function exportSessionMarkdown(session) {
 
   return lines.join("\n");
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — Session governance layer.
+ * Tracks conversation maturity + turn lifecycle independent of
+ * legacy llm_sessions SQLite store above.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const CONVERSATION_MATURITY_V2 = Object.freeze({
+  DRAFT: "draft",
+  ACTIVE: "active",
+  PAUSED: "paused",
+  ARCHIVED: "archived",
+});
+
+export const TURN_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending",
+  STREAMING: "streaming",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const CONV_TRANSITIONS_V2 = new Map([
+  ["draft", new Set(["active", "archived"])],
+  ["active", new Set(["paused", "archived"])],
+  ["paused", new Set(["active", "archived"])],
+  ["archived", new Set()],
+]);
+const CONV_TERMINALS_V2 = new Set(["archived"]);
+
+const TURN_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["streaming", "cancelled"])],
+  ["streaming", new Set(["completed", "failed", "cancelled"])],
+  ["completed", new Set()],
+  ["failed", new Set()],
+  ["cancelled", new Set()],
+]);
+const TURN_TERMINALS_V2 = new Set(["completed", "failed", "cancelled"]);
+
+export const SESSION_DEFAULT_MAX_ACTIVE_CONV_PER_USER = 50;
+export const SESSION_DEFAULT_MAX_PENDING_TURNS_PER_CONV = 3;
+export const SESSION_DEFAULT_CONV_IDLE_MS = 1000 * 60 * 60 * 24 * 14; // 14 days
+export const SESSION_DEFAULT_TURN_STUCK_MS = 1000 * 60 * 5; // 5 min
+
+const _conversationsV2 = new Map();
+const _turnsV2 = new Map();
+let _maxActiveConvPerUserV2 = SESSION_DEFAULT_MAX_ACTIVE_CONV_PER_USER;
+let _maxPendingTurnsPerConvV2 = SESSION_DEFAULT_MAX_PENDING_TURNS_PER_CONV;
+let _convIdleMsV2 = SESSION_DEFAULT_CONV_IDLE_MS;
+let _turnStuckMsV2 = SESSION_DEFAULT_TURN_STUCK_MS;
+
+function _posIntSessionV2(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 getMaxActiveConvPerUserV2() {
+  return _maxActiveConvPerUserV2;
+}
+export function setMaxActiveConvPerUserV2(n) {
+  _maxActiveConvPerUserV2 = _posIntSessionV2(n, "maxActiveConvPerUser");
+}
+export function getMaxPendingTurnsPerConvV2() {
+  return _maxPendingTurnsPerConvV2;
+}
+export function setMaxPendingTurnsPerConvV2(n) {
+  _maxPendingTurnsPerConvV2 = _posIntSessionV2(n, "maxPendingTurnsPerConv");
+}
+export function getConvIdleMsV2() {
+  return _convIdleMsV2;
+}
+export function setConvIdleMsV2(n) {
+  _convIdleMsV2 = _posIntSessionV2(n, "convIdleMs");
+}
+export function getTurnStuckMsV2() {
+  return _turnStuckMsV2;
+}
+export function setTurnStuckMsV2(n) {
+  _turnStuckMsV2 = _posIntSessionV2(n, "turnStuckMs");
+}
+
+export function getActiveConvCountV2(userId) {
+  let n = 0;
+  for (const c of _conversationsV2.values()) {
+    if (c.userId === userId && c.status === "active") n += 1;
+  }
+  return n;
+}
+
+export function getPendingTurnCountV2(conversationId) {
+  let n = 0;
+  for (const t of _turnsV2.values()) {
+    if (
+      t.conversationId === conversationId &&
+      (t.status === "pending" || t.status === "streaming")
+    )
+      n += 1;
+  }
+  return n;
+}
+
+function _copyConvV2(c) {
+  return { ...c, metadata: { ...c.metadata } };
+}
+function _copyTurnV2(t) {
+  return { ...t, metadata: { ...t.metadata } };
+}
+
+export function registerConversationV2(
+  id,
+  { userId, model, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!userId || typeof userId !== "string")
+    throw new Error("userId must be a string");
+  if (!model || typeof model !== "string")
+    throw new Error("model must be a string");
+  if (_conversationsV2.has(id))
+    throw new Error(`conversation ${id} already exists`);
+  const c = {
+    id,
+    userId,
+    model,
+    status: "draft",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: { ...metadata },
+  };
+  _conversationsV2.set(id, c);
+  return _copyConvV2(c);
+}
+
+export function getConversationV2(id) {
+  const c = _conversationsV2.get(id);
+  return c ? _copyConvV2(c) : null;
+}
+
+export function listConversationsV2({ userId, status } = {}) {
+  const out = [];
+  for (const c of _conversationsV2.values()) {
+    if (userId && c.userId !== userId) continue;
+    if (status && c.status !== status) continue;
+    out.push(_copyConvV2(c));
+  }
+  return out;
+}
+
+export function setConversationStatusV2(id, next, { now = Date.now() } = {}) {
+  const c = _conversationsV2.get(id);
+  if (!c) throw new Error(`conversation ${id} not found`);
+  if (!CONV_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown conversation status: ${next}`);
+  if (CONV_TERMINALS_V2.has(c.status))
+    throw new Error(`conversation ${id} is in terminal state ${c.status}`);
+  const allowed = CONV_TRANSITIONS_V2.get(c.status);
+  if (!allowed.has(next))
+    throw new Error(
+      `cannot transition conversation from ${c.status} to ${next}`,
+    );
+  if (next === "active") {
+    if (c.status === "draft") {
+      const count = getActiveConvCountV2(c.userId);
+      if (count >= _maxActiveConvPerUserV2)
+        throw new Error(
+          `user ${c.userId} already at active-conversation cap (${_maxActiveConvPerUserV2})`,
+        );
+    }
+    if (!c.activatedAt) c.activatedAt = now;
+  }
+  if (next === "archived" && !c.archivedAt) c.archivedAt = now;
+  c.status = next;
+  c.lastSeenAt = now;
+  return _copyConvV2(c);
+}
+
+export function activateConversationV2(id, opts) {
+  return setConversationStatusV2(id, "active", opts);
+}
+export function pauseConversationV2(id, opts) {
+  return setConversationStatusV2(id, "paused", opts);
+}
+export function archiveConversationV2(id, opts) {
+  return setConversationStatusV2(id, "archived", opts);
+}
+
+export function touchConversationV2(id, { now = Date.now() } = {}) {
+  const c = _conversationsV2.get(id);
+  if (!c) throw new Error(`conversation ${id} not found`);
+  c.lastSeenAt = now;
+  return _copyConvV2(c);
+}
+
+export function createTurnV2(
+  id,
+  { conversationId, role = "user", metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!conversationId || typeof conversationId !== "string")
+    throw new Error("conversationId must be a string");
+  if (_turnsV2.has(id)) throw new Error(`turn ${id} already exists`);
+  const count = getPendingTurnCountV2(conversationId);
+  if (count >= _maxPendingTurnsPerConvV2)
+    throw new Error(
+      `conversation ${conversationId} already at pending-turn cap (${_maxPendingTurnsPerConvV2})`,
+    );
+  const t = {
+    id,
+    conversationId,
+    role,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    streamingStartedAt: null,
+    settledAt: null,
+    metadata: { ...metadata },
+  };
+  _turnsV2.set(id, t);
+  return _copyTurnV2(t);
+}
+
+export function getTurnV2(id) {
+  const t = _turnsV2.get(id);
+  return t ? _copyTurnV2(t) : null;
+}
+
+export function listTurnsV2({ conversationId, status } = {}) {
+  const out = [];
+  for (const t of _turnsV2.values()) {
+    if (conversationId && t.conversationId !== conversationId) continue;
+    if (status && t.status !== status) continue;
+    out.push(_copyTurnV2(t));
+  }
+  return out;
+}
+
+export function setTurnStatusV2(id, next, { now = Date.now() } = {}) {
+  const t = _turnsV2.get(id);
+  if (!t) throw new Error(`turn ${id} not found`);
+  if (!TURN_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown turn status: ${next}`);
+  if (TURN_TERMINALS_V2.has(t.status))
+    throw new Error(`turn ${id} is in terminal state ${t.status}`);
+  const allowed = TURN_TRANSITIONS_V2.get(t.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition turn from ${t.status} to ${next}`);
+  if (next === "streaming" && !t.streamingStartedAt) t.streamingStartedAt = now;
+  if (TURN_TERMINALS_V2.has(next) && !t.settledAt) t.settledAt = now;
+  t.status = next;
+  t.lastSeenAt = now;
+  return _copyTurnV2(t);
+}
+
+export function streamTurnV2(id, opts) {
+  return setTurnStatusV2(id, "streaming", opts);
+}
+export function completeTurnV2(id, opts) {
+  return setTurnStatusV2(id, "completed", opts);
+}
+export function failTurnV2(id, opts) {
+  return setTurnStatusV2(id, "failed", opts);
+}
+export function cancelTurnV2(id, opts) {
+  return setTurnStatusV2(id, "cancelled", opts);
+}
+
+export function autoArchiveIdleConversationsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const c of _conversationsV2.values()) {
+    if (c.status === "archived" || c.status === "draft") continue;
+    if (now - c.lastSeenAt > _convIdleMsV2) {
+      c.status = "archived";
+      c.lastSeenAt = now;
+      if (!c.archivedAt) c.archivedAt = now;
+      flipped.push(_copyConvV2(c));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckTurnsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const t of _turnsV2.values()) {
+    if (t.status !== "streaming") continue;
+    const ref = t.streamingStartedAt ?? t.lastSeenAt;
+    if (now - ref > _turnStuckMsV2) {
+      t.status = "failed";
+      t.lastSeenAt = now;
+      if (!t.settledAt) t.settledAt = now;
+      flipped.push(_copyTurnV2(t));
+    }
+  }
+  return flipped;
+}
+
+export function getSessionManagerStatsV2() {
+  const conversationsByStatus = {};
+  for (const v of Object.values(CONVERSATION_MATURITY_V2))
+    conversationsByStatus[v] = 0;
+  for (const c of _conversationsV2.values())
+    conversationsByStatus[c.status] += 1;
+
+  const turnsByStatus = {};
+  for (const v of Object.values(TURN_LIFECYCLE_V2)) turnsByStatus[v] = 0;
+  for (const t of _turnsV2.values()) turnsByStatus[t.status] += 1;
+
+  return {
+    totalConversationsV2: _conversationsV2.size,
+    totalTurnsV2: _turnsV2.size,
+    maxActiveConvPerUser: _maxActiveConvPerUserV2,
+    maxPendingTurnsPerConv: _maxPendingTurnsPerConvV2,
+    convIdleMs: _convIdleMsV2,
+    turnStuckMs: _turnStuckMsV2,
+    conversationsByStatus,
+    turnsByStatus,
+  };
+}
+
+export function _resetStateSessionManagerV2() {
+  _conversationsV2.clear();
+  _turnsV2.clear();
+  _maxActiveConvPerUserV2 = SESSION_DEFAULT_MAX_ACTIVE_CONV_PER_USER;
+  _maxPendingTurnsPerConvV2 = SESSION_DEFAULT_MAX_PENDING_TURNS_PER_CONV;
+  _convIdleMsV2 = SESSION_DEFAULT_CONV_IDLE_MS;
+  _turnStuckMsV2 = SESSION_DEFAULT_TURN_STUCK_MS;
+}