chainlesschain 0.81.0 → 0.143.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/mcp-scaffold.js

@@ -383,3 +383,84 @@ function renderGitignore() {
 !.env.example
 `;
 }
+
+// ===== V2 Surface: MCP Scaffold governance overlay (CLI v0.142.0) =====
+export const MSCAF_PROFILE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", STALE: "stale", ARCHIVED: "archived",
+});
+export const MSCAF_GENERATION_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", GENERATING: "generating", GENERATED: "generated", FAILED: "failed", CANCELLED: "cancelled",
+});
+const _mscafPTrans = new Map([
+  [MSCAF_PROFILE_MATURITY_V2.PENDING, new Set([MSCAF_PROFILE_MATURITY_V2.ACTIVE, MSCAF_PROFILE_MATURITY_V2.ARCHIVED])],
+  [MSCAF_PROFILE_MATURITY_V2.ACTIVE, new Set([MSCAF_PROFILE_MATURITY_V2.STALE, MSCAF_PROFILE_MATURITY_V2.ARCHIVED])],
+  [MSCAF_PROFILE_MATURITY_V2.STALE, new Set([MSCAF_PROFILE_MATURITY_V2.ACTIVE, MSCAF_PROFILE_MATURITY_V2.ARCHIVED])],
+  [MSCAF_PROFILE_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _mscafPTerminal = new Set([MSCAF_PROFILE_MATURITY_V2.ARCHIVED]);
+const _mscafGTrans = new Map([
+  [MSCAF_GENERATION_LIFECYCLE_V2.QUEUED, new Set([MSCAF_GENERATION_LIFECYCLE_V2.GENERATING, MSCAF_GENERATION_LIFECYCLE_V2.CANCELLED])],
+  [MSCAF_GENERATION_LIFECYCLE_V2.GENERATING, new Set([MSCAF_GENERATION_LIFECYCLE_V2.GENERATED, MSCAF_GENERATION_LIFECYCLE_V2.FAILED, MSCAF_GENERATION_LIFECYCLE_V2.CANCELLED])],
+  [MSCAF_GENERATION_LIFECYCLE_V2.GENERATED, new Set()],
+  [MSCAF_GENERATION_LIFECYCLE_V2.FAILED, new Set()],
+  [MSCAF_GENERATION_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _mscafPsV2 = new Map();
+const _mscafGsV2 = new Map();
+let _mscafMaxActive = 6, _mscafMaxPending = 15, _mscafIdleMs = 30 * 24 * 60 * 60 * 1000, _mscafStuckMs = 60 * 1000;
+function _mscafPos(n, label) { const v = Math.floor(Number(n)); if (!Number.isFinite(v) || v <= 0) throw new Error(`${label} must be positive integer`); return v; }
+function _mscafCheckP(from, to) { const a = _mscafPTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid mscaf profile transition ${from} → ${to}`); }
+function _mscafCheckG(from, to) { const a = _mscafGTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid mscaf generation transition ${from} → ${to}`); }
+export function setMaxActiveMscafProfilesPerOwnerV2(n) { _mscafMaxActive = _mscafPos(n, "maxActiveMscafProfilesPerOwner"); }
+export function getMaxActiveMscafProfilesPerOwnerV2() { return _mscafMaxActive; }
+export function setMaxPendingMscafGenerationsPerProfileV2(n) { _mscafMaxPending = _mscafPos(n, "maxPendingMscafGenerationsPerProfile"); }
+export function getMaxPendingMscafGenerationsPerProfileV2() { return _mscafMaxPending; }
+export function setMscafProfileIdleMsV2(n) { _mscafIdleMs = _mscafPos(n, "mscafProfileIdleMs"); }
+export function getMscafProfileIdleMsV2() { return _mscafIdleMs; }
+export function setMscafGenerationStuckMsV2(n) { _mscafStuckMs = _mscafPos(n, "mscafGenerationStuckMs"); }
+export function getMscafGenerationStuckMsV2() { return _mscafStuckMs; }
+export function _resetStateMcpScaffoldV2() { _mscafPsV2.clear(); _mscafGsV2.clear(); _mscafMaxActive = 6; _mscafMaxPending = 15; _mscafIdleMs = 30 * 24 * 60 * 60 * 1000; _mscafStuckMs = 60 * 1000; }
+export function registerMscafProfileV2({ id, owner, transport, metadata } = {}) {
+  if (!id) throw new Error("mscaf profile id required"); if (!owner) throw new Error("mscaf profile owner required");
+  if (_mscafPsV2.has(id)) throw new Error(`mscaf profile ${id} already registered`);
+  const now = Date.now();
+  const p = { id, owner, transport: transport || "stdio", status: MSCAF_PROFILE_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, archivedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _mscafPsV2.set(id, p); return { ...p, metadata: { ...p.metadata } };
+}
+function _mscafCountActive(owner) { let n = 0; for (const p of _mscafPsV2.values()) if (p.owner === owner && p.status === MSCAF_PROFILE_MATURITY_V2.ACTIVE) n++; return n; }
+export function activateMscafProfileV2(id) {
+  const p = _mscafPsV2.get(id); if (!p) throw new Error(`mscaf profile ${id} not found`);
+  _mscafCheckP(p.status, MSCAF_PROFILE_MATURITY_V2.ACTIVE);
+  const recovery = p.status === MSCAF_PROFILE_MATURITY_V2.STALE;
+  if (!recovery && _mscafCountActive(p.owner) >= _mscafMaxActive) throw new Error(`max active mscaf profiles for owner ${p.owner} reached`);
+  const now = Date.now(); p.status = MSCAF_PROFILE_MATURITY_V2.ACTIVE; p.updatedAt = now; p.lastTouchedAt = now; if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function staleMscafProfileV2(id) { const p = _mscafPsV2.get(id); if (!p) throw new Error(`mscaf profile ${id} not found`); _mscafCheckP(p.status, MSCAF_PROFILE_MATURITY_V2.STALE); p.status = MSCAF_PROFILE_MATURITY_V2.STALE; p.updatedAt = Date.now(); return { ...p, metadata: { ...p.metadata } }; }
+export function archiveMscafProfileV2(id) { const p = _mscafPsV2.get(id); if (!p) throw new Error(`mscaf profile ${id} not found`); _mscafCheckP(p.status, MSCAF_PROFILE_MATURITY_V2.ARCHIVED); const now = Date.now(); p.status = MSCAF_PROFILE_MATURITY_V2.ARCHIVED; p.updatedAt = now; if (!p.archivedAt) p.archivedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function touchMscafProfileV2(id) { const p = _mscafPsV2.get(id); if (!p) throw new Error(`mscaf profile ${id} not found`); if (_mscafPTerminal.has(p.status)) throw new Error(`cannot touch terminal mscaf profile ${id}`); const now = Date.now(); p.lastTouchedAt = now; p.updatedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function getMscafProfileV2(id) { const p = _mscafPsV2.get(id); if (!p) return null; return { ...p, metadata: { ...p.metadata } }; }
+export function listMscafProfilesV2() { return [..._mscafPsV2.values()].map((p) => ({ ...p, metadata: { ...p.metadata } })); }
+function _mscafCountPending(profileId) { let n = 0; for (const g of _mscafGsV2.values()) if (g.profileId === profileId && (g.status === MSCAF_GENERATION_LIFECYCLE_V2.QUEUED || g.status === MSCAF_GENERATION_LIFECYCLE_V2.GENERATING)) n++; return n; }
+export function createMscafGenerationV2({ id, profileId, target, metadata } = {}) {
+  if (!id) throw new Error("mscaf generation id required"); if (!profileId) throw new Error("mscaf generation profileId required");
+  if (_mscafGsV2.has(id)) throw new Error(`mscaf generation ${id} already exists`);
+  if (!_mscafPsV2.has(profileId)) throw new Error(`mscaf profile ${profileId} not found`);
+  if (_mscafCountPending(profileId) >= _mscafMaxPending) throw new Error(`max pending mscaf generations for profile ${profileId} reached`);
+  const now = Date.now();
+  const g = { id, profileId, target: target || "", status: MSCAF_GENERATION_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _mscafGsV2.set(id, g); return { ...g, metadata: { ...g.metadata } };
+}
+export function generatingMscafGenerationV2(id) { const g = _mscafGsV2.get(id); if (!g) throw new Error(`mscaf generation ${id} not found`); _mscafCheckG(g.status, MSCAF_GENERATION_LIFECYCLE_V2.GENERATING); const now = Date.now(); g.status = MSCAF_GENERATION_LIFECYCLE_V2.GENERATING; g.updatedAt = now; if (!g.startedAt) g.startedAt = now; return { ...g, metadata: { ...g.metadata } }; }
+export function generateMscafGenerationV2(id) { const g = _mscafGsV2.get(id); if (!g) throw new Error(`mscaf generation ${id} not found`); _mscafCheckG(g.status, MSCAF_GENERATION_LIFECYCLE_V2.GENERATED); const now = Date.now(); g.status = MSCAF_GENERATION_LIFECYCLE_V2.GENERATED; g.updatedAt = now; if (!g.settledAt) g.settledAt = now; return { ...g, metadata: { ...g.metadata } }; }
+export function failMscafGenerationV2(id, reason) { const g = _mscafGsV2.get(id); if (!g) throw new Error(`mscaf generation ${id} not found`); _mscafCheckG(g.status, MSCAF_GENERATION_LIFECYCLE_V2.FAILED); const now = Date.now(); g.status = MSCAF_GENERATION_LIFECYCLE_V2.FAILED; g.updatedAt = now; if (!g.settledAt) g.settledAt = now; if (reason) g.metadata.failReason = String(reason); return { ...g, metadata: { ...g.metadata } }; }
+export function cancelMscafGenerationV2(id, reason) { const g = _mscafGsV2.get(id); if (!g) throw new Error(`mscaf generation ${id} not found`); _mscafCheckG(g.status, MSCAF_GENERATION_LIFECYCLE_V2.CANCELLED); const now = Date.now(); g.status = MSCAF_GENERATION_LIFECYCLE_V2.CANCELLED; g.updatedAt = now; if (!g.settledAt) g.settledAt = now; if (reason) g.metadata.cancelReason = String(reason); return { ...g, metadata: { ...g.metadata } }; }
+export function getMscafGenerationV2(id) { const g = _mscafGsV2.get(id); if (!g) return null; return { ...g, metadata: { ...g.metadata } }; }
+export function listMscafGenerationsV2() { return [..._mscafGsV2.values()].map((g) => ({ ...g, metadata: { ...g.metadata } })); }
+export function autoStaleIdleMscafProfilesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const p of _mscafPsV2.values()) if (p.status === MSCAF_PROFILE_MATURITY_V2.ACTIVE && (t - p.lastTouchedAt) >= _mscafIdleMs) { p.status = MSCAF_PROFILE_MATURITY_V2.STALE; p.updatedAt = t; flipped.push(p.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckMscafGenerationsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const g of _mscafGsV2.values()) if (g.status === MSCAF_GENERATION_LIFECYCLE_V2.GENERATING && g.startedAt != null && (t - g.startedAt) >= _mscafStuckMs) { g.status = MSCAF_GENERATION_LIFECYCLE_V2.FAILED; g.updatedAt = t; if (!g.settledAt) g.settledAt = t; g.metadata.failReason = "auto-fail-stuck"; flipped.push(g.id); } return { flipped, count: flipped.length }; }
+export function getMcpScaffoldGovStatsV2() {
+  const profilesByStatus = {}; for (const v of Object.values(MSCAF_PROFILE_MATURITY_V2)) profilesByStatus[v] = 0; for (const p of _mscafPsV2.values()) profilesByStatus[p.status]++;
+  const generationsByStatus = {}; for (const v of Object.values(MSCAF_GENERATION_LIFECYCLE_V2)) generationsByStatus[v] = 0; for (const g of _mscafGsV2.values()) generationsByStatus[g.status]++;
+  return { totalMscafProfilesV2: _mscafPsV2.size, totalMscafGenerationsV2: _mscafGsV2.size, maxActiveMscafProfilesPerOwner: _mscafMaxActive, maxPendingMscafGenerationsPerProfile: _mscafMaxPending, mscafProfileIdleMs: _mscafIdleMs, mscafGenerationStuckMs: _mscafStuckMs, profilesByStatus, generationsByStatus };
+}

package/src/lib/memory-injection.js

@@ -88,3 +88,84 @@ export function buildMemoryInjection(options = {}) {
   });
   return content ? { role: "system", content, count: memories.length } : null;
 }
+
+// ===== V2 Surface: Memory Injection governance overlay (CLI v0.142.0) =====
+export const MINJ_RULE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", ARCHIVED: "archived",
+});
+export const MINJ_INJECTION_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", INJECTING: "injecting", APPLIED: "applied", FAILED: "failed", CANCELLED: "cancelled",
+});
+const _minjRTrans = new Map([
+  [MINJ_RULE_MATURITY_V2.PENDING, new Set([MINJ_RULE_MATURITY_V2.ACTIVE, MINJ_RULE_MATURITY_V2.ARCHIVED])],
+  [MINJ_RULE_MATURITY_V2.ACTIVE, new Set([MINJ_RULE_MATURITY_V2.PAUSED, MINJ_RULE_MATURITY_V2.ARCHIVED])],
+  [MINJ_RULE_MATURITY_V2.PAUSED, new Set([MINJ_RULE_MATURITY_V2.ACTIVE, MINJ_RULE_MATURITY_V2.ARCHIVED])],
+  [MINJ_RULE_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _minjRTerminal = new Set([MINJ_RULE_MATURITY_V2.ARCHIVED]);
+const _minjITrans = new Map([
+  [MINJ_INJECTION_LIFECYCLE_V2.QUEUED, new Set([MINJ_INJECTION_LIFECYCLE_V2.INJECTING, MINJ_INJECTION_LIFECYCLE_V2.CANCELLED])],
+  [MINJ_INJECTION_LIFECYCLE_V2.INJECTING, new Set([MINJ_INJECTION_LIFECYCLE_V2.APPLIED, MINJ_INJECTION_LIFECYCLE_V2.FAILED, MINJ_INJECTION_LIFECYCLE_V2.CANCELLED])],
+  [MINJ_INJECTION_LIFECYCLE_V2.APPLIED, new Set()],
+  [MINJ_INJECTION_LIFECYCLE_V2.FAILED, new Set()],
+  [MINJ_INJECTION_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _minjRsV2 = new Map();
+const _minjIsV2 = new Map();
+let _minjMaxActive = 10, _minjMaxPending = 25, _minjIdleMs = 30 * 24 * 60 * 60 * 1000, _minjStuckMs = 30 * 1000;
+function _minjPos(n, label) { const v = Math.floor(Number(n)); if (!Number.isFinite(v) || v <= 0) throw new Error(`${label} must be positive integer`); return v; }
+function _minjCheckR(from, to) { const a = _minjRTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid minj rule transition ${from} → ${to}`); }
+function _minjCheckI(from, to) { const a = _minjITrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid minj injection transition ${from} → ${to}`); }
+export function setMaxActiveMinjRulesPerOwnerV2(n) { _minjMaxActive = _minjPos(n, "maxActiveMinjRulesPerOwner"); }
+export function getMaxActiveMinjRulesPerOwnerV2() { return _minjMaxActive; }
+export function setMaxPendingMinjInjectionsPerRuleV2(n) { _minjMaxPending = _minjPos(n, "maxPendingMinjInjectionsPerRule"); }
+export function getMaxPendingMinjInjectionsPerRuleV2() { return _minjMaxPending; }
+export function setMinjRuleIdleMsV2(n) { _minjIdleMs = _minjPos(n, "minjRuleIdleMs"); }
+export function getMinjRuleIdleMsV2() { return _minjIdleMs; }
+export function setMinjInjectionStuckMsV2(n) { _minjStuckMs = _minjPos(n, "minjInjectionStuckMs"); }
+export function getMinjInjectionStuckMsV2() { return _minjStuckMs; }
+export function _resetStateMemoryInjectionV2() { _minjRsV2.clear(); _minjIsV2.clear(); _minjMaxActive = 10; _minjMaxPending = 25; _minjIdleMs = 30 * 24 * 60 * 60 * 1000; _minjStuckMs = 30 * 1000; }
+export function registerMinjRuleV2({ id, owner, scope, metadata } = {}) {
+  if (!id) throw new Error("minj rule id required"); if (!owner) throw new Error("minj rule owner required");
+  if (_minjRsV2.has(id)) throw new Error(`minj rule ${id} already registered`);
+  const now = Date.now();
+  const r = { id, owner, scope: scope || "*", status: MINJ_RULE_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, archivedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _minjRsV2.set(id, r); return { ...r, metadata: { ...r.metadata } };
+}
+function _minjCountActive(owner) { let n = 0; for (const r of _minjRsV2.values()) if (r.owner === owner && r.status === MINJ_RULE_MATURITY_V2.ACTIVE) n++; return n; }
+export function activateMinjRuleV2(id) {
+  const r = _minjRsV2.get(id); if (!r) throw new Error(`minj rule ${id} not found`);
+  _minjCheckR(r.status, MINJ_RULE_MATURITY_V2.ACTIVE);
+  const recovery = r.status === MINJ_RULE_MATURITY_V2.PAUSED;
+  if (!recovery && _minjCountActive(r.owner) >= _minjMaxActive) throw new Error(`max active minj rules for owner ${r.owner} reached`);
+  const now = Date.now(); r.status = MINJ_RULE_MATURITY_V2.ACTIVE; r.updatedAt = now; r.lastTouchedAt = now; if (!r.activatedAt) r.activatedAt = now;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function pauseMinjRuleV2(id) { const r = _minjRsV2.get(id); if (!r) throw new Error(`minj rule ${id} not found`); _minjCheckR(r.status, MINJ_RULE_MATURITY_V2.PAUSED); r.status = MINJ_RULE_MATURITY_V2.PAUSED; r.updatedAt = Date.now(); return { ...r, metadata: { ...r.metadata } }; }
+export function archiveMinjRuleV2(id) { const r = _minjRsV2.get(id); if (!r) throw new Error(`minj rule ${id} not found`); _minjCheckR(r.status, MINJ_RULE_MATURITY_V2.ARCHIVED); const now = Date.now(); r.status = MINJ_RULE_MATURITY_V2.ARCHIVED; r.updatedAt = now; if (!r.archivedAt) r.archivedAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function touchMinjRuleV2(id) { const r = _minjRsV2.get(id); if (!r) throw new Error(`minj rule ${id} not found`); if (_minjRTerminal.has(r.status)) throw new Error(`cannot touch terminal minj rule ${id}`); const now = Date.now(); r.lastTouchedAt = now; r.updatedAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function getMinjRuleV2(id) { const r = _minjRsV2.get(id); if (!r) return null; return { ...r, metadata: { ...r.metadata } }; }
+export function listMinjRulesV2() { return [..._minjRsV2.values()].map((r) => ({ ...r, metadata: { ...r.metadata } })); }
+function _minjCountPending(ruleId) { let n = 0; for (const i of _minjIsV2.values()) if (i.ruleId === ruleId && (i.status === MINJ_INJECTION_LIFECYCLE_V2.QUEUED || i.status === MINJ_INJECTION_LIFECYCLE_V2.INJECTING)) n++; return n; }
+export function createMinjInjectionV2({ id, ruleId, payload, metadata } = {}) {
+  if (!id) throw new Error("minj injection id required"); if (!ruleId) throw new Error("minj injection ruleId required");
+  if (_minjIsV2.has(id)) throw new Error(`minj injection ${id} already exists`);
+  if (!_minjRsV2.has(ruleId)) throw new Error(`minj rule ${ruleId} not found`);
+  if (_minjCountPending(ruleId) >= _minjMaxPending) throw new Error(`max pending minj injections for rule ${ruleId} reached`);
+  const now = Date.now();
+  const i = { id, ruleId, payload: payload || "", status: MINJ_INJECTION_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _minjIsV2.set(id, i); return { ...i, metadata: { ...i.metadata } };
+}
+export function injectingMinjInjectionV2(id) { const i = _minjIsV2.get(id); if (!i) throw new Error(`minj injection ${id} not found`); _minjCheckI(i.status, MINJ_INJECTION_LIFECYCLE_V2.INJECTING); const now = Date.now(); i.status = MINJ_INJECTION_LIFECYCLE_V2.INJECTING; i.updatedAt = now; if (!i.startedAt) i.startedAt = now; return { ...i, metadata: { ...i.metadata } }; }
+export function applyMinjInjectionV2(id) { const i = _minjIsV2.get(id); if (!i) throw new Error(`minj injection ${id} not found`); _minjCheckI(i.status, MINJ_INJECTION_LIFECYCLE_V2.APPLIED); const now = Date.now(); i.status = MINJ_INJECTION_LIFECYCLE_V2.APPLIED; i.updatedAt = now; if (!i.settledAt) i.settledAt = now; return { ...i, metadata: { ...i.metadata } }; }
+export function failMinjInjectionV2(id, reason) { const i = _minjIsV2.get(id); if (!i) throw new Error(`minj injection ${id} not found`); _minjCheckI(i.status, MINJ_INJECTION_LIFECYCLE_V2.FAILED); const now = Date.now(); i.status = MINJ_INJECTION_LIFECYCLE_V2.FAILED; i.updatedAt = now; if (!i.settledAt) i.settledAt = now; if (reason) i.metadata.failReason = String(reason); return { ...i, metadata: { ...i.metadata } }; }
+export function cancelMinjInjectionV2(id, reason) { const i = _minjIsV2.get(id); if (!i) throw new Error(`minj injection ${id} not found`); _minjCheckI(i.status, MINJ_INJECTION_LIFECYCLE_V2.CANCELLED); const now = Date.now(); i.status = MINJ_INJECTION_LIFECYCLE_V2.CANCELLED; i.updatedAt = now; if (!i.settledAt) i.settledAt = now; if (reason) i.metadata.cancelReason = String(reason); return { ...i, metadata: { ...i.metadata } }; }
+export function getMinjInjectionV2(id) { const i = _minjIsV2.get(id); if (!i) return null; return { ...i, metadata: { ...i.metadata } }; }
+export function listMinjInjectionsV2() { return [..._minjIsV2.values()].map((i) => ({ ...i, metadata: { ...i.metadata } })); }
+export function autoPauseIdleMinjRulesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const r of _minjRsV2.values()) if (r.status === MINJ_RULE_MATURITY_V2.ACTIVE && (t - r.lastTouchedAt) >= _minjIdleMs) { r.status = MINJ_RULE_MATURITY_V2.PAUSED; r.updatedAt = t; flipped.push(r.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckMinjInjectionsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const i of _minjIsV2.values()) if (i.status === MINJ_INJECTION_LIFECYCLE_V2.INJECTING && i.startedAt != null && (t - i.startedAt) >= _minjStuckMs) { i.status = MINJ_INJECTION_LIFECYCLE_V2.FAILED; i.updatedAt = t; if (!i.settledAt) i.settledAt = t; i.metadata.failReason = "auto-fail-stuck"; flipped.push(i.id); } return { flipped, count: flipped.length }; }
+export function getMemoryInjectionGovStatsV2() {
+  const rulesByStatus = {}; for (const v of Object.values(MINJ_RULE_MATURITY_V2)) rulesByStatus[v] = 0; for (const r of _minjRsV2.values()) rulesByStatus[r.status]++;
+  const injectionsByStatus = {}; for (const v of Object.values(MINJ_INJECTION_LIFECYCLE_V2)) injectionsByStatus[v] = 0; for (const i of _minjIsV2.values()) injectionsByStatus[i.status]++;
+  return { totalMinjRulesV2: _minjRsV2.size, totalMinjInjectionsV2: _minjIsV2.size, maxActiveMinjRulesPerOwner: _minjMaxActive, maxPendingMinjInjectionsPerRule: _minjMaxPending, minjRuleIdleMs: _minjIdleMs, minjInjectionStuckMs: _minjStuckMs, rulesByStatus, injectionsByStatus };
+}