chainlesschain 0.81.0 → 0.132.0

package/src/lib/skill-loader.js

@@ -356,3 +356,380 @@ export class CLISkillLoader {
     this._cache = null;
   }
 }
+
+// ─── V2 Governance Layer ────────────────────────────────────────────
+//
+// In-memory governance for skill registrations + execution tickets,
+// independent of the file-based 4-layer CLISkillLoader (which scans
+// bundled/marketplace/managed/workspace dirs). V2 tracks maturity
+// transitions, per-owner active-skill caps, per-skill pending-execution
+// caps, stamp-once timestamps, and bulk auto-flip routines.
+
+export const SKILL_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  DEPRECATED: "deprecated",
+  ARCHIVED: "archived",
+});
+
+export const EXECUTION_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  SUCCEEDED: "succeeded",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const _SKILL_TRANSITIONS_V2 = new Map([
+  [
+    SKILL_MATURITY_V2.PENDING,
+    new Set([SKILL_MATURITY_V2.ACTIVE, SKILL_MATURITY_V2.ARCHIVED]),
+  ],
+  [
+    SKILL_MATURITY_V2.ACTIVE,
+    new Set([SKILL_MATURITY_V2.DEPRECATED, SKILL_MATURITY_V2.ARCHIVED]),
+  ],
+  [
+    SKILL_MATURITY_V2.DEPRECATED,
+    new Set([SKILL_MATURITY_V2.ACTIVE, SKILL_MATURITY_V2.ARCHIVED]),
+  ],
+  [SKILL_MATURITY_V2.ARCHIVED, new Set()],
+]);
+
+const _SKILL_TERMINALS_V2 = new Set([SKILL_MATURITY_V2.ARCHIVED]);
+
+const _EXEC_TRANSITIONS_V2 = new Map([
+  [
+    EXECUTION_LIFECYCLE_V2.QUEUED,
+    new Set([EXECUTION_LIFECYCLE_V2.RUNNING, EXECUTION_LIFECYCLE_V2.CANCELLED]),
+  ],
+  [
+    EXECUTION_LIFECYCLE_V2.RUNNING,
+    new Set([
+      EXECUTION_LIFECYCLE_V2.SUCCEEDED,
+      EXECUTION_LIFECYCLE_V2.FAILED,
+      EXECUTION_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [EXECUTION_LIFECYCLE_V2.SUCCEEDED, new Set()],
+  [EXECUTION_LIFECYCLE_V2.FAILED, new Set()],
+  [EXECUTION_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _EXEC_TERMINALS_V2 = new Set([
+  EXECUTION_LIFECYCLE_V2.SUCCEEDED,
+  EXECUTION_LIFECYCLE_V2.FAILED,
+  EXECUTION_LIFECYCLE_V2.CANCELLED,
+]);
+
+export const SKILL_DEFAULT_MAX_ACTIVE_PER_OWNER = 30;
+export const SKILL_DEFAULT_MAX_PENDING_EXECUTIONS_PER_SKILL = 5;
+export const SKILL_DEFAULT_SKILL_IDLE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+export const SKILL_DEFAULT_EXEC_STUCK_MS = 15 * 60 * 1000; // 15 min
+
+const _stateV2 = {
+  skills: new Map(),
+  executions: new Map(),
+  maxActiveSkillsPerOwner: SKILL_DEFAULT_MAX_ACTIVE_PER_OWNER,
+  maxPendingExecutionsPerSkill: SKILL_DEFAULT_MAX_PENDING_EXECUTIONS_PER_SKILL,
+  skillIdleMs: SKILL_DEFAULT_SKILL_IDLE_MS,
+  execStuckMs: SKILL_DEFAULT_EXEC_STUCK_MS,
+};
+
+function _posIntSkillV2(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0) {
+    throw new Error(`${label} must be a positive integer, got ${n}`);
+  }
+  return v;
+}
+
+export function getMaxActiveSkillsPerOwnerV2() {
+  return _stateV2.maxActiveSkillsPerOwner;
+}
+
+export function setMaxActiveSkillsPerOwnerV2(n) {
+  _stateV2.maxActiveSkillsPerOwner = _posIntSkillV2(
+    n,
+    "maxActiveSkillsPerOwner",
+  );
+}
+
+export function getMaxPendingExecutionsPerSkillV2() {
+  return _stateV2.maxPendingExecutionsPerSkill;
+}
+
+export function setMaxPendingExecutionsPerSkillV2(n) {
+  _stateV2.maxPendingExecutionsPerSkill = _posIntSkillV2(
+    n,
+    "maxPendingExecutionsPerSkill",
+  );
+}
+
+export function getSkillIdleMsV2() {
+  return _stateV2.skillIdleMs;
+}
+
+export function setSkillIdleMsV2(ms) {
+  _stateV2.skillIdleMs = _posIntSkillV2(ms, "skillIdleMs");
+}
+
+export function getExecStuckMsV2() {
+  return _stateV2.execStuckMs;
+}
+
+export function setExecStuckMsV2(ms) {
+  _stateV2.execStuckMs = _posIntSkillV2(ms, "execStuckMs");
+}
+
+function _copySkillV2(s) {
+  return { ...s, metadata: { ...s.metadata } };
+}
+
+function _copyExecV2(e) {
+  return { ...e, metadata: { ...e.metadata } };
+}
+
+export function getActiveSkillCountV2(ownerId) {
+  let count = 0;
+  for (const s of _stateV2.skills.values()) {
+    if (s.ownerId === ownerId && s.status === SKILL_MATURITY_V2.ACTIVE) count++;
+  }
+  return count;
+}
+
+export function getPendingExecutionCountV2(skillId) {
+  let count = 0;
+  for (const e of _stateV2.executions.values()) {
+    if (
+      e.skillId === skillId &&
+      (e.status === EXECUTION_LIFECYCLE_V2.QUEUED ||
+        e.status === EXECUTION_LIFECYCLE_V2.RUNNING)
+    ) {
+      count++;
+    }
+  }
+  return count;
+}
+
+export function registerSkillV2(id, { ownerId, name, layer, metadata } = {}) {
+  if (!id) throw new Error("skill id is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (!name) throw new Error("name is required");
+  if (_stateV2.skills.has(id)) throw new Error(`skill ${id} already exists`);
+  const now = Date.now();
+  const skill = {
+    id,
+    ownerId,
+    name,
+    layer: layer || "workspace",
+    status: SKILL_MATURITY_V2.PENDING,
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: metadata ? { ...metadata } : {},
+  };
+  _stateV2.skills.set(id, skill);
+  return _copySkillV2(skill);
+}
+
+export function getSkillV2(id) {
+  const s = _stateV2.skills.get(id);
+  return s ? _copySkillV2(s) : null;
+}
+
+export function listSkillsV2({ ownerId, status, layer } = {}) {
+  const out = [];
+  for (const s of _stateV2.skills.values()) {
+    if (ownerId && s.ownerId !== ownerId) continue;
+    if (status && s.status !== status) continue;
+    if (layer && s.layer !== layer) continue;
+    out.push(_copySkillV2(s));
+  }
+  return out;
+}
+
+export function setSkillStatusV2(id, next) {
+  const s = _stateV2.skills.get(id);
+  if (!s) throw new Error(`skill ${id} not found`);
+  const allowed = _SKILL_TRANSITIONS_V2.get(s.status);
+  if (!allowed || !allowed.has(next)) {
+    throw new Error(`invalid skill transition: ${s.status} → ${next}`);
+  }
+  if (
+    s.status === SKILL_MATURITY_V2.PENDING &&
+    next === SKILL_MATURITY_V2.ACTIVE
+  ) {
+    const count = getActiveSkillCountV2(s.ownerId);
+    if (count >= _stateV2.maxActiveSkillsPerOwner) {
+      throw new Error(
+        `owner ${s.ownerId} active-skill cap reached (${count}/${_stateV2.maxActiveSkillsPerOwner})`,
+      );
+    }
+  }
+  const now = Date.now();
+  s.status = next;
+  s.lastSeenAt = now;
+  if (next === SKILL_MATURITY_V2.ACTIVE && !s.activatedAt) s.activatedAt = now;
+  if (_SKILL_TERMINALS_V2.has(next) && !s.archivedAt) s.archivedAt = now;
+  return _copySkillV2(s);
+}
+
+export function activateSkillV2(id) {
+  return setSkillStatusV2(id, SKILL_MATURITY_V2.ACTIVE);
+}
+
+export function deprecateSkillV2(id) {
+  return setSkillStatusV2(id, SKILL_MATURITY_V2.DEPRECATED);
+}
+
+export function archiveSkillV2(id) {
+  return setSkillStatusV2(id, SKILL_MATURITY_V2.ARCHIVED);
+}
+
+export function touchSkillV2(id) {
+  const s = _stateV2.skills.get(id);
+  if (!s) throw new Error(`skill ${id} not found`);
+  s.lastSeenAt = Date.now();
+  return _copySkillV2(s);
+}
+
+export function createExecutionV2(id, { skillId, kind, metadata } = {}) {
+  if (!id) throw new Error("execution id is required");
+  if (!skillId) throw new Error("skillId is required");
+  if (_stateV2.executions.has(id))
+    throw new Error(`execution ${id} already exists`);
+  const skill = _stateV2.skills.get(skillId);
+  if (!skill) throw new Error(`skill ${skillId} not found`);
+  const pending = getPendingExecutionCountV2(skillId);
+  if (pending >= _stateV2.maxPendingExecutionsPerSkill) {
+    throw new Error(
+      `skill ${skillId} pending-execution cap reached (${pending}/${_stateV2.maxPendingExecutionsPerSkill})`,
+    );
+  }
+  const now = Date.now();
+  const exec = {
+    id,
+    skillId,
+    kind: kind || "invoke",
+    status: EXECUTION_LIFECYCLE_V2.QUEUED,
+    createdAt: now,
+    lastSeenAt: now,
+    startedAt: null,
+    settledAt: null,
+    metadata: metadata ? { ...metadata } : {},
+  };
+  _stateV2.executions.set(id, exec);
+  return _copyExecV2(exec);
+}
+
+export function getExecutionV2(id) {
+  const e = _stateV2.executions.get(id);
+  return e ? _copyExecV2(e) : null;
+}
+
+export function listExecutionsV2({ skillId, status } = {}) {
+  const out = [];
+  for (const e of _stateV2.executions.values()) {
+    if (skillId && e.skillId !== skillId) continue;
+    if (status && e.status !== status) continue;
+    out.push(_copyExecV2(e));
+  }
+  return out;
+}
+
+export function setExecutionStatusV2(id, next) {
+  const e = _stateV2.executions.get(id);
+  if (!e) throw new Error(`execution ${id} not found`);
+  const allowed = _EXEC_TRANSITIONS_V2.get(e.status);
+  if (!allowed || !allowed.has(next)) {
+    throw new Error(`invalid execution transition: ${e.status} → ${next}`);
+  }
+  const now = Date.now();
+  e.status = next;
+  e.lastSeenAt = now;
+  if (next === EXECUTION_LIFECYCLE_V2.RUNNING && !e.startedAt)
+    e.startedAt = now;
+  if (_EXEC_TERMINALS_V2.has(next) && !e.settledAt) e.settledAt = now;
+  return _copyExecV2(e);
+}
+
+export function startExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.RUNNING);
+}
+
+export function succeedExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.SUCCEEDED);
+}
+
+export function failExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.FAILED);
+}
+
+export function cancelExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.CANCELLED);
+}
+
+export function autoDeprecateIdleSkillsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const s of _stateV2.skills.values()) {
+    if (
+      s.status === SKILL_MATURITY_V2.ACTIVE &&
+      now - s.lastSeenAt > _stateV2.skillIdleMs
+    ) {
+      s.status = SKILL_MATURITY_V2.DEPRECATED;
+      s.lastSeenAt = now;
+      flipped.push(_copySkillV2(s));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckExecutionsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const e of _stateV2.executions.values()) {
+    if (
+      e.status === EXECUTION_LIFECYCLE_V2.RUNNING &&
+      now - e.lastSeenAt > _stateV2.execStuckMs
+    ) {
+      e.status = EXECUTION_LIFECYCLE_V2.FAILED;
+      e.lastSeenAt = now;
+      if (!e.settledAt) e.settledAt = now;
+      flipped.push(_copyExecV2(e));
+    }
+  }
+  return flipped;
+}
+
+export function getSkillLoaderStatsV2() {
+  const skillsByStatus = {};
+  for (const v of Object.values(SKILL_MATURITY_V2)) skillsByStatus[v] = 0;
+  for (const s of _stateV2.skills.values()) skillsByStatus[s.status]++;
+
+  const executionsByStatus = {};
+  for (const v of Object.values(EXECUTION_LIFECYCLE_V2))
+    executionsByStatus[v] = 0;
+  for (const e of _stateV2.executions.values()) executionsByStatus[e.status]++;
+
+  return {
+    totalSkillsV2: _stateV2.skills.size,
+    totalExecutionsV2: _stateV2.executions.size,
+    maxActiveSkillsPerOwner: _stateV2.maxActiveSkillsPerOwner,
+    maxPendingExecutionsPerSkill: _stateV2.maxPendingExecutionsPerSkill,
+    skillIdleMs: _stateV2.skillIdleMs,
+    execStuckMs: _stateV2.execStuckMs,
+    skillsByStatus,
+    executionsByStatus,
+  };
+}
+
+export function _resetStateSkillLoaderV2() {
+  _stateV2.skills.clear();
+  _stateV2.executions.clear();
+  _stateV2.maxActiveSkillsPerOwner = SKILL_DEFAULT_MAX_ACTIVE_PER_OWNER;
+  _stateV2.maxPendingExecutionsPerSkill =
+    SKILL_DEFAULT_MAX_PENDING_EXECUTIONS_PER_SKILL;
+  _stateV2.skillIdleMs = SKILL_DEFAULT_SKILL_IDLE_MS;
+  _stateV2.execStuckMs = SKILL_DEFAULT_EXEC_STUCK_MS;
+}

package/src/lib/social-manager.js

@@ -281,3 +281,329 @@ export function _resetState() {
   _posts.clear();
   _messages.clear();
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — Social governance layer.
+ * Tracks relationship maturity + thread lifecycle independent of
+ * legacy contacts/friends/posts/messages stores above.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const RELATIONSHIP_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  CONNECTED: "connected",
+  MUTED: "muted",
+  BLOCKED: "blocked",
+});
+
+export const THREAD_LIFECYCLE_V2 = Object.freeze({
+  OPEN: "open",
+  ENGAGED: "engaged",
+  RESOLVED: "resolved",
+  ABANDONED: "abandoned",
+  REPORTED: "reported",
+});
+
+const REL_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["connected", "blocked"])],
+  ["connected", new Set(["muted", "blocked"])],
+  ["muted", new Set(["connected", "blocked"])],
+  ["blocked", new Set()],
+]);
+const REL_TERMINALS_V2 = new Set(["blocked"]);
+
+const THREAD_TRANSITIONS_V2 = new Map([
+  ["open", new Set(["engaged", "abandoned", "reported"])],
+  ["engaged", new Set(["resolved", "abandoned", "reported"])],
+  ["resolved", new Set()],
+  ["abandoned", new Set()],
+  ["reported", new Set()],
+]);
+const THREAD_TERMINALS_V2 = new Set(["resolved", "abandoned", "reported"]);
+
+export const SOCIAL_DEFAULT_MAX_CONNECTED_PER_USER = 500;
+export const SOCIAL_DEFAULT_MAX_OPEN_THREADS_PER_USER = 50;
+export const SOCIAL_DEFAULT_RELATIONSHIP_IDLE_MS = 1000 * 60 * 60 * 24 * 180; // 180 days
+export const SOCIAL_DEFAULT_THREAD_STUCK_MS = 1000 * 60 * 60 * 24 * 7; // 7 days
+
+const _relationshipsV2 = new Map();
+const _threadsV2 = new Map();
+let _maxConnectedPerUserV2 = SOCIAL_DEFAULT_MAX_CONNECTED_PER_USER;
+let _maxOpenThreadsPerUserV2 = SOCIAL_DEFAULT_MAX_OPEN_THREADS_PER_USER;
+let _relationshipIdleMsV2 = SOCIAL_DEFAULT_RELATIONSHIP_IDLE_MS;
+let _threadStuckMsV2 = SOCIAL_DEFAULT_THREAD_STUCK_MS;
+
+function _posIntSocialV2(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 getMaxConnectedPerUserV2() {
+  return _maxConnectedPerUserV2;
+}
+export function setMaxConnectedPerUserV2(n) {
+  _maxConnectedPerUserV2 = _posIntSocialV2(n, "maxConnectedPerUser");
+}
+export function getMaxOpenThreadsPerUserV2() {
+  return _maxOpenThreadsPerUserV2;
+}
+export function setMaxOpenThreadsPerUserV2(n) {
+  _maxOpenThreadsPerUserV2 = _posIntSocialV2(n, "maxOpenThreadsPerUser");
+}
+export function getRelationshipIdleMsV2() {
+  return _relationshipIdleMsV2;
+}
+export function setRelationshipIdleMsV2(n) {
+  _relationshipIdleMsV2 = _posIntSocialV2(n, "relationshipIdleMs");
+}
+export function getThreadStuckMsV2() {
+  return _threadStuckMsV2;
+}
+export function setThreadStuckMsV2(n) {
+  _threadStuckMsV2 = _posIntSocialV2(n, "threadStuckMs");
+}
+
+export function getConnectedCountV2(userId) {
+  let n = 0;
+  for (const r of _relationshipsV2.values()) {
+    if (r.userId === userId && r.status === "connected") n += 1;
+  }
+  return n;
+}
+
+export function getOpenThreadCountV2(userId) {
+  let n = 0;
+  for (const t of _threadsV2.values()) {
+    if (t.userId === userId && (t.status === "open" || t.status === "engaged"))
+      n += 1;
+  }
+  return n;
+}
+
+function _copyRelV2(r) {
+  return { ...r, metadata: { ...r.metadata } };
+}
+function _copyThreadV2(t) {
+  return { ...t, metadata: { ...t.metadata } };
+}
+
+export function registerRelationshipV2(
+  id,
+  { userId, peerId, 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 (!peerId || typeof peerId !== "string")
+    throw new Error("peerId must be a string");
+  if (_relationshipsV2.has(id))
+    throw new Error(`relationship ${id} already exists`);
+  const r = {
+    id,
+    userId,
+    peerId,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    connectedAt: null,
+    blockedAt: null,
+    metadata: { ...metadata },
+  };
+  _relationshipsV2.set(id, r);
+  return _copyRelV2(r);
+}
+
+export function getRelationshipV2(id) {
+  const r = _relationshipsV2.get(id);
+  return r ? _copyRelV2(r) : null;
+}
+
+export function listRelationshipsV2({ userId, status } = {}) {
+  const out = [];
+  for (const r of _relationshipsV2.values()) {
+    if (userId && r.userId !== userId) continue;
+    if (status && r.status !== status) continue;
+    out.push(_copyRelV2(r));
+  }
+  return out;
+}
+
+export function setRelationshipStatusV2(id, next, { now = Date.now() } = {}) {
+  const r = _relationshipsV2.get(id);
+  if (!r) throw new Error(`relationship ${id} not found`);
+  if (!REL_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown relationship status: ${next}`);
+  if (REL_TERMINALS_V2.has(r.status))
+    throw new Error(`relationship ${id} is in terminal state ${r.status}`);
+  const allowed = REL_TRANSITIONS_V2.get(r.status);
+  if (!allowed.has(next))
+    throw new Error(
+      `cannot transition relationship from ${r.status} to ${next}`,
+    );
+  if (next === "connected") {
+    if (r.status === "pending") {
+      const count = getConnectedCountV2(r.userId);
+      if (count >= _maxConnectedPerUserV2)
+        throw new Error(
+          `user ${r.userId} already at connected cap (${_maxConnectedPerUserV2})`,
+        );
+    }
+    if (!r.connectedAt) r.connectedAt = now;
+  }
+  if (next === "blocked" && !r.blockedAt) r.blockedAt = now;
+  r.status = next;
+  r.lastSeenAt = now;
+  return _copyRelV2(r);
+}
+
+export function connectRelationshipV2(id, opts) {
+  return setRelationshipStatusV2(id, "connected", opts);
+}
+export function muteRelationshipV2(id, opts) {
+  return setRelationshipStatusV2(id, "muted", opts);
+}
+export function blockRelationshipV2(id, opts) {
+  return setRelationshipStatusV2(id, "blocked", opts);
+}
+
+export function touchRelationshipV2(id, { now = Date.now() } = {}) {
+  const r = _relationshipsV2.get(id);
+  if (!r) throw new Error(`relationship ${id} not found`);
+  r.lastSeenAt = now;
+  return _copyRelV2(r);
+}
+
+export function createThreadV2(
+  id,
+  { userId, topic, 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 (!topic || typeof topic !== "string")
+    throw new Error("topic must be a string");
+  if (_threadsV2.has(id)) throw new Error(`thread ${id} already exists`);
+  const count = getOpenThreadCountV2(userId);
+  if (count >= _maxOpenThreadsPerUserV2)
+    throw new Error(
+      `user ${userId} already at open-thread cap (${_maxOpenThreadsPerUserV2})`,
+    );
+  const t = {
+    id,
+    userId,
+    topic,
+    status: "open",
+    createdAt: now,
+    lastSeenAt: now,
+    engagedAt: null,
+    settledAt: null,
+    metadata: { ...metadata },
+  };
+  _threadsV2.set(id, t);
+  return _copyThreadV2(t);
+}
+
+export function getThreadV2(id) {
+  const t = _threadsV2.get(id);
+  return t ? _copyThreadV2(t) : null;
+}
+
+export function listThreadsV2({ userId, status } = {}) {
+  const out = [];
+  for (const t of _threadsV2.values()) {
+    if (userId && t.userId !== userId) continue;
+    if (status && t.status !== status) continue;
+    out.push(_copyThreadV2(t));
+  }
+  return out;
+}
+
+export function setThreadStatusV2(id, next, { now = Date.now() } = {}) {
+  const t = _threadsV2.get(id);
+  if (!t) throw new Error(`thread ${id} not found`);
+  if (!THREAD_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown thread status: ${next}`);
+  if (THREAD_TERMINALS_V2.has(t.status))
+    throw new Error(`thread ${id} is in terminal state ${t.status}`);
+  const allowed = THREAD_TRANSITIONS_V2.get(t.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition thread from ${t.status} to ${next}`);
+  if (next === "engaged" && !t.engagedAt) t.engagedAt = now;
+  if (THREAD_TERMINALS_V2.has(next) && !t.settledAt) t.settledAt = now;
+  t.status = next;
+  t.lastSeenAt = now;
+  return _copyThreadV2(t);
+}
+
+export function engageThreadV2(id, opts) {
+  return setThreadStatusV2(id, "engaged", opts);
+}
+export function resolveThreadV2(id, opts) {
+  return setThreadStatusV2(id, "resolved", opts);
+}
+export function abandonThreadV2(id, opts) {
+  return setThreadStatusV2(id, "abandoned", opts);
+}
+export function reportThreadV2(id, opts) {
+  return setThreadStatusV2(id, "reported", opts);
+}
+
+export function autoMuteIdleRelationshipsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const r of _relationshipsV2.values()) {
+    if (r.status !== "connected") continue;
+    if (now - r.lastSeenAt > _relationshipIdleMsV2) {
+      r.status = "muted";
+      r.lastSeenAt = now;
+      flipped.push(_copyRelV2(r));
+    }
+  }
+  return flipped;
+}
+
+export function autoAbandonStuckThreadsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const t of _threadsV2.values()) {
+    if (t.status !== "open" && t.status !== "engaged") continue;
+    if (now - t.lastSeenAt > _threadStuckMsV2) {
+      t.status = "abandoned";
+      t.lastSeenAt = now;
+      if (!t.settledAt) t.settledAt = now;
+      flipped.push(_copyThreadV2(t));
+    }
+  }
+  return flipped;
+}
+
+export function getSocialManagerStatsV2() {
+  const relationshipsByStatus = {};
+  for (const v of Object.values(RELATIONSHIP_MATURITY_V2))
+    relationshipsByStatus[v] = 0;
+  for (const r of _relationshipsV2.values())
+    relationshipsByStatus[r.status] += 1;
+
+  const threadsByStatus = {};
+  for (const v of Object.values(THREAD_LIFECYCLE_V2)) threadsByStatus[v] = 0;
+  for (const t of _threadsV2.values()) threadsByStatus[t.status] += 1;
+
+  return {
+    totalRelationshipsV2: _relationshipsV2.size,
+    totalThreadsV2: _threadsV2.size,
+    maxConnectedPerUser: _maxConnectedPerUserV2,
+    maxOpenThreadsPerUser: _maxOpenThreadsPerUserV2,
+    relationshipIdleMs: _relationshipIdleMsV2,
+    threadStuckMs: _threadStuckMsV2,
+    relationshipsByStatus,
+    threadsByStatus,
+  };
+}
+
+export function _resetStateSocialManagerV2() {
+  _relationshipsV2.clear();
+  _threadsV2.clear();
+  _maxConnectedPerUserV2 = SOCIAL_DEFAULT_MAX_CONNECTED_PER_USER;
+  _maxOpenThreadsPerUserV2 = SOCIAL_DEFAULT_MAX_OPEN_THREADS_PER_USER;
+  _relationshipIdleMsV2 = SOCIAL_DEFAULT_RELATIONSHIP_IDLE_MS;
+  _threadStuckMsV2 = SOCIAL_DEFAULT_THREAD_STUCK_MS;
+}