chainlesschain 0.81.0 → 0.143.0

package/src/lib/permanent-memory.js

@@ -368,3 +368,323 @@ export class CLIPermanentMemory {
     }
   }
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — Permanent memory governance layer.
+ * Tracks per-owner pin maturity + per-pin retention-job lifecycle
+ * independent of file/SQLite/BM25 layers.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const PIN_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  DORMANT: "dormant",
+  ARCHIVED: "archived",
+});
+
+export const RETENTION_JOB_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const PIN_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["active", "archived"])],
+  ["active", new Set(["dormant", "archived"])],
+  ["dormant", new Set(["active", "archived"])],
+  ["archived", new Set()],
+]);
+const PIN_TERMINALS_V2 = new Set(["archived"]);
+
+const JOB_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["running", "cancelled"])],
+  ["running", new Set(["completed", "failed", "cancelled"])],
+  ["completed", new Set()],
+  ["failed", new Set()],
+  ["cancelled", new Set()],
+]);
+const JOB_TERMINALS_V2 = new Set(["completed", "failed", "cancelled"]);
+
+export const PERMMEM_DEFAULT_MAX_ACTIVE_PINS_PER_OWNER = 500;
+export const PERMMEM_DEFAULT_MAX_PENDING_JOBS_PER_PIN = 2;
+export const PERMMEM_DEFAULT_PIN_IDLE_MS = 1000 * 60 * 60 * 24 * 90; // 90 days
+export const PERMMEM_DEFAULT_JOB_STUCK_MS = 1000 * 60 * 15; // 15 min
+
+const _pinsV2 = new Map();
+const _jobsV2 = new Map();
+let _maxActivePinsPerOwnerV2 = PERMMEM_DEFAULT_MAX_ACTIVE_PINS_PER_OWNER;
+let _maxPendingJobsPerPinV2 = PERMMEM_DEFAULT_MAX_PENDING_JOBS_PER_PIN;
+let _pinIdleMsV2 = PERMMEM_DEFAULT_PIN_IDLE_MS;
+let _jobStuckMsV2 = PERMMEM_DEFAULT_JOB_STUCK_MS;
+
+function _posIntPermMemV2(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 getMaxActivePinsPerOwnerV2() {
+  return _maxActivePinsPerOwnerV2;
+}
+export function setMaxActivePinsPerOwnerV2(n) {
+  _maxActivePinsPerOwnerV2 = _posIntPermMemV2(n, "maxActivePinsPerOwner");
+}
+export function getMaxPendingJobsPerPinV2() {
+  return _maxPendingJobsPerPinV2;
+}
+export function setMaxPendingJobsPerPinV2(n) {
+  _maxPendingJobsPerPinV2 = _posIntPermMemV2(n, "maxPendingJobsPerPin");
+}
+export function getPinIdleMsV2() {
+  return _pinIdleMsV2;
+}
+export function setPinIdleMsV2(n) {
+  _pinIdleMsV2 = _posIntPermMemV2(n, "pinIdleMs");
+}
+export function getJobStuckMsV2() {
+  return _jobStuckMsV2;
+}
+export function setJobStuckMsV2(n) {
+  _jobStuckMsV2 = _posIntPermMemV2(n, "jobStuckMs");
+}
+
+export function getActivePinCountV2(ownerId) {
+  let n = 0;
+  for (const p of _pinsV2.values()) {
+    if (p.ownerId === ownerId && p.status === "active") n += 1;
+  }
+  return n;
+}
+
+export function getPendingJobCountV2(pinId) {
+  let n = 0;
+  for (const j of _jobsV2.values()) {
+    if (j.pinId === pinId && (j.status === "queued" || j.status === "running"))
+      n += 1;
+  }
+  return n;
+}
+
+function _copyPinV2(p) {
+  return { ...p, metadata: { ...p.metadata } };
+}
+function _copyJobV2(j) {
+  return { ...j, metadata: { ...j.metadata } };
+}
+
+export function registerPinV2(
+  id,
+  { ownerId, label, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!ownerId || typeof ownerId !== "string")
+    throw new Error("ownerId must be a string");
+  if (!label || typeof label !== "string")
+    throw new Error("label must be a string");
+  if (_pinsV2.has(id)) throw new Error(`pin ${id} already exists`);
+  const p = {
+    id,
+    ownerId,
+    label,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: { ...metadata },
+  };
+  _pinsV2.set(id, p);
+  return _copyPinV2(p);
+}
+
+export function getPinV2(id) {
+  const p = _pinsV2.get(id);
+  return p ? _copyPinV2(p) : null;
+}
+
+export function listPinsV2({ ownerId, status } = {}) {
+  const out = [];
+  for (const p of _pinsV2.values()) {
+    if (ownerId && p.ownerId !== ownerId) continue;
+    if (status && p.status !== status) continue;
+    out.push(_copyPinV2(p));
+  }
+  return out;
+}
+
+export function setPinStatusV2(id, next, { now = Date.now() } = {}) {
+  const p = _pinsV2.get(id);
+  if (!p) throw new Error(`pin ${id} not found`);
+  if (!PIN_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown pin status: ${next}`);
+  if (PIN_TERMINALS_V2.has(p.status))
+    throw new Error(`pin ${id} is in terminal state ${p.status}`);
+  const allowed = PIN_TRANSITIONS_V2.get(p.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition pin from ${p.status} to ${next}`);
+  if (next === "active") {
+    if (p.status === "pending") {
+      const count = getActivePinCountV2(p.ownerId);
+      if (count >= _maxActivePinsPerOwnerV2)
+        throw new Error(
+          `owner ${p.ownerId} already at active-pin cap (${_maxActivePinsPerOwnerV2})`,
+        );
+    }
+    if (!p.activatedAt) p.activatedAt = now;
+  }
+  if (next === "archived" && !p.archivedAt) p.archivedAt = now;
+  p.status = next;
+  p.lastSeenAt = now;
+  return _copyPinV2(p);
+}
+
+export function activatePinV2(id, opts) {
+  return setPinStatusV2(id, "active", opts);
+}
+export function dormantPinV2(id, opts) {
+  return setPinStatusV2(id, "dormant", opts);
+}
+export function archivePinV2(id, opts) {
+  return setPinStatusV2(id, "archived", opts);
+}
+
+export function touchPinV2(id, { now = Date.now() } = {}) {
+  const p = _pinsV2.get(id);
+  if (!p) throw new Error(`pin ${id} not found`);
+  p.lastSeenAt = now;
+  return _copyPinV2(p);
+}
+
+export function createRetentionJobV2(
+  id,
+  { pinId, kind = "review", metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!pinId || typeof pinId !== "string")
+    throw new Error("pinId must be a string");
+  if (_jobsV2.has(id)) throw new Error(`job ${id} already exists`);
+  const count = getPendingJobCountV2(pinId);
+  if (count >= _maxPendingJobsPerPinV2)
+    throw new Error(
+      `pin ${pinId} already at pending-job cap (${_maxPendingJobsPerPinV2})`,
+    );
+  const j = {
+    id,
+    pinId,
+    kind,
+    status: "queued",
+    createdAt: now,
+    lastSeenAt: now,
+    startedAt: null,
+    settledAt: null,
+    metadata: { ...metadata },
+  };
+  _jobsV2.set(id, j);
+  return _copyJobV2(j);
+}
+
+export function getRetentionJobV2(id) {
+  const j = _jobsV2.get(id);
+  return j ? _copyJobV2(j) : null;
+}
+
+export function listRetentionJobsV2({ pinId, status } = {}) {
+  const out = [];
+  for (const j of _jobsV2.values()) {
+    if (pinId && j.pinId !== pinId) continue;
+    if (status && j.status !== status) continue;
+    out.push(_copyJobV2(j));
+  }
+  return out;
+}
+
+export function setRetentionJobStatusV2(id, next, { now = Date.now() } = {}) {
+  const j = _jobsV2.get(id);
+  if (!j) throw new Error(`job ${id} not found`);
+  if (!JOB_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown job status: ${next}`);
+  if (JOB_TERMINALS_V2.has(j.status))
+    throw new Error(`job ${id} is in terminal state ${j.status}`);
+  const allowed = JOB_TRANSITIONS_V2.get(j.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition job from ${j.status} to ${next}`);
+  if (next === "running" && !j.startedAt) j.startedAt = now;
+  if (JOB_TERMINALS_V2.has(next) && !j.settledAt) j.settledAt = now;
+  j.status = next;
+  j.lastSeenAt = now;
+  return _copyJobV2(j);
+}
+
+export function startRetentionJobV2(id, opts) {
+  return setRetentionJobStatusV2(id, "running", opts);
+}
+export function completeRetentionJobV2(id, opts) {
+  return setRetentionJobStatusV2(id, "completed", opts);
+}
+export function failRetentionJobV2(id, opts) {
+  return setRetentionJobStatusV2(id, "failed", opts);
+}
+export function cancelRetentionJobV2(id, opts) {
+  return setRetentionJobStatusV2(id, "cancelled", opts);
+}
+
+export function autoDormantIdlePinsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const p of _pinsV2.values()) {
+    if (p.status !== "active") continue;
+    if (now - p.lastSeenAt > _pinIdleMsV2) {
+      p.status = "dormant";
+      p.lastSeenAt = now;
+      flipped.push(_copyPinV2(p));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckJobsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const j of _jobsV2.values()) {
+    if (j.status !== "running") continue;
+    if (now - j.lastSeenAt > _jobStuckMsV2) {
+      j.status = "failed";
+      j.lastSeenAt = now;
+      if (!j.settledAt) j.settledAt = now;
+      flipped.push(_copyJobV2(j));
+    }
+  }
+  return flipped;
+}
+
+export function getPermanentMemoryStatsV2() {
+  const pinsByStatus = {};
+  for (const v of Object.values(PIN_MATURITY_V2)) pinsByStatus[v] = 0;
+  for (const p of _pinsV2.values()) pinsByStatus[p.status] += 1;
+
+  const jobsByStatus = {};
+  for (const v of Object.values(RETENTION_JOB_LIFECYCLE_V2))
+    jobsByStatus[v] = 0;
+  for (const j of _jobsV2.values()) jobsByStatus[j.status] += 1;
+
+  return {
+    totalPinsV2: _pinsV2.size,
+    totalJobsV2: _jobsV2.size,
+    maxActivePinsPerOwner: _maxActivePinsPerOwnerV2,
+    maxPendingJobsPerPin: _maxPendingJobsPerPinV2,
+    pinIdleMs: _pinIdleMsV2,
+    jobStuckMs: _jobStuckMsV2,
+    pinsByStatus,
+    jobsByStatus,
+  };
+}
+
+export function _resetStatePermanentMemoryV2() {
+  _pinsV2.clear();
+  _jobsV2.clear();
+  _maxActivePinsPerOwnerV2 = PERMMEM_DEFAULT_MAX_ACTIVE_PINS_PER_OWNER;
+  _maxPendingJobsPerPinV2 = PERMMEM_DEFAULT_MAX_PENDING_JOBS_PER_PIN;
+  _pinIdleMsV2 = PERMMEM_DEFAULT_PIN_IDLE_MS;
+  _jobStuckMsV2 = PERMMEM_DEFAULT_JOB_STUCK_MS;
+}

package/src/lib/permission-engine.js

@@ -372,3 +372,84 @@ export function listUserRoles(db) {
 
   return [...userMap.entries()].map(([userDid, roles]) => ({ userDid, roles }));
 }
+
+// ===== V2 Surface: Permission Engine governance overlay (CLI v0.141.0) =====
+export const PERM_RULE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", DISABLED: "disabled", RETIRED: "retired",
+});
+export const PERM_CHECK_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", EVALUATING: "evaluating", ALLOWED: "allowed", DENIED: "denied", CANCELLED: "cancelled",
+});
+const _permRTrans = new Map([
+  [PERM_RULE_MATURITY_V2.PENDING, new Set([PERM_RULE_MATURITY_V2.ACTIVE, PERM_RULE_MATURITY_V2.RETIRED])],
+  [PERM_RULE_MATURITY_V2.ACTIVE, new Set([PERM_RULE_MATURITY_V2.DISABLED, PERM_RULE_MATURITY_V2.RETIRED])],
+  [PERM_RULE_MATURITY_V2.DISABLED, new Set([PERM_RULE_MATURITY_V2.ACTIVE, PERM_RULE_MATURITY_V2.RETIRED])],
+  [PERM_RULE_MATURITY_V2.RETIRED, new Set()],
+]);
+const _permRTerminal = new Set([PERM_RULE_MATURITY_V2.RETIRED]);
+const _permCTrans = new Map([
+  [PERM_CHECK_LIFECYCLE_V2.QUEUED, new Set([PERM_CHECK_LIFECYCLE_V2.EVALUATING, PERM_CHECK_LIFECYCLE_V2.CANCELLED])],
+  [PERM_CHECK_LIFECYCLE_V2.EVALUATING, new Set([PERM_CHECK_LIFECYCLE_V2.ALLOWED, PERM_CHECK_LIFECYCLE_V2.DENIED, PERM_CHECK_LIFECYCLE_V2.CANCELLED])],
+  [PERM_CHECK_LIFECYCLE_V2.ALLOWED, new Set()],
+  [PERM_CHECK_LIFECYCLE_V2.DENIED, new Set()],
+  [PERM_CHECK_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _permRsV2 = new Map();
+const _permCsV2 = new Map();
+let _permMaxActivePerOwner = 10, _permMaxPendingChecksPerRule = 30, _permIdleMs = 30 * 24 * 60 * 60 * 1000, _permStuckMs = 60 * 1000;
+function _permPos(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 _permCheckR(from, to) { const a = _permRTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid perm rule transition ${from} → ${to}`); }
+function _permCheckC(from, to) { const a = _permCTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid perm check transition ${from} → ${to}`); }
+export function setMaxActivePermRulesPerOwnerV2(n) { _permMaxActivePerOwner = _permPos(n, "maxActivePermRulesPerOwner"); }
+export function getMaxActivePermRulesPerOwnerV2() { return _permMaxActivePerOwner; }
+export function setMaxPendingPermChecksPerRuleV2(n) { _permMaxPendingChecksPerRule = _permPos(n, "maxPendingPermChecksPerRule"); }
+export function getMaxPendingPermChecksPerRuleV2() { return _permMaxPendingChecksPerRule; }
+export function setPermRuleIdleMsV2(n) { _permIdleMs = _permPos(n, "permRuleIdleMs"); }
+export function getPermRuleIdleMsV2() { return _permIdleMs; }
+export function setPermCheckStuckMsV2(n) { _permStuckMs = _permPos(n, "permCheckStuckMs"); }
+export function getPermCheckStuckMsV2() { return _permStuckMs; }
+export function _resetStatePermissionEngineV2() { _permRsV2.clear(); _permCsV2.clear(); _permMaxActivePerOwner = 10; _permMaxPendingChecksPerRule = 30; _permIdleMs = 30 * 24 * 60 * 60 * 1000; _permStuckMs = 60 * 1000; }
+export function registerPermRuleV2({ id, owner, scope, metadata } = {}) {
+  if (!id) throw new Error("perm rule id required"); if (!owner) throw new Error("perm rule owner required");
+  if (_permRsV2.has(id)) throw new Error(`perm rule ${id} already registered`);
+  const now = Date.now();
+  const r = { id, owner, scope: scope || "*", status: PERM_RULE_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, retiredAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _permRsV2.set(id, r); return { ...r, metadata: { ...r.metadata } };
+}
+function _permCountActive(owner) { let n = 0; for (const r of _permRsV2.values()) if (r.owner === owner && r.status === PERM_RULE_MATURITY_V2.ACTIVE) n++; return n; }
+export function activatePermRuleV2(id) {
+  const r = _permRsV2.get(id); if (!r) throw new Error(`perm rule ${id} not found`);
+  _permCheckR(r.status, PERM_RULE_MATURITY_V2.ACTIVE);
+  const recovery = r.status === PERM_RULE_MATURITY_V2.DISABLED;
+  if (!recovery && _permCountActive(r.owner) >= _permMaxActivePerOwner) throw new Error(`max active perm rules for owner ${r.owner} reached`);
+  const now = Date.now(); r.status = PERM_RULE_MATURITY_V2.ACTIVE; r.updatedAt = now; r.lastTouchedAt = now; if (!r.activatedAt) r.activatedAt = now;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function disablePermRuleV2(id) { const r = _permRsV2.get(id); if (!r) throw new Error(`perm rule ${id} not found`); _permCheckR(r.status, PERM_RULE_MATURITY_V2.DISABLED); r.status = PERM_RULE_MATURITY_V2.DISABLED; r.updatedAt = Date.now(); return { ...r, metadata: { ...r.metadata } }; }
+export function retirePermRuleV2(id) { const r = _permRsV2.get(id); if (!r) throw new Error(`perm rule ${id} not found`); _permCheckR(r.status, PERM_RULE_MATURITY_V2.RETIRED); const now = Date.now(); r.status = PERM_RULE_MATURITY_V2.RETIRED; r.updatedAt = now; if (!r.retiredAt) r.retiredAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function touchPermRuleV2(id) { const r = _permRsV2.get(id); if (!r) throw new Error(`perm rule ${id} not found`); if (_permRTerminal.has(r.status)) throw new Error(`cannot touch terminal perm rule ${id}`); const now = Date.now(); r.lastTouchedAt = now; r.updatedAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function getPermRuleV2(id) { const r = _permRsV2.get(id); if (!r) return null; return { ...r, metadata: { ...r.metadata } }; }
+export function listPermRulesV2() { return [..._permRsV2.values()].map((r) => ({ ...r, metadata: { ...r.metadata } })); }
+function _permCountPending(ruleId) { let n = 0; for (const c of _permCsV2.values()) if (c.ruleId === ruleId && (c.status === PERM_CHECK_LIFECYCLE_V2.QUEUED || c.status === PERM_CHECK_LIFECYCLE_V2.EVALUATING)) n++; return n; }
+export function createPermCheckV2({ id, ruleId, subject, metadata } = {}) {
+  if (!id) throw new Error("perm check id required"); if (!ruleId) throw new Error("perm check ruleId required");
+  if (_permCsV2.has(id)) throw new Error(`perm check ${id} already exists`);
+  if (!_permRsV2.has(ruleId)) throw new Error(`perm rule ${ruleId} not found`);
+  if (_permCountPending(ruleId) >= _permMaxPendingChecksPerRule) throw new Error(`max pending perm checks for rule ${ruleId} reached`);
+  const now = Date.now();
+  const c = { id, ruleId, subject: subject || "", status: PERM_CHECK_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _permCsV2.set(id, c); return { ...c, metadata: { ...c.metadata } };
+}
+export function evaluatePermCheckV2(id) { const c = _permCsV2.get(id); if (!c) throw new Error(`perm check ${id} not found`); _permCheckC(c.status, PERM_CHECK_LIFECYCLE_V2.EVALUATING); const now = Date.now(); c.status = PERM_CHECK_LIFECYCLE_V2.EVALUATING; c.updatedAt = now; if (!c.startedAt) c.startedAt = now; return { ...c, metadata: { ...c.metadata } }; }
+export function allowPermCheckV2(id) { const c = _permCsV2.get(id); if (!c) throw new Error(`perm check ${id} not found`); _permCheckC(c.status, PERM_CHECK_LIFECYCLE_V2.ALLOWED); const now = Date.now(); c.status = PERM_CHECK_LIFECYCLE_V2.ALLOWED; c.updatedAt = now; if (!c.settledAt) c.settledAt = now; return { ...c, metadata: { ...c.metadata } }; }
+export function denyPermCheckV2(id, reason) { const c = _permCsV2.get(id); if (!c) throw new Error(`perm check ${id} not found`); _permCheckC(c.status, PERM_CHECK_LIFECYCLE_V2.DENIED); const now = Date.now(); c.status = PERM_CHECK_LIFECYCLE_V2.DENIED; c.updatedAt = now; if (!c.settledAt) c.settledAt = now; if (reason) c.metadata.denyReason = String(reason); return { ...c, metadata: { ...c.metadata } }; }
+export function cancelPermCheckV2(id, reason) { const c = _permCsV2.get(id); if (!c) throw new Error(`perm check ${id} not found`); _permCheckC(c.status, PERM_CHECK_LIFECYCLE_V2.CANCELLED); const now = Date.now(); c.status = PERM_CHECK_LIFECYCLE_V2.CANCELLED; c.updatedAt = now; if (!c.settledAt) c.settledAt = now; if (reason) c.metadata.cancelReason = String(reason); return { ...c, metadata: { ...c.metadata } }; }
+export function getPermCheckV2(id) { const c = _permCsV2.get(id); if (!c) return null; return { ...c, metadata: { ...c.metadata } }; }
+export function listPermChecksV2() { return [..._permCsV2.values()].map((c) => ({ ...c, metadata: { ...c.metadata } })); }
+export function autoDisableIdlePermRulesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const r of _permRsV2.values()) if (r.status === PERM_RULE_MATURITY_V2.ACTIVE && (t - r.lastTouchedAt) >= _permIdleMs) { r.status = PERM_RULE_MATURITY_V2.DISABLED; r.updatedAt = t; flipped.push(r.id); } return { flipped, count: flipped.length }; }
+export function autoDenyStuckPermChecksV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const c of _permCsV2.values()) if (c.status === PERM_CHECK_LIFECYCLE_V2.EVALUATING && c.startedAt != null && (t - c.startedAt) >= _permStuckMs) { c.status = PERM_CHECK_LIFECYCLE_V2.DENIED; c.updatedAt = t; if (!c.settledAt) c.settledAt = t; c.metadata.denyReason = "auto-deny-stuck"; flipped.push(c.id); } return { flipped, count: flipped.length }; }
+export function getPermissionEngineGovStatsV2() {
+  const rulesByStatus = {}; for (const v of Object.values(PERM_RULE_MATURITY_V2)) rulesByStatus[v] = 0; for (const r of _permRsV2.values()) rulesByStatus[r.status]++;
+  const checksByStatus = {}; for (const v of Object.values(PERM_CHECK_LIFECYCLE_V2)) checksByStatus[v] = 0; for (const c of _permCsV2.values()) checksByStatus[c.status]++;
+  return { totalPermRulesV2: _permRsV2.size, totalPermChecksV2: _permCsV2.size, maxActivePermRulesPerOwner: _permMaxActivePerOwner, maxPendingPermChecksPerRule: _permMaxPendingChecksPerRule, permRuleIdleMs: _permIdleMs, permCheckStuckMs: _permStuckMs, rulesByStatus, checksByStatus };
+}

package/src/lib/pipeline-orchestrator.js

@@ -926,3 +926,108 @@ export function getStats(db) {
     deploysByStrategy: deployByStrategy,
   };
 }
+
+
+// ===== V2 Surface: Pipeline Orchestrator governance overlay (CLI v0.137.0) =====
+export const PIPELINE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", ARCHIVED: "archived",
+});
+export const PIPELINE_RUN_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", RUNNING: "running", COMPLETED: "completed", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _pipTrans = new Map([
+  [PIPELINE_MATURITY_V2.PENDING, new Set([PIPELINE_MATURITY_V2.ACTIVE, PIPELINE_MATURITY_V2.ARCHIVED])],
+  [PIPELINE_MATURITY_V2.ACTIVE, new Set([PIPELINE_MATURITY_V2.PAUSED, PIPELINE_MATURITY_V2.ARCHIVED])],
+  [PIPELINE_MATURITY_V2.PAUSED, new Set([PIPELINE_MATURITY_V2.ACTIVE, PIPELINE_MATURITY_V2.ARCHIVED])],
+  [PIPELINE_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _pipTerminal = new Set([PIPELINE_MATURITY_V2.ARCHIVED]);
+const _pipRunTrans = new Map([
+  [PIPELINE_RUN_LIFECYCLE_V2.QUEUED, new Set([PIPELINE_RUN_LIFECYCLE_V2.RUNNING, PIPELINE_RUN_LIFECYCLE_V2.CANCELLED])],
+  [PIPELINE_RUN_LIFECYCLE_V2.RUNNING, new Set([PIPELINE_RUN_LIFECYCLE_V2.COMPLETED, PIPELINE_RUN_LIFECYCLE_V2.FAILED, PIPELINE_RUN_LIFECYCLE_V2.CANCELLED])],
+  [PIPELINE_RUN_LIFECYCLE_V2.COMPLETED, new Set()],
+  [PIPELINE_RUN_LIFECYCLE_V2.FAILED, new Set()],
+  [PIPELINE_RUN_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _pips = new Map();
+const _pipRuns = new Map();
+let _pipMaxActivePerOwner = 10;
+let _pipMaxPendingPerPip = 20;
+let _pipIdleMs = 3 * 24 * 60 * 60 * 1000;
+let _pipRunStuckMs = 10 * 60 * 1000;
+
+function _pipPos(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 setMaxActivePipelinesPerOwnerV2(n) { _pipMaxActivePerOwner = _pipPos(n, "maxActivePipelinesPerOwner"); }
+export function getMaxActivePipelinesPerOwnerV2() { return _pipMaxActivePerOwner; }
+export function setMaxPendingPipelineRunsPerPipelineV2(n) { _pipMaxPendingPerPip = _pipPos(n, "maxPendingPipelineRunsPerPipeline"); }
+export function getMaxPendingPipelineRunsPerPipelineV2() { return _pipMaxPendingPerPip; }
+export function setPipelineIdleMsV2(n) { _pipIdleMs = _pipPos(n, "pipelineIdleMs"); }
+export function getPipelineIdleMsV2() { return _pipIdleMs; }
+export function setPipelineRunStuckMsV2(n) { _pipRunStuckMs = _pipPos(n, "pipelineRunStuckMs"); }
+export function getPipelineRunStuckMsV2() { return _pipRunStuckMs; }
+
+export function _resetStatePipelineOrchestratorV2() {
+  _pips.clear(); _pipRuns.clear();
+  _pipMaxActivePerOwner = 10; _pipMaxPendingPerPip = 20;
+  _pipIdleMs = 3 * 24 * 60 * 60 * 1000; _pipRunStuckMs = 10 * 60 * 1000;
+}
+
+export function registerPipelineV2({ id, owner, name, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_pips.has(id)) throw new Error(`pipeline ${id} already registered`);
+  const now = Date.now();
+  const p = { id, owner, name: name || id, status: PIPELINE_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, archivedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _pips.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+function _pipCheckP(from, to) { const a = _pipTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid pipeline transition ${from} → ${to}`); }
+function _pipCountActive(owner) { let n = 0; for (const p of _pips.values()) if (p.owner === owner && p.status === PIPELINE_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activatePipelineV2(id) {
+  const p = _pips.get(id); if (!p) throw new Error(`pipeline ${id} not found`);
+  _pipCheckP(p.status, PIPELINE_MATURITY_V2.ACTIVE);
+  const recovery = p.status === PIPELINE_MATURITY_V2.PAUSED;
+  if (!recovery) { const c = _pipCountActive(p.owner); if (c >= _pipMaxActivePerOwner) throw new Error(`max active pipelines per owner (${_pipMaxActivePerOwner}) reached for ${p.owner}`); }
+  const now = Date.now(); p.status = PIPELINE_MATURITY_V2.ACTIVE; p.updatedAt = now; p.lastTouchedAt = now; if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function pausePipelineV2(id) { const p = _pips.get(id); if (!p) throw new Error(`pipeline ${id} not found`); _pipCheckP(p.status, PIPELINE_MATURITY_V2.PAUSED); p.status = PIPELINE_MATURITY_V2.PAUSED; p.updatedAt = Date.now(); return { ...p, metadata: { ...p.metadata } }; }
+export function archivePipelineV2(id) { const p = _pips.get(id); if (!p) throw new Error(`pipeline ${id} not found`); _pipCheckP(p.status, PIPELINE_MATURITY_V2.ARCHIVED); const now = Date.now(); p.status = PIPELINE_MATURITY_V2.ARCHIVED; p.updatedAt = now; if (!p.archivedAt) p.archivedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function touchPipelineV2(id) { const p = _pips.get(id); if (!p) throw new Error(`pipeline ${id} not found`); if (_pipTerminal.has(p.status)) throw new Error(`cannot touch terminal pipeline ${id}`); const now = Date.now(); p.lastTouchedAt = now; p.updatedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function getPipelineV2(id) { const p = _pips.get(id); if (!p) return null; return { ...p, metadata: { ...p.metadata } }; }
+export function listPipelinesV2() { return [..._pips.values()].map((p) => ({ ...p, metadata: { ...p.metadata } })); }
+
+function _pipCountPendingRuns(pid) { let n = 0; for (const r of _pipRuns.values()) if (r.pipelineId === pid && (r.status === PIPELINE_RUN_LIFECYCLE_V2.QUEUED || r.status === PIPELINE_RUN_LIFECYCLE_V2.RUNNING)) n++; return n; }
+
+export function createPipelineRunV2({ id, pipelineId, trigger, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!pipelineId || typeof pipelineId !== "string") throw new Error("pipelineId is required");
+  if (_pipRuns.has(id)) throw new Error(`pipeline run ${id} already exists`);
+  if (!_pips.has(pipelineId)) throw new Error(`pipeline ${pipelineId} not found`);
+  const pending = _pipCountPendingRuns(pipelineId);
+  if (pending >= _pipMaxPendingPerPip) throw new Error(`max pending pipeline runs per pipeline (${_pipMaxPendingPerPip}) reached for ${pipelineId}`);
+  const now = Date.now();
+  const r = { id, pipelineId, trigger: trigger || "manual", status: PIPELINE_RUN_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _pipRuns.set(id, r);
+  return { ...r, metadata: { ...r.metadata } };
+}
+function _pipCheckR(from, to) { const a = _pipRunTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid pipeline run transition ${from} → ${to}`); }
+export function startPipelineRunV2(id) { const r = _pipRuns.get(id); if (!r) throw new Error(`pipeline run ${id} not found`); _pipCheckR(r.status, PIPELINE_RUN_LIFECYCLE_V2.RUNNING); const now = Date.now(); r.status = PIPELINE_RUN_LIFECYCLE_V2.RUNNING; r.updatedAt = now; if (!r.startedAt) r.startedAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function completePipelineRunV2(id) { const r = _pipRuns.get(id); if (!r) throw new Error(`pipeline run ${id} not found`); _pipCheckR(r.status, PIPELINE_RUN_LIFECYCLE_V2.COMPLETED); const now = Date.now(); r.status = PIPELINE_RUN_LIFECYCLE_V2.COMPLETED; r.updatedAt = now; if (!r.settledAt) r.settledAt = now; return { ...r, metadata: { ...r.metadata } }; }
+export function failPipelineRunV2(id, reason) { const r = _pipRuns.get(id); if (!r) throw new Error(`pipeline run ${id} not found`); _pipCheckR(r.status, PIPELINE_RUN_LIFECYCLE_V2.FAILED); const now = Date.now(); r.status = PIPELINE_RUN_LIFECYCLE_V2.FAILED; r.updatedAt = now; if (!r.settledAt) r.settledAt = now; if (reason) r.metadata.failReason = String(reason); return { ...r, metadata: { ...r.metadata } }; }
+export function cancelPipelineRunV2(id, reason) { const r = _pipRuns.get(id); if (!r) throw new Error(`pipeline run ${id} not found`); _pipCheckR(r.status, PIPELINE_RUN_LIFECYCLE_V2.CANCELLED); const now = Date.now(); r.status = PIPELINE_RUN_LIFECYCLE_V2.CANCELLED; r.updatedAt = now; if (!r.settledAt) r.settledAt = now; if (reason) r.metadata.cancelReason = String(reason); return { ...r, metadata: { ...r.metadata } }; }
+export function getPipelineRunV2(id) { const r = _pipRuns.get(id); if (!r) return null; return { ...r, metadata: { ...r.metadata } }; }
+export function listPipelineRunsV2() { return [..._pipRuns.values()].map((r) => ({ ...r, metadata: { ...r.metadata } })); }
+
+export function autoPauseIdlePipelinesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const p of _pips.values()) if (p.status === PIPELINE_MATURITY_V2.ACTIVE && (t - p.lastTouchedAt) >= _pipIdleMs) { p.status = PIPELINE_MATURITY_V2.PAUSED; p.updatedAt = t; flipped.push(p.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckPipelineRunsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const r of _pipRuns.values()) if (r.status === PIPELINE_RUN_LIFECYCLE_V2.RUNNING && r.startedAt != null && (t - r.startedAt) >= _pipRunStuckMs) { r.status = PIPELINE_RUN_LIFECYCLE_V2.FAILED; r.updatedAt = t; if (!r.settledAt) r.settledAt = t; r.metadata.failReason = "auto-fail-stuck"; flipped.push(r.id); } return { flipped, count: flipped.length }; }
+
+export function getPipelineOrchestratorGovStatsV2() {
+  const pipelinesByStatus = {}; for (const s of Object.values(PIPELINE_MATURITY_V2)) pipelinesByStatus[s] = 0; for (const p of _pips.values()) pipelinesByStatus[p.status]++;
+  const runsByStatus = {}; for (const s of Object.values(PIPELINE_RUN_LIFECYCLE_V2)) runsByStatus[s] = 0; for (const r of _pipRuns.values()) runsByStatus[r.status]++;
+  return { totalPipelinesV2: _pips.size, totalRunsV2: _pipRuns.size, maxActivePipelinesPerOwner: _pipMaxActivePerOwner, maxPendingPipelineRunsPerPipeline: _pipMaxPendingPerPip, pipelineIdleMs: _pipIdleMs, pipelineRunStuckMs: _pipRunStuckMs, pipelinesByStatus, runsByStatus };
+}

package/src/lib/plan-mode.js

@@ -544,3 +544,84 @@ export function destroyPlanModeManager() {
     _instance = null;
   }
 }
+
+// ===== V2 Surface: Plan Mode governance overlay (CLI v0.141.0) =====
+export const PLAN_PROFILE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", ARCHIVED: "archived",
+});
+export const PLAN_STEP_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", RUNNING: "running", COMPLETED: "completed", FAILED: "failed", CANCELLED: "cancelled",
+});
+const _planPTrans = new Map([
+  [PLAN_PROFILE_MATURITY_V2.PENDING, new Set([PLAN_PROFILE_MATURITY_V2.ACTIVE, PLAN_PROFILE_MATURITY_V2.ARCHIVED])],
+  [PLAN_PROFILE_MATURITY_V2.ACTIVE, new Set([PLAN_PROFILE_MATURITY_V2.PAUSED, PLAN_PROFILE_MATURITY_V2.ARCHIVED])],
+  [PLAN_PROFILE_MATURITY_V2.PAUSED, new Set([PLAN_PROFILE_MATURITY_V2.ACTIVE, PLAN_PROFILE_MATURITY_V2.ARCHIVED])],
+  [PLAN_PROFILE_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _planPTerminal = new Set([PLAN_PROFILE_MATURITY_V2.ARCHIVED]);
+const _planSTrans = new Map([
+  [PLAN_STEP_LIFECYCLE_V2.QUEUED, new Set([PLAN_STEP_LIFECYCLE_V2.RUNNING, PLAN_STEP_LIFECYCLE_V2.CANCELLED])],
+  [PLAN_STEP_LIFECYCLE_V2.RUNNING, new Set([PLAN_STEP_LIFECYCLE_V2.COMPLETED, PLAN_STEP_LIFECYCLE_V2.FAILED, PLAN_STEP_LIFECYCLE_V2.CANCELLED])],
+  [PLAN_STEP_LIFECYCLE_V2.COMPLETED, new Set()],
+  [PLAN_STEP_LIFECYCLE_V2.FAILED, new Set()],
+  [PLAN_STEP_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _planPsV2 = new Map();
+const _planSsV2 = new Map();
+let _planMaxActivePerOwner = 6, _planMaxPendingStepsPerProfile = 15, _planIdleMs = 7 * 24 * 60 * 60 * 1000, _planStuckMs = 30 * 60 * 1000;
+function _planPos(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 _planCheckP(from, to) { const a = _planPTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid plan profile transition ${from} → ${to}`); }
+function _planCheckS(from, to) { const a = _planSTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid plan step transition ${from} → ${to}`); }
+export function setMaxActivePlanProfilesPerOwnerV2(n) { _planMaxActivePerOwner = _planPos(n, "maxActivePlanProfilesPerOwner"); }
+export function getMaxActivePlanProfilesPerOwnerV2() { return _planMaxActivePerOwner; }
+export function setMaxPendingPlanStepsPerProfileV2(n) { _planMaxPendingStepsPerProfile = _planPos(n, "maxPendingPlanStepsPerProfile"); }
+export function getMaxPendingPlanStepsPerProfileV2() { return _planMaxPendingStepsPerProfile; }
+export function setPlanProfileIdleMsV2(n) { _planIdleMs = _planPos(n, "planProfileIdleMs"); }
+export function getPlanProfileIdleMsV2() { return _planIdleMs; }
+export function setPlanStepStuckMsV2(n) { _planStuckMs = _planPos(n, "planStepStuckMs"); }
+export function getPlanStepStuckMsV2() { return _planStuckMs; }
+export function _resetStatePlanModeV2() { _planPsV2.clear(); _planSsV2.clear(); _planMaxActivePerOwner = 6; _planMaxPendingStepsPerProfile = 15; _planIdleMs = 7 * 24 * 60 * 60 * 1000; _planStuckMs = 30 * 60 * 1000; }
+export function registerPlanProfileV2({ id, owner, goal, metadata } = {}) {
+  if (!id) throw new Error("plan profile id required"); if (!owner) throw new Error("plan profile owner required");
+  if (_planPsV2.has(id)) throw new Error(`plan profile ${id} already registered`);
+  const now = Date.now();
+  const p = { id, owner, goal: goal || "", status: PLAN_PROFILE_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, archivedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _planPsV2.set(id, p); return { ...p, metadata: { ...p.metadata } };
+}
+function _planCountActive(owner) { let n = 0; for (const p of _planPsV2.values()) if (p.owner === owner && p.status === PLAN_PROFILE_MATURITY_V2.ACTIVE) n++; return n; }
+export function activatePlanProfileV2(id) {
+  const p = _planPsV2.get(id); if (!p) throw new Error(`plan profile ${id} not found`);
+  _planCheckP(p.status, PLAN_PROFILE_MATURITY_V2.ACTIVE);
+  const recovery = p.status === PLAN_PROFILE_MATURITY_V2.PAUSED;
+  if (!recovery && _planCountActive(p.owner) >= _planMaxActivePerOwner) throw new Error(`max active plan profiles for owner ${p.owner} reached`);
+  const now = Date.now(); p.status = PLAN_PROFILE_MATURITY_V2.ACTIVE; p.updatedAt = now; p.lastTouchedAt = now; if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function pausePlanProfileV2(id) { const p = _planPsV2.get(id); if (!p) throw new Error(`plan profile ${id} not found`); _planCheckP(p.status, PLAN_PROFILE_MATURITY_V2.PAUSED); p.status = PLAN_PROFILE_MATURITY_V2.PAUSED; p.updatedAt = Date.now(); return { ...p, metadata: { ...p.metadata } }; }
+export function archivePlanProfileV2(id) { const p = _planPsV2.get(id); if (!p) throw new Error(`plan profile ${id} not found`); _planCheckP(p.status, PLAN_PROFILE_MATURITY_V2.ARCHIVED); const now = Date.now(); p.status = PLAN_PROFILE_MATURITY_V2.ARCHIVED; p.updatedAt = now; if (!p.archivedAt) p.archivedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function touchPlanProfileV2(id) { const p = _planPsV2.get(id); if (!p) throw new Error(`plan profile ${id} not found`); if (_planPTerminal.has(p.status)) throw new Error(`cannot touch terminal plan profile ${id}`); const now = Date.now(); p.lastTouchedAt = now; p.updatedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function getPlanProfileV2(id) { const p = _planPsV2.get(id); if (!p) return null; return { ...p, metadata: { ...p.metadata } }; }
+export function listPlanProfilesV2() { return [..._planPsV2.values()].map((p) => ({ ...p, metadata: { ...p.metadata } })); }
+function _planCountPending(profileId) { let n = 0; for (const s of _planSsV2.values()) if (s.profileId === profileId && (s.status === PLAN_STEP_LIFECYCLE_V2.QUEUED || s.status === PLAN_STEP_LIFECYCLE_V2.RUNNING)) n++; return n; }
+export function createPlanStepV2({ id, profileId, action, metadata } = {}) {
+  if (!id) throw new Error("plan step id required"); if (!profileId) throw new Error("plan step profileId required");
+  if (_planSsV2.has(id)) throw new Error(`plan step ${id} already exists`);
+  if (!_planPsV2.has(profileId)) throw new Error(`plan profile ${profileId} not found`);
+  if (_planCountPending(profileId) >= _planMaxPendingStepsPerProfile) throw new Error(`max pending plan steps for profile ${profileId} reached`);
+  const now = Date.now();
+  const s = { id, profileId, action: action || "", status: PLAN_STEP_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _planSsV2.set(id, s); return { ...s, metadata: { ...s.metadata } };
+}
+export function startPlanStepV2(id) { const s = _planSsV2.get(id); if (!s) throw new Error(`plan step ${id} not found`); _planCheckS(s.status, PLAN_STEP_LIFECYCLE_V2.RUNNING); const now = Date.now(); s.status = PLAN_STEP_LIFECYCLE_V2.RUNNING; s.updatedAt = now; if (!s.startedAt) s.startedAt = now; return { ...s, metadata: { ...s.metadata } }; }
+export function completePlanStepV2(id) { const s = _planSsV2.get(id); if (!s) throw new Error(`plan step ${id} not found`); _planCheckS(s.status, PLAN_STEP_LIFECYCLE_V2.COMPLETED); const now = Date.now(); s.status = PLAN_STEP_LIFECYCLE_V2.COMPLETED; s.updatedAt = now; if (!s.settledAt) s.settledAt = now; return { ...s, metadata: { ...s.metadata } }; }
+export function failPlanStepV2(id, reason) { const s = _planSsV2.get(id); if (!s) throw new Error(`plan step ${id} not found`); _planCheckS(s.status, PLAN_STEP_LIFECYCLE_V2.FAILED); const now = Date.now(); s.status = PLAN_STEP_LIFECYCLE_V2.FAILED; s.updatedAt = now; if (!s.settledAt) s.settledAt = now; if (reason) s.metadata.failReason = String(reason); return { ...s, metadata: { ...s.metadata } }; }
+export function cancelPlanStepV2(id, reason) { const s = _planSsV2.get(id); if (!s) throw new Error(`plan step ${id} not found`); _planCheckS(s.status, PLAN_STEP_LIFECYCLE_V2.CANCELLED); const now = Date.now(); s.status = PLAN_STEP_LIFECYCLE_V2.CANCELLED; s.updatedAt = now; if (!s.settledAt) s.settledAt = now; if (reason) s.metadata.cancelReason = String(reason); return { ...s, metadata: { ...s.metadata } }; }
+export function getPlanStepV2(id) { const s = _planSsV2.get(id); if (!s) return null; return { ...s, metadata: { ...s.metadata } }; }
+export function listPlanStepsV2() { return [..._planSsV2.values()].map((s) => ({ ...s, metadata: { ...s.metadata } })); }
+export function autoPauseIdlePlanProfilesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const p of _planPsV2.values()) if (p.status === PLAN_PROFILE_MATURITY_V2.ACTIVE && (t - p.lastTouchedAt) >= _planIdleMs) { p.status = PLAN_PROFILE_MATURITY_V2.PAUSED; p.updatedAt = t; flipped.push(p.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckPlanStepsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const s of _planSsV2.values()) if (s.status === PLAN_STEP_LIFECYCLE_V2.RUNNING && s.startedAt != null && (t - s.startedAt) >= _planStuckMs) { s.status = PLAN_STEP_LIFECYCLE_V2.FAILED; s.updatedAt = t; if (!s.settledAt) s.settledAt = t; s.metadata.failReason = "auto-fail-stuck"; flipped.push(s.id); } return { flipped, count: flipped.length }; }
+export function getPlanModeGovStatsV2() {
+  const profilesByStatus = {}; for (const v of Object.values(PLAN_PROFILE_MATURITY_V2)) profilesByStatus[v] = 0; for (const p of _planPsV2.values()) profilesByStatus[p.status]++;
+  const stepsByStatus = {}; for (const v of Object.values(PLAN_STEP_LIFECYCLE_V2)) stepsByStatus[v] = 0; for (const s of _planSsV2.values()) stepsByStatus[s.status]++;
+  return { totalPlanProfilesV2: _planPsV2.size, totalPlanStepsV2: _planSsV2.size, maxActivePlanProfilesPerOwner: _planMaxActivePerOwner, maxPendingPlanStepsPerProfile: _planMaxPendingStepsPerProfile, planProfileIdleMs: _planIdleMs, planStepStuckMs: _planStuckMs, profilesByStatus, stepsByStatus };
+}