chainlesschain 0.66.0 → 0.132.0

package/src/lib/sla-manager.js

@@ -481,4 +481,279 @@ export function _resetState() {
   _metrics.clear();
   _violations.clear();
   _seq = 0;
+  _maxActiveSlasPerOrg = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
+}
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 (Phase 61) — Frozen enums + contract/violation state
+ * machines + active-per-org cap + auto-expire + stats-v2.
+ * Strictly additive on top of the legacy surface above.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const SLA_STATUS_V2 = Object.freeze({
+  ACTIVE: "active",
+  EXPIRED: "expired",
+  TERMINATED: "terminated",
+});
+
+export const SLA_TIER_V2 = Object.freeze({
+  GOLD: "gold",
+  SILVER: "silver",
+  BRONZE: "bronze",
+});
+
+export const SLA_TERM_V2 = Object.freeze({
+  AVAILABILITY: "availability",
+  RESPONSE_TIME: "response_time",
+  THROUGHPUT: "throughput",
+  ERROR_RATE: "error_rate",
+});
+
+export const VIOLATION_SEVERITY_V2 = Object.freeze({
+  MINOR: "minor",
+  MODERATE: "moderate",
+  MAJOR: "major",
+  CRITICAL: "critical",
+});
+
+export const VIOLATION_STATUS_V2 = Object.freeze({
+  OPEN: "open",
+  ACKNOWLEDGED: "acknowledged",
+  RESOLVED: "resolved",
+  WAIVED: "waived",
+});
+
+const DEFAULT_MAX_ACTIVE_SLAS_PER_ORG = 1;
+let _maxActiveSlasPerOrg = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
+export const SLA_DEFAULT_MAX_ACTIVE_PER_ORG = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
+
+export function setMaxActiveSlasPerOrg(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 1) {
+    throw new Error("maxActiveSlasPerOrg must be a positive integer");
+  }
+  _maxActiveSlasPerOrg = Math.floor(n);
+  return _maxActiveSlasPerOrg;
+}
+
+export function getMaxActiveSlasPerOrg() {
+  return _maxActiveSlasPerOrg;
+}
+
+// Contract state machine: active → { expired, terminated }; both terminal.
+const _contractTerminal = new Set([
+  SLA_STATUS_V2.EXPIRED,
+  SLA_STATUS_V2.TERMINATED,
+]);
+const _contractAllowed = new Map([
+  [
+    SLA_STATUS_V2.ACTIVE,
+    new Set([SLA_STATUS_V2.EXPIRED, SLA_STATUS_V2.TERMINATED]),
+  ],
+  [SLA_STATUS_V2.EXPIRED, new Set([])],
+  [SLA_STATUS_V2.TERMINATED, new Set([])],
+]);
+
+// Violation state machine: open → { acknowledged, resolved, waived };
+// acknowledged → { resolved, waived }; resolved/waived terminal.
+const _violationTerminal = new Set([
+  VIOLATION_STATUS_V2.RESOLVED,
+  VIOLATION_STATUS_V2.WAIVED,
+]);
+const _violationAllowed = new Map([
+  [
+    VIOLATION_STATUS_V2.OPEN,
+    new Set([
+      VIOLATION_STATUS_V2.ACKNOWLEDGED,
+      VIOLATION_STATUS_V2.RESOLVED,
+      VIOLATION_STATUS_V2.WAIVED,
+    ]),
+  ],
+  [
+    VIOLATION_STATUS_V2.ACKNOWLEDGED,
+    new Set([VIOLATION_STATUS_V2.RESOLVED, VIOLATION_STATUS_V2.WAIVED]),
+  ],
+  [VIOLATION_STATUS_V2.RESOLVED, new Set([])],
+  [VIOLATION_STATUS_V2.WAIVED, new Set([])],
+]);
+
+export function getActiveSlaCountForOrg(orgId) {
+  let count = 0;
+  for (const c of _contracts.values()) {
+    if (c.orgId === orgId && c.status === SLA_STATUS_V2.ACTIVE) count++;
+  }
+  return count;
+}
+
+/**
+ * createSLAV2 — like createSLA but enforces per-org active-contract cap
+ * and rejects unknown tier/status at the boundary. Augments stored
+ * contract with in-memory V2 fields (violationStatus doesn't apply here;
+ * see recordViolation*).
+ */
+export function createSLAV2(db, config = {}) {
+  const orgId = config.orgId;
+  if (!orgId) throw new Error("orgId is required");
+
+  const activeCount = getActiveSlaCountForOrg(orgId);
+  if (activeCount >= _maxActiveSlasPerOrg) {
+    throw new Error(
+      `Max active SLAs per org reached: ${activeCount}/${_maxActiveSlasPerOrg}`,
+    );
+  }
+
+  return createSLA(db, config);
+}
+
+export function setSLAStatus(db, slaId, newStatus) {
+  const contract = _contracts.get(slaId);
+  if (!contract) throw new Error(`SLA not found: ${slaId}`);
+
+  if (!Object.values(SLA_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown SLA status: ${newStatus}`);
+  }
+
+  const allowed = _contractAllowed.get(contract.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid SLA status transition: ${contract.status} → ${newStatus}`,
+    );
+  }
+
+  contract.status = newStatus;
+  contract.updatedAt = Date.now();
+  db.prepare(
+    `UPDATE sla_contracts SET status = ?, updated_at = ? WHERE sla_id = ?`,
+  ).run(contract.status, contract.updatedAt, slaId);
+
+  const { _seq: _omit, ...rest } = contract;
+  void _omit;
+  return rest;
+}
+
+export function expireSLA(db, slaId) {
+  return setSLAStatus(db, slaId, SLA_STATUS_V2.EXPIRED);
+}
+
+/**
+ * autoExpireSLAs — bulk-flip ACTIVE contracts whose endDate < now to
+ * EXPIRED. Returns the list of flipped contracts.
+ */
+export function autoExpireSLAs(db, nowMs = Date.now()) {
+  const flipped = [];
+  for (const contract of _contracts.values()) {
+    if (contract.status === SLA_STATUS_V2.ACTIVE && contract.endDate < nowMs) {
+      contract.status = SLA_STATUS_V2.EXPIRED;
+      contract.updatedAt = nowMs;
+      db.prepare(
+        `UPDATE sla_contracts SET status = ?, updated_at = ? WHERE sla_id = ?`,
+      ).run(contract.status, contract.updatedAt, contract.slaId);
+      const { _seq: _omit, ...rest } = contract;
+      void _omit;
+      flipped.push(rest);
+    }
+  }
+  return flipped;
+}
+
+export function setViolationStatus(db, violationId, newStatus, patch = {}) {
+  const violation = _violations.get(violationId);
+  if (!violation) throw new Error(`Violation not found: ${violationId}`);
+
+  if (!Object.values(VIOLATION_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown violation status: ${newStatus}`);
+  }
+
+  const current = violation.v2Status || VIOLATION_STATUS_V2.OPEN;
+  const allowed = _violationAllowed.get(current);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid violation status transition: ${current} → ${newStatus}`,
+    );
+  }
+
+  violation.v2Status = newStatus;
+  if (typeof patch.note === "string") {
+    violation.note = patch.note;
+  }
+  if (_violationTerminal.has(newStatus)) {
+    violation.resolvedAt = Date.now();
+    db.prepare(
+      `UPDATE sla_violations SET resolved_at = ? WHERE violation_id = ?`,
+    ).run(violation.resolvedAt, violationId);
+  }
+
+  return { ...violation };
+}
+
+export function acknowledgeViolation(db, violationId, note) {
+  return setViolationStatus(db, violationId, VIOLATION_STATUS_V2.ACKNOWLEDGED, {
+    note,
+  });
+}
+
+export function resolveViolation(db, violationId, note) {
+  return setViolationStatus(db, violationId, VIOLATION_STATUS_V2.RESOLVED, {
+    note,
+  });
+}
+
+export function waiveViolation(db, violationId, note) {
+  return setViolationStatus(db, violationId, VIOLATION_STATUS_V2.WAIVED, {
+    note,
+  });
+}
+
+export function getSLAStatsV2() {
+  const contracts = [..._contracts.values()];
+  const violations = [..._violations.values()];
+
+  const byStatus = {};
+  for (const s of Object.values(SLA_STATUS_V2)) byStatus[s] = 0;
+  for (const c of contracts) byStatus[c.status] = (byStatus[c.status] || 0) + 1;
+
+  const byTier = {};
+  for (const t of Object.values(SLA_TIER_V2)) byTier[t] = 0;
+  for (const c of contracts) byTier[c.tier] = (byTier[c.tier] || 0) + 1;
+
+  const bySeverity = {};
+  for (const s of Object.values(VIOLATION_SEVERITY_V2)) bySeverity[s] = 0;
+  for (const v of violations)
+    bySeverity[v.severity] = (bySeverity[v.severity] || 0) + 1;
+
+  const byTerm = {};
+  for (const t of Object.values(SLA_TERM_V2)) byTerm[t] = 0;
+  for (const v of violations) byTerm[v.term] = (byTerm[v.term] || 0) + 1;
+
+  const byViolationStatus = {};
+  for (const s of Object.values(VIOLATION_STATUS_V2)) byViolationStatus[s] = 0;
+  for (const v of violations) {
+    const s = v.v2Status || VIOLATION_STATUS_V2.OPEN;
+    byViolationStatus[s] = (byViolationStatus[s] || 0) + 1;
+  }
+
+  let totalCompensation = 0;
+  for (const v of violations) {
+    if (v.compensationAmount) totalCompensation += v.compensationAmount;
+  }
+
+  const activeOrgs = new Set();
+  for (const c of contracts) {
+    if (c.status === SLA_STATUS_V2.ACTIVE) activeOrgs.add(c.orgId);
+  }
+
+  return {
+    totalContracts: contracts.length,
+    activeContracts: byStatus[SLA_STATUS_V2.ACTIVE] || 0,
+    activeOrgs: activeOrgs.size,
+    maxActiveSlasPerOrg: _maxActiveSlasPerOrg,
+    byStatus,
+    byTier,
+    violations: {
+      total: violations.length,
+      byTerm,
+      bySeverity,
+      byStatus: byViolationStatus,
+      totalCompensation: Number(totalCompensation.toFixed(4)),
+    },
+  };
 }

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