chainlesschain 0.81.0 → 0.143.0

package/src/lib/llm-providers.js

@@ -365,3 +365,394 @@ export class LLMProviderRegistry {
     return { ok: true, elapsed: Date.now() - start, response: text.trim() };
   }
 }
+
+/* ─────────────────────────────────────────────────────────────────
+ * V2 Governance Layer (in-memory, independent of SQLite llm_providers)
+ *
+ *   Provider profile maturity: pending → active → suspended → retired
+ *     - retired terminal
+ *     - suspended → active recovery (cap-exempt)
+ *
+ *   Request lifecycle: queued → running → completed | failed | cancelled
+ *     - 3 terminals
+ *     - per-profile pending-request cap counts queued+running
+ *
+ *   Per-owner active-profile cap on pending→active only (recovery exempt).
+ *   Per-profile pending-request cap enforced at createRequestV2.
+ *
+ *   Auto-flip:
+ *     - autoSuspendIdleProfilesV2  active w/ lastSeenAt past idle threshold → suspended
+ *     - autoFailStuckRequestsV2    running w/ startedAt past stuck threshold → failed
+ * ───────────────────────────────────────────────────────────────── */
+
+export const PROVIDER_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  SUSPENDED: "suspended",
+  RETIRED: "retired",
+});
+
+export const REQUEST_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const _PROVIDER_TRANSITIONS_V2 = new Map([
+  [
+    PROVIDER_MATURITY_V2.PENDING,
+    new Set([PROVIDER_MATURITY_V2.ACTIVE, PROVIDER_MATURITY_V2.RETIRED]),
+  ],
+  [
+    PROVIDER_MATURITY_V2.ACTIVE,
+    new Set([PROVIDER_MATURITY_V2.SUSPENDED, PROVIDER_MATURITY_V2.RETIRED]),
+  ],
+  [
+    PROVIDER_MATURITY_V2.SUSPENDED,
+    new Set([PROVIDER_MATURITY_V2.ACTIVE, PROVIDER_MATURITY_V2.RETIRED]),
+  ],
+  [PROVIDER_MATURITY_V2.RETIRED, new Set()],
+]);
+const _PROVIDER_TERMINALS_V2 = new Set([PROVIDER_MATURITY_V2.RETIRED]);
+
+const _REQUEST_TRANSITIONS_V2 = new Map([
+  [
+    REQUEST_LIFECYCLE_V2.QUEUED,
+    new Set([REQUEST_LIFECYCLE_V2.RUNNING, REQUEST_LIFECYCLE_V2.CANCELLED]),
+  ],
+  [
+    REQUEST_LIFECYCLE_V2.RUNNING,
+    new Set([
+      REQUEST_LIFECYCLE_V2.COMPLETED,
+      REQUEST_LIFECYCLE_V2.FAILED,
+      REQUEST_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [REQUEST_LIFECYCLE_V2.COMPLETED, new Set()],
+  [REQUEST_LIFECYCLE_V2.FAILED, new Set()],
+  [REQUEST_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _REQUEST_TERMINALS_V2 = new Set([
+  REQUEST_LIFECYCLE_V2.COMPLETED,
+  REQUEST_LIFECYCLE_V2.FAILED,
+  REQUEST_LIFECYCLE_V2.CANCELLED,
+]);
+
+export const PROVIDER_DEFAULT_MAX_ACTIVE_PER_OWNER = 8;
+export const PROVIDER_DEFAULT_MAX_PENDING_REQUESTS_PER_PROFILE = 16;
+export const PROVIDER_DEFAULT_PROFILE_IDLE_MS = 14 * 24 * 60 * 60 * 1000;
+export const PROVIDER_DEFAULT_REQUEST_STUCK_MS = 5 * 60 * 1000;
+
+const _stateLlmV2 = {
+  profiles: new Map(),
+  requests: new Map(),
+  maxActiveProfilesPerOwner: PROVIDER_DEFAULT_MAX_ACTIVE_PER_OWNER,
+  maxPendingRequestsPerProfile:
+    PROVIDER_DEFAULT_MAX_PENDING_REQUESTS_PER_PROFILE,
+  profileIdleMs: PROVIDER_DEFAULT_PROFILE_IDLE_MS,
+  requestStuckMs: PROVIDER_DEFAULT_REQUEST_STUCK_MS,
+};
+
+function _posIntLlmV2(n, label) {
+  const v = Math.floor(n);
+  if (!Number.isFinite(v) || v <= 0) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return v;
+}
+
+function _copyProfileV2(p) {
+  return { ...p, metadata: { ...p.metadata } };
+}
+
+function _copyRequestV2(r) {
+  return { ...r, metadata: { ...r.metadata } };
+}
+
+export function getMaxActiveProfilesPerOwnerV2() {
+  return _stateLlmV2.maxActiveProfilesPerOwner;
+}
+
+export function setMaxActiveProfilesPerOwnerV2(n) {
+  _stateLlmV2.maxActiveProfilesPerOwner = _posIntLlmV2(
+    n,
+    "maxActiveProfilesPerOwner",
+  );
+}
+
+export function getMaxPendingRequestsPerProfileV2() {
+  return _stateLlmV2.maxPendingRequestsPerProfile;
+}
+
+export function setMaxPendingRequestsPerProfileV2(n) {
+  _stateLlmV2.maxPendingRequestsPerProfile = _posIntLlmV2(
+    n,
+    "maxPendingRequestsPerProfile",
+  );
+}
+
+export function getProfileIdleMsV2() {
+  return _stateLlmV2.profileIdleMs;
+}
+
+export function setProfileIdleMsV2(ms) {
+  _stateLlmV2.profileIdleMs = _posIntLlmV2(ms, "profileIdleMs");
+}
+
+export function getRequestStuckMsV2() {
+  return _stateLlmV2.requestStuckMs;
+}
+
+export function setRequestStuckMsV2(ms) {
+  _stateLlmV2.requestStuckMs = _posIntLlmV2(ms, "requestStuckMs");
+}
+
+export function getActiveProfileCountV2(ownerId) {
+  let count = 0;
+  for (const p of _stateLlmV2.profiles.values()) {
+    if (p.ownerId === ownerId && p.status === PROVIDER_MATURITY_V2.ACTIVE) {
+      count++;
+    }
+  }
+  return count;
+}
+
+export function getPendingRequestCountV2(profileId) {
+  let count = 0;
+  for (const r of _stateLlmV2.requests.values()) {
+    if (
+      r.profileId === profileId &&
+      (r.status === REQUEST_LIFECYCLE_V2.QUEUED ||
+        r.status === REQUEST_LIFECYCLE_V2.RUNNING)
+    ) {
+      count++;
+    }
+  }
+  return count;
+}
+
+export function registerProfileV2(
+  id,
+  { ownerId, provider, model, metadata } = {},
+) {
+  if (!id) throw new Error("profile id is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (!provider) throw new Error("provider is required");
+  if (_stateLlmV2.profiles.has(id))
+    throw new Error(`profile ${id} already exists`);
+  const now = Date.now();
+  const profile = {
+    id,
+    ownerId,
+    provider,
+    model: model || "default",
+    status: PROVIDER_MATURITY_V2.PENDING,
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    retiredAt: null,
+    metadata: metadata ? { ...metadata } : {},
+  };
+  _stateLlmV2.profiles.set(id, profile);
+  return _copyProfileV2(profile);
+}
+
+export function getProfileV2(id) {
+  const p = _stateLlmV2.profiles.get(id);
+  return p ? _copyProfileV2(p) : null;
+}
+
+export function listProfilesV2({ ownerId, status, provider } = {}) {
+  const out = [];
+  for (const p of _stateLlmV2.profiles.values()) {
+    if (ownerId && p.ownerId !== ownerId) continue;
+    if (status && p.status !== status) continue;
+    if (provider && p.provider !== provider) continue;
+    out.push(_copyProfileV2(p));
+  }
+  return out;
+}
+
+export function setProfileStatusV2(id, next) {
+  const p = _stateLlmV2.profiles.get(id);
+  if (!p) throw new Error(`profile ${id} not found`);
+  const allowed = _PROVIDER_TRANSITIONS_V2.get(p.status);
+  if (!allowed || !allowed.has(next)) {
+    throw new Error(`invalid profile transition: ${p.status} → ${next}`);
+  }
+  if (
+    p.status === PROVIDER_MATURITY_V2.PENDING &&
+    next === PROVIDER_MATURITY_V2.ACTIVE
+  ) {
+    const count = getActiveProfileCountV2(p.ownerId);
+    if (count >= _stateLlmV2.maxActiveProfilesPerOwner) {
+      throw new Error(
+        `owner ${p.ownerId} active-profile cap reached (${count}/${_stateLlmV2.maxActiveProfilesPerOwner})`,
+      );
+    }
+  }
+  const now = Date.now();
+  p.status = next;
+  p.lastSeenAt = now;
+  if (next === PROVIDER_MATURITY_V2.ACTIVE && !p.activatedAt)
+    p.activatedAt = now;
+  if (_PROVIDER_TERMINALS_V2.has(next) && !p.retiredAt) p.retiredAt = now;
+  return _copyProfileV2(p);
+}
+
+export function activateProfileV2(id) {
+  return setProfileStatusV2(id, PROVIDER_MATURITY_V2.ACTIVE);
+}
+
+export function suspendProfileV2(id) {
+  return setProfileStatusV2(id, PROVIDER_MATURITY_V2.SUSPENDED);
+}
+
+export function retireProfileV2(id) {
+  return setProfileStatusV2(id, PROVIDER_MATURITY_V2.RETIRED);
+}
+
+export function touchProfileV2(id) {
+  const p = _stateLlmV2.profiles.get(id);
+  if (!p) throw new Error(`profile ${id} not found`);
+  p.lastSeenAt = Date.now();
+  return _copyProfileV2(p);
+}
+
+export function createRequestV2(id, { profileId, kind, metadata } = {}) {
+  if (!id) throw new Error("request id is required");
+  if (!profileId) throw new Error("profileId is required");
+  if (_stateLlmV2.requests.has(id))
+    throw new Error(`request ${id} already exists`);
+  const profile = _stateLlmV2.profiles.get(profileId);
+  if (!profile) throw new Error(`profile ${profileId} not found`);
+  const pending = getPendingRequestCountV2(profileId);
+  if (pending >= _stateLlmV2.maxPendingRequestsPerProfile) {
+    throw new Error(
+      `profile ${profileId} pending-request cap reached (${pending}/${_stateLlmV2.maxPendingRequestsPerProfile})`,
+    );
+  }
+  const now = Date.now();
+  const req = {
+    id,
+    profileId,
+    kind: kind || "completion",
+    status: REQUEST_LIFECYCLE_V2.QUEUED,
+    createdAt: now,
+    lastSeenAt: now,
+    startedAt: null,
+    settledAt: null,
+    metadata: metadata ? { ...metadata } : {},
+  };
+  _stateLlmV2.requests.set(id, req);
+  return _copyRequestV2(req);
+}
+
+export function getRequestV2(id) {
+  const r = _stateLlmV2.requests.get(id);
+  return r ? _copyRequestV2(r) : null;
+}
+
+export function listRequestsV2({ profileId, status } = {}) {
+  const out = [];
+  for (const r of _stateLlmV2.requests.values()) {
+    if (profileId && r.profileId !== profileId) continue;
+    if (status && r.status !== status) continue;
+    out.push(_copyRequestV2(r));
+  }
+  return out;
+}
+
+export function setRequestStatusV2(id, next) {
+  const r = _stateLlmV2.requests.get(id);
+  if (!r) throw new Error(`request ${id} not found`);
+  const allowed = _REQUEST_TRANSITIONS_V2.get(r.status);
+  if (!allowed || !allowed.has(next)) {
+    throw new Error(`invalid request transition: ${r.status} → ${next}`);
+  }
+  const now = Date.now();
+  r.status = next;
+  r.lastSeenAt = now;
+  if (next === REQUEST_LIFECYCLE_V2.RUNNING && !r.startedAt) r.startedAt = now;
+  if (_REQUEST_TERMINALS_V2.has(next) && !r.settledAt) r.settledAt = now;
+  return _copyRequestV2(r);
+}
+
+export function startRequestV2(id) {
+  return setRequestStatusV2(id, REQUEST_LIFECYCLE_V2.RUNNING);
+}
+
+export function completeRequestV2(id) {
+  return setRequestStatusV2(id, REQUEST_LIFECYCLE_V2.COMPLETED);
+}
+
+export function failRequestV2(id) {
+  return setRequestStatusV2(id, REQUEST_LIFECYCLE_V2.FAILED);
+}
+
+export function cancelRequestV2(id) {
+  return setRequestStatusV2(id, REQUEST_LIFECYCLE_V2.CANCELLED);
+}
+
+export function autoSuspendIdleProfilesV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const p of _stateLlmV2.profiles.values()) {
+    if (
+      p.status === PROVIDER_MATURITY_V2.ACTIVE &&
+      now - p.lastSeenAt >= _stateLlmV2.profileIdleMs
+    ) {
+      p.status = PROVIDER_MATURITY_V2.SUSPENDED;
+      p.lastSeenAt = now;
+      flipped.push(p.id);
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function autoFailStuckRequestsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const r of _stateLlmV2.requests.values()) {
+    if (
+      r.status === REQUEST_LIFECYCLE_V2.RUNNING &&
+      r.startedAt &&
+      now - r.startedAt >= _stateLlmV2.requestStuckMs
+    ) {
+      r.status = REQUEST_LIFECYCLE_V2.FAILED;
+      r.lastSeenAt = now;
+      if (!r.settledAt) r.settledAt = now;
+      flipped.push(r.id);
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function getLlmProvidersStatsV2() {
+  const profilesByStatus = {};
+  for (const s of Object.values(PROVIDER_MATURITY_V2)) profilesByStatus[s] = 0;
+  for (const p of _stateLlmV2.profiles.values()) profilesByStatus[p.status]++;
+  const requestsByStatus = {};
+  for (const s of Object.values(REQUEST_LIFECYCLE_V2)) requestsByStatus[s] = 0;
+  for (const r of _stateLlmV2.requests.values()) requestsByStatus[r.status]++;
+  return {
+    totalProfilesV2: _stateLlmV2.profiles.size,
+    totalRequestsV2: _stateLlmV2.requests.size,
+    maxActiveProfilesPerOwner: _stateLlmV2.maxActiveProfilesPerOwner,
+    maxPendingRequestsPerProfile: _stateLlmV2.maxPendingRequestsPerProfile,
+    profileIdleMs: _stateLlmV2.profileIdleMs,
+    requestStuckMs: _stateLlmV2.requestStuckMs,
+    profilesByStatus,
+    requestsByStatus,
+  };
+}
+
+export function _resetStateLlmProvidersV2() {
+  _stateLlmV2.profiles.clear();
+  _stateLlmV2.requests.clear();
+  _stateLlmV2.maxActiveProfilesPerOwner = PROVIDER_DEFAULT_MAX_ACTIVE_PER_OWNER;
+  _stateLlmV2.maxPendingRequestsPerProfile =
+    PROVIDER_DEFAULT_MAX_PENDING_REQUESTS_PER_PROFILE;
+  _stateLlmV2.profileIdleMs = PROVIDER_DEFAULT_PROFILE_IDLE_MS;
+  _stateLlmV2.requestStuckMs = PROVIDER_DEFAULT_REQUEST_STUCK_MS;
+}

package/src/lib/matrix-bridge.js

@@ -446,3 +446,108 @@ export function _resetState() {
     e2eeEnabled: true,
   };
 }
+
+
+// ===== V2 Surface: Matrix Bridge governance overlay (CLI v0.134.0) =====
+export const MX_ROOM_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", MUTED: "muted", ARCHIVED: "archived",
+});
+export const MX_MESSAGE_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", SENDING: "sending", DELIVERED: "delivered", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _mxRoomTrans = new Map([
+  [MX_ROOM_MATURITY_V2.PENDING, new Set([MX_ROOM_MATURITY_V2.ACTIVE, MX_ROOM_MATURITY_V2.ARCHIVED])],
+  [MX_ROOM_MATURITY_V2.ACTIVE, new Set([MX_ROOM_MATURITY_V2.MUTED, MX_ROOM_MATURITY_V2.ARCHIVED])],
+  [MX_ROOM_MATURITY_V2.MUTED, new Set([MX_ROOM_MATURITY_V2.ACTIVE, MX_ROOM_MATURITY_V2.ARCHIVED])],
+  [MX_ROOM_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _mxRoomTerminal = new Set([MX_ROOM_MATURITY_V2.ARCHIVED]);
+const _mxMsgTrans = new Map([
+  [MX_MESSAGE_LIFECYCLE_V2.QUEUED, new Set([MX_MESSAGE_LIFECYCLE_V2.SENDING, MX_MESSAGE_LIFECYCLE_V2.CANCELLED])],
+  [MX_MESSAGE_LIFECYCLE_V2.SENDING, new Set([MX_MESSAGE_LIFECYCLE_V2.DELIVERED, MX_MESSAGE_LIFECYCLE_V2.FAILED, MX_MESSAGE_LIFECYCLE_V2.CANCELLED])],
+  [MX_MESSAGE_LIFECYCLE_V2.DELIVERED, new Set()],
+  [MX_MESSAGE_LIFECYCLE_V2.FAILED, new Set()],
+  [MX_MESSAGE_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _mxRooms = new Map();
+const _mxMsgs = new Map();
+let _mxMaxActivePerOwner = 20;
+let _mxMaxPendingPerRoom = 40;
+let _mxRoomIdleMs = 24 * 60 * 60 * 1000;
+let _mxMsgStuckMs = 3 * 60 * 1000;
+
+function _mxPos(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 setMaxActiveMatrixRoomsPerOwnerV2(n) { _mxMaxActivePerOwner = _mxPos(n, "maxActiveMatrixRoomsPerOwner"); }
+export function getMaxActiveMatrixRoomsPerOwnerV2() { return _mxMaxActivePerOwner; }
+export function setMaxPendingMatrixMessagesPerRoomV2(n) { _mxMaxPendingPerRoom = _mxPos(n, "maxPendingMatrixMessagesPerRoom"); }
+export function getMaxPendingMatrixMessagesPerRoomV2() { return _mxMaxPendingPerRoom; }
+export function setMatrixRoomIdleMsV2(n) { _mxRoomIdleMs = _mxPos(n, "matrixRoomIdleMs"); }
+export function getMatrixRoomIdleMsV2() { return _mxRoomIdleMs; }
+export function setMatrixMessageStuckMsV2(n) { _mxMsgStuckMs = _mxPos(n, "matrixMessageStuckMs"); }
+export function getMatrixMessageStuckMsV2() { return _mxMsgStuckMs; }
+
+export function _resetStateMatrixBridgeV2() {
+  _mxRooms.clear(); _mxMsgs.clear();
+  _mxMaxActivePerOwner = 20; _mxMaxPendingPerRoom = 40;
+  _mxRoomIdleMs = 24 * 60 * 60 * 1000; _mxMsgStuckMs = 3 * 60 * 1000;
+}
+
+export function registerMatrixRoomV2({ id, owner, alias, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_mxRooms.has(id)) throw new Error(`matrix room ${id} already registered`);
+  const now = Date.now();
+  const r = { id, owner, alias: alias || id, status: MX_ROOM_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, archivedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _mxRooms.set(id, r);
+  return { ...r, metadata: { ...r.metadata } };
+}
+function _mxCheckR(from, to) { const a = _mxRoomTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid matrix room transition ${from} → ${to}`); }
+function _mxCountActive(owner) { let n = 0; for (const r of _mxRooms.values()) if (r.owner === owner && r.status === MX_ROOM_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateMatrixRoomV2(id) {
+  const r = _mxRooms.get(id); if (!r) throw new Error(`matrix room ${id} not found`);
+  _mxCheckR(r.status, MX_ROOM_MATURITY_V2.ACTIVE);
+  const recovery = r.status === MX_ROOM_MATURITY_V2.MUTED;
+  if (!recovery) { const a = _mxCountActive(r.owner); if (a >= _mxMaxActivePerOwner) throw new Error(`max active matrix rooms per owner (${_mxMaxActivePerOwner}) reached for ${r.owner}`); }
+  const now = Date.now(); r.status = MX_ROOM_MATURITY_V2.ACTIVE; r.updatedAt = now; r.lastTouchedAt = now; if (!r.activatedAt) r.activatedAt = now;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function muteMatrixRoomV2(id) { const r = _mxRooms.get(id); if (!r) throw new Error(`matrix room ${id} not found`); _mxCheckR(r.status, MX_ROOM_MATURITY_V2.MUTED); r.status = MX_ROOM_MATURITY_V2.MUTED; r.updatedAt = Date.now(); return { ...r, metadata: { ...r.metadata } }; }
+export function archiveMatrixRoomV2(id) { const r = _mxRooms.get(id); if (!r) throw new Error(`matrix room ${id} not found`); _mxCheckR(r.status, MX_ROOM_MATURITY_V2.ARCHIVED); const now = Date.now(); r.status = MX_ROOM_MATURITY_V2.ARCHIVED; r.updatedAt = now; if (!r.archivedAt) r.archivedAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function touchMatrixRoomV2(id) { const r = _mxRooms.get(id); if (!r) throw new Error(`matrix room ${id} not found`); if (_mxRoomTerminal.has(r.status)) throw new Error(`cannot touch terminal matrix room ${id}`); const now = Date.now(); r.lastTouchedAt = now; r.updatedAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function getMatrixRoomV2(id) { const r = _mxRooms.get(id); if (!r) return null; return { ...r, metadata: { ...r.metadata } }; }
+export function listMatrixRoomsV2() { return [..._mxRooms.values()].map((r) => ({ ...r, metadata: { ...r.metadata } })); }
+
+function _mxCountPending(rid) { let n = 0; for (const m of _mxMsgs.values()) if (m.roomId === rid && (m.status === MX_MESSAGE_LIFECYCLE_V2.QUEUED || m.status === MX_MESSAGE_LIFECYCLE_V2.SENDING)) n++; return n; }
+
+export function createMatrixMessageV2({ id, roomId, body, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!roomId || typeof roomId !== "string") throw new Error("roomId is required");
+  if (_mxMsgs.has(id)) throw new Error(`matrix message ${id} already exists`);
+  if (!_mxRooms.has(roomId)) throw new Error(`matrix room ${roomId} not found`);
+  const pending = _mxCountPending(roomId);
+  if (pending >= _mxMaxPendingPerRoom) throw new Error(`max pending matrix messages per room (${_mxMaxPendingPerRoom}) reached for ${roomId}`);
+  const now = Date.now();
+  const m = { id, roomId, body: body || "", status: MX_MESSAGE_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _mxMsgs.set(id, m);
+  return { ...m, metadata: { ...m.metadata } };
+}
+function _mxCheckM(from, to) { const a = _mxMsgTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid matrix message transition ${from} → ${to}`); }
+export function startMatrixMessageV2(id) { const m = _mxMsgs.get(id); if (!m) throw new Error(`matrix message ${id} not found`); _mxCheckM(m.status, MX_MESSAGE_LIFECYCLE_V2.SENDING); const now = Date.now(); m.status = MX_MESSAGE_LIFECYCLE_V2.SENDING; m.updatedAt = now; if (!m.startedAt) m.startedAt = now; return { ...m, metadata: { ...m.metadata } }; }
+export function deliverMatrixMessageV2(id) { const m = _mxMsgs.get(id); if (!m) throw new Error(`matrix message ${id} not found`); _mxCheckM(m.status, MX_MESSAGE_LIFECYCLE_V2.DELIVERED); const now = Date.now(); m.status = MX_MESSAGE_LIFECYCLE_V2.DELIVERED; m.updatedAt = now; if (!m.settledAt) m.settledAt = now; return { ...m, metadata: { ...m.metadata } }; }
+export function failMatrixMessageV2(id, reason) { const m = _mxMsgs.get(id); if (!m) throw new Error(`matrix message ${id} not found`); _mxCheckM(m.status, MX_MESSAGE_LIFECYCLE_V2.FAILED); const now = Date.now(); m.status = MX_MESSAGE_LIFECYCLE_V2.FAILED; m.updatedAt = now; if (!m.settledAt) m.settledAt = now; if (reason) m.metadata.failReason = String(reason); return { ...m, metadata: { ...m.metadata } }; }
+export function cancelMatrixMessageV2(id, reason) { const m = _mxMsgs.get(id); if (!m) throw new Error(`matrix message ${id} not found`); _mxCheckM(m.status, MX_MESSAGE_LIFECYCLE_V2.CANCELLED); const now = Date.now(); m.status = MX_MESSAGE_LIFECYCLE_V2.CANCELLED; m.updatedAt = now; if (!m.settledAt) m.settledAt = now; if (reason) m.metadata.cancelReason = String(reason); return { ...m, metadata: { ...m.metadata } }; }
+export function getMatrixMessageV2(id) { const m = _mxMsgs.get(id); if (!m) return null; return { ...m, metadata: { ...m.metadata } }; }
+export function listMatrixMessagesV2() { return [..._mxMsgs.values()].map((m) => ({ ...m, metadata: { ...m.metadata } })); }
+
+export function autoMuteIdleMatrixRoomsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const r of _mxRooms.values()) if (r.status === MX_ROOM_MATURITY_V2.ACTIVE && (t - r.lastTouchedAt) >= _mxRoomIdleMs) { r.status = MX_ROOM_MATURITY_V2.MUTED; r.updatedAt = t; flipped.push(r.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckMatrixMessagesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const m of _mxMsgs.values()) if (m.status === MX_MESSAGE_LIFECYCLE_V2.SENDING && m.startedAt != null && (t - m.startedAt) >= _mxMsgStuckMs) { m.status = MX_MESSAGE_LIFECYCLE_V2.FAILED; m.updatedAt = t; if (!m.settledAt) m.settledAt = t; m.metadata.failReason = "auto-fail-stuck"; flipped.push(m.id); } return { flipped, count: flipped.length }; }
+
+export function getMatrixBridgeStatsV2() {
+  const roomsByStatus = {}; for (const s of Object.values(MX_ROOM_MATURITY_V2)) roomsByStatus[s] = 0; for (const r of _mxRooms.values()) roomsByStatus[r.status]++;
+  const msgsByStatus = {}; for (const s of Object.values(MX_MESSAGE_LIFECYCLE_V2)) msgsByStatus[s] = 0; for (const m of _mxMsgs.values()) msgsByStatus[m.status]++;
+  return { totalRoomsV2: _mxRooms.size, totalMessagesV2: _mxMsgs.size, maxActiveMatrixRoomsPerOwner: _mxMaxActivePerOwner, maxPendingMatrixMessagesPerRoom: _mxMaxPendingPerRoom, matrixRoomIdleMs: _mxRoomIdleMs, matrixMessageStuckMs: _mxMsgStuckMs, roomsByStatus, msgsByStatus };
+}