chainlesschain 0.132.0 → 0.143.0

package/src/lib/cowork-task-runner.js

@@ -465,3 +465,108 @@ function _appendHistory(cwd, entry, userMessage) {
     // Best-effort — don't fail the task for history write errors
   }
 }
+
+
+// ===== V2 Surface: Cowork Task Runner governance overlay (CLI v0.139.0) =====
+export const RUNNER_PROFILE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", RETIRED: "retired",
+});
+export const RUNNER_EXEC_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", RUNNING: "running", SUCCEEDED: "succeeded", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _rpTrans = new Map([
+  [RUNNER_PROFILE_MATURITY_V2.PENDING, new Set([RUNNER_PROFILE_MATURITY_V2.ACTIVE, RUNNER_PROFILE_MATURITY_V2.RETIRED])],
+  [RUNNER_PROFILE_MATURITY_V2.ACTIVE, new Set([RUNNER_PROFILE_MATURITY_V2.PAUSED, RUNNER_PROFILE_MATURITY_V2.RETIRED])],
+  [RUNNER_PROFILE_MATURITY_V2.PAUSED, new Set([RUNNER_PROFILE_MATURITY_V2.ACTIVE, RUNNER_PROFILE_MATURITY_V2.RETIRED])],
+  [RUNNER_PROFILE_MATURITY_V2.RETIRED, new Set()],
+]);
+const _rpTerminal = new Set([RUNNER_PROFILE_MATURITY_V2.RETIRED]);
+const _reTrans = new Map([
+  [RUNNER_EXEC_LIFECYCLE_V2.QUEUED, new Set([RUNNER_EXEC_LIFECYCLE_V2.RUNNING, RUNNER_EXEC_LIFECYCLE_V2.CANCELLED])],
+  [RUNNER_EXEC_LIFECYCLE_V2.RUNNING, new Set([RUNNER_EXEC_LIFECYCLE_V2.SUCCEEDED, RUNNER_EXEC_LIFECYCLE_V2.FAILED, RUNNER_EXEC_LIFECYCLE_V2.CANCELLED])],
+  [RUNNER_EXEC_LIFECYCLE_V2.SUCCEEDED, new Set()],
+  [RUNNER_EXEC_LIFECYCLE_V2.FAILED, new Set()],
+  [RUNNER_EXEC_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _rpsV2 = new Map();
+const _resV2 = new Map();
+let _rpMaxActivePerOwner = 8;
+let _rpMaxPendingExecsPerProfile = 15;
+let _rpIdleMs = 14 * 24 * 60 * 60 * 1000;
+let _reStuckMs = 20 * 60 * 1000;
+
+function _rpPos(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 setMaxActiveRunnerProfilesPerOwnerV2(n) { _rpMaxActivePerOwner = _rpPos(n, "maxActiveRunnerProfilesPerOwner"); }
+export function getMaxActiveRunnerProfilesPerOwnerV2() { return _rpMaxActivePerOwner; }
+export function setMaxPendingRunnerExecsPerProfileV2(n) { _rpMaxPendingExecsPerProfile = _rpPos(n, "maxPendingRunnerExecsPerProfile"); }
+export function getMaxPendingRunnerExecsPerProfileV2() { return _rpMaxPendingExecsPerProfile; }
+export function setRunnerProfileIdleMsV2(n) { _rpIdleMs = _rpPos(n, "runnerProfileIdleMs"); }
+export function getRunnerProfileIdleMsV2() { return _rpIdleMs; }
+export function setRunnerExecStuckMsV2(n) { _reStuckMs = _rpPos(n, "runnerExecStuckMs"); }
+export function getRunnerExecStuckMsV2() { return _reStuckMs; }
+
+export function _resetStateRunnerV2() {
+  _rpsV2.clear(); _resV2.clear();
+  _rpMaxActivePerOwner = 8; _rpMaxPendingExecsPerProfile = 15;
+  _rpIdleMs = 14 * 24 * 60 * 60 * 1000; _reStuckMs = 20 * 60 * 1000;
+}
+
+export function registerRunnerProfileV2({ id, owner, template, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_rpsV2.has(id)) throw new Error(`runner profile ${id} already registered`);
+  const now = Date.now();
+  const p = { id, owner, template: template || "default", status: RUNNER_PROFILE_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, retiredAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _rpsV2.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+function _rpCheckP(from, to) { const a = _rpTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid runner profile transition ${from} → ${to}`); }
+function _rpCountActive(owner) { let n = 0; for (const p of _rpsV2.values()) if (p.owner === owner && p.status === RUNNER_PROFILE_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateRunnerProfileV2(id) {
+  const p = _rpsV2.get(id); if (!p) throw new Error(`runner profile ${id} not found`);
+  _rpCheckP(p.status, RUNNER_PROFILE_MATURITY_V2.ACTIVE);
+  const recovery = p.status === RUNNER_PROFILE_MATURITY_V2.PAUSED;
+  if (!recovery) { const c = _rpCountActive(p.owner); if (c >= _rpMaxActivePerOwner) throw new Error(`max active runner profiles per owner (${_rpMaxActivePerOwner}) reached for ${p.owner}`); }
+  const now = Date.now(); p.status = RUNNER_PROFILE_MATURITY_V2.ACTIVE; p.updatedAt = now; p.lastTouchedAt = now; if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function pauseRunnerProfileV2(id) { const p = _rpsV2.get(id); if (!p) throw new Error(`runner profile ${id} not found`); _rpCheckP(p.status, RUNNER_PROFILE_MATURITY_V2.PAUSED); p.status = RUNNER_PROFILE_MATURITY_V2.PAUSED; p.updatedAt = Date.now(); return { ...p, metadata: { ...p.metadata } }; }
+export function retireRunnerProfileV2(id) { const p = _rpsV2.get(id); if (!p) throw new Error(`runner profile ${id} not found`); _rpCheckP(p.status, RUNNER_PROFILE_MATURITY_V2.RETIRED); const now = Date.now(); p.status = RUNNER_PROFILE_MATURITY_V2.RETIRED; p.updatedAt = now; if (!p.retiredAt) p.retiredAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function touchRunnerProfileV2(id) { const p = _rpsV2.get(id); if (!p) throw new Error(`runner profile ${id} not found`); if (_rpTerminal.has(p.status)) throw new Error(`cannot touch terminal runner profile ${id}`); const now = Date.now(); p.lastTouchedAt = now; p.updatedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function getRunnerProfileV2(id) { const p = _rpsV2.get(id); if (!p) return null; return { ...p, metadata: { ...p.metadata } }; }
+export function listRunnerProfilesV2() { return [..._rpsV2.values()].map((p) => ({ ...p, metadata: { ...p.metadata } })); }
+
+function _reCountPending(profileId) { let n = 0; for (const e of _resV2.values()) if (e.profileId === profileId && (e.status === RUNNER_EXEC_LIFECYCLE_V2.QUEUED || e.status === RUNNER_EXEC_LIFECYCLE_V2.RUNNING)) n++; return n; }
+
+export function createRunnerExecV2({ id, profileId, taskInput, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!profileId || typeof profileId !== "string") throw new Error("profileId is required");
+  if (_resV2.has(id)) throw new Error(`runner exec ${id} already exists`);
+  if (!_rpsV2.has(profileId)) throw new Error(`runner profile ${profileId} not found`);
+  const pending = _reCountPending(profileId);
+  if (pending >= _rpMaxPendingExecsPerProfile) throw new Error(`max pending runner execs per profile (${_rpMaxPendingExecsPerProfile}) reached for ${profileId}`);
+  const now = Date.now();
+  const e = { id, profileId, taskInput: taskInput || "", status: RUNNER_EXEC_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _resV2.set(id, e);
+  return { ...e, metadata: { ...e.metadata } };
+}
+function _reCheckE(from, to) { const a = _reTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid runner exec transition ${from} → ${to}`); }
+export function startRunnerExecV2(id) { const e = _resV2.get(id); if (!e) throw new Error(`runner exec ${id} not found`); _reCheckE(e.status, RUNNER_EXEC_LIFECYCLE_V2.RUNNING); const now = Date.now(); e.status = RUNNER_EXEC_LIFECYCLE_V2.RUNNING; e.updatedAt = now; if (!e.startedAt) e.startedAt = now; return { ...e, metadata: { ...e.metadata } }; }
+export function succeedRunnerExecV2(id) { const e = _resV2.get(id); if (!e) throw new Error(`runner exec ${id} not found`); _reCheckE(e.status, RUNNER_EXEC_LIFECYCLE_V2.SUCCEEDED); const now = Date.now(); e.status = RUNNER_EXEC_LIFECYCLE_V2.SUCCEEDED; e.updatedAt = now; if (!e.settledAt) e.settledAt = now; return { ...e, metadata: { ...e.metadata } }; }
+export function failRunnerExecV2(id, reason) { const e = _resV2.get(id); if (!e) throw new Error(`runner exec ${id} not found`); _reCheckE(e.status, RUNNER_EXEC_LIFECYCLE_V2.FAILED); const now = Date.now(); e.status = RUNNER_EXEC_LIFECYCLE_V2.FAILED; e.updatedAt = now; if (!e.settledAt) e.settledAt = now; if (reason) e.metadata.failReason = String(reason); return { ...e, metadata: { ...e.metadata } }; }
+export function cancelRunnerExecV2(id, reason) { const e = _resV2.get(id); if (!e) throw new Error(`runner exec ${id} not found`); _reCheckE(e.status, RUNNER_EXEC_LIFECYCLE_V2.CANCELLED); const now = Date.now(); e.status = RUNNER_EXEC_LIFECYCLE_V2.CANCELLED; e.updatedAt = now; if (!e.settledAt) e.settledAt = now; if (reason) e.metadata.cancelReason = String(reason); return { ...e, metadata: { ...e.metadata } }; }
+export function getRunnerExecV2(id) { const e = _resV2.get(id); if (!e) return null; return { ...e, metadata: { ...e.metadata } }; }
+export function listRunnerExecsV2() { return [..._resV2.values()].map((e) => ({ ...e, metadata: { ...e.metadata } })); }
+
+export function autoPauseIdleRunnerProfilesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const p of _rpsV2.values()) if (p.status === RUNNER_PROFILE_MATURITY_V2.ACTIVE && (t - p.lastTouchedAt) >= _rpIdleMs) { p.status = RUNNER_PROFILE_MATURITY_V2.PAUSED; p.updatedAt = t; flipped.push(p.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckRunnerExecsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const e of _resV2.values()) if (e.status === RUNNER_EXEC_LIFECYCLE_V2.RUNNING && e.startedAt != null && (t - e.startedAt) >= _reStuckMs) { e.status = RUNNER_EXEC_LIFECYCLE_V2.FAILED; e.updatedAt = t; if (!e.settledAt) e.settledAt = t; e.metadata.failReason = "auto-fail-stuck"; flipped.push(e.id); } return { flipped, count: flipped.length }; }
+
+export function getRunnerGovStatsV2() {
+  const profilesByStatus = {}; for (const s of Object.values(RUNNER_PROFILE_MATURITY_V2)) profilesByStatus[s] = 0; for (const p of _rpsV2.values()) profilesByStatus[p.status]++;
+  const execsByStatus = {}; for (const s of Object.values(RUNNER_EXEC_LIFECYCLE_V2)) execsByStatus[s] = 0; for (const e of _resV2.values()) execsByStatus[e.status]++;
+  return { totalRunnerProfilesV2: _rpsV2.size, totalRunnerExecsV2: _resV2.size, maxActiveRunnerProfilesPerOwner: _rpMaxActivePerOwner, maxPendingRunnerExecsPerProfile: _rpMaxPendingExecsPerProfile, runnerProfileIdleMs: _rpIdleMs, runnerExecStuckMs: _reStuckMs, profilesByStatus, execsByStatus };
+}

package/src/lib/cross-chain.js

@@ -1012,3 +1012,108 @@ export function getCrossChainStatsV2() {
     configuredChains: _chainConfigs.size,
   };
 }
+
+
+// ===== V2 Surface: Cross-Chain governance overlay (CLI v0.136.0) =====
+export const XCHAIN_CHANNEL_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", DECOMMISSIONED: "decommissioned",
+});
+export const XCHAIN_TRANSFER_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", RELAYING: "relaying", CONFIRMED: "confirmed", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _xcChanTrans = new Map([
+  [XCHAIN_CHANNEL_MATURITY_V2.PENDING, new Set([XCHAIN_CHANNEL_MATURITY_V2.ACTIVE, XCHAIN_CHANNEL_MATURITY_V2.DECOMMISSIONED])],
+  [XCHAIN_CHANNEL_MATURITY_V2.ACTIVE, new Set([XCHAIN_CHANNEL_MATURITY_V2.PAUSED, XCHAIN_CHANNEL_MATURITY_V2.DECOMMISSIONED])],
+  [XCHAIN_CHANNEL_MATURITY_V2.PAUSED, new Set([XCHAIN_CHANNEL_MATURITY_V2.ACTIVE, XCHAIN_CHANNEL_MATURITY_V2.DECOMMISSIONED])],
+  [XCHAIN_CHANNEL_MATURITY_V2.DECOMMISSIONED, new Set()],
+]);
+const _xcChanTerminal = new Set([XCHAIN_CHANNEL_MATURITY_V2.DECOMMISSIONED]);
+const _xcTxTrans = new Map([
+  [XCHAIN_TRANSFER_LIFECYCLE_V2.QUEUED, new Set([XCHAIN_TRANSFER_LIFECYCLE_V2.RELAYING, XCHAIN_TRANSFER_LIFECYCLE_V2.CANCELLED])],
+  [XCHAIN_TRANSFER_LIFECYCLE_V2.RELAYING, new Set([XCHAIN_TRANSFER_LIFECYCLE_V2.CONFIRMED, XCHAIN_TRANSFER_LIFECYCLE_V2.FAILED, XCHAIN_TRANSFER_LIFECYCLE_V2.CANCELLED])],
+  [XCHAIN_TRANSFER_LIFECYCLE_V2.CONFIRMED, new Set()],
+  [XCHAIN_TRANSFER_LIFECYCLE_V2.FAILED, new Set()],
+  [XCHAIN_TRANSFER_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _xcChans = new Map();
+const _xcTxs = new Map();
+let _xcMaxActivePerOwner = 10;
+let _xcMaxPendingPerChan = 20;
+let _xcChanIdleMs = 24 * 60 * 60 * 1000;
+let _xcTxStuckMs = 15 * 60 * 1000;
+
+function _xcPos(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 setMaxActiveXchainChannelsPerOwnerV2(n) { _xcMaxActivePerOwner = _xcPos(n, "maxActiveXchainChannelsPerOwner"); }
+export function getMaxActiveXchainChannelsPerOwnerV2() { return _xcMaxActivePerOwner; }
+export function setMaxPendingXchainTransfersPerChannelV2(n) { _xcMaxPendingPerChan = _xcPos(n, "maxPendingXchainTransfersPerChannel"); }
+export function getMaxPendingXchainTransfersPerChannelV2() { return _xcMaxPendingPerChan; }
+export function setXchainChannelIdleMsV2(n) { _xcChanIdleMs = _xcPos(n, "xchainChannelIdleMs"); }
+export function getXchainChannelIdleMsV2() { return _xcChanIdleMs; }
+export function setXchainTransferStuckMsV2(n) { _xcTxStuckMs = _xcPos(n, "xchainTransferStuckMs"); }
+export function getXchainTransferStuckMsV2() { return _xcTxStuckMs; }
+
+export function _resetStateCrossChainV2() {
+  _xcChans.clear(); _xcTxs.clear();
+  _xcMaxActivePerOwner = 10; _xcMaxPendingPerChan = 20;
+  _xcChanIdleMs = 24 * 60 * 60 * 1000; _xcTxStuckMs = 15 * 60 * 1000;
+}
+
+export function registerXchainChannelV2({ id, owner, fromChain, toChain, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_xcChans.has(id)) throw new Error(`xchain channel ${id} already registered`);
+  const now = Date.now();
+  const c = { id, owner, fromChain: fromChain || "", toChain: toChain || "", status: XCHAIN_CHANNEL_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, decommissionedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _xcChans.set(id, c);
+  return { ...c, metadata: { ...c.metadata } };
+}
+function _xcCheckC(from, to) { const a = _xcChanTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid xchain channel transition ${from} → ${to}`); }
+function _xcCountActive(owner) { let n = 0; for (const c of _xcChans.values()) if (c.owner === owner && c.status === XCHAIN_CHANNEL_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateXchainChannelV2(id) {
+  const c = _xcChans.get(id); if (!c) throw new Error(`xchain channel ${id} not found`);
+  _xcCheckC(c.status, XCHAIN_CHANNEL_MATURITY_V2.ACTIVE);
+  const recovery = c.status === XCHAIN_CHANNEL_MATURITY_V2.PAUSED;
+  if (!recovery) { const a = _xcCountActive(c.owner); if (a >= _xcMaxActivePerOwner) throw new Error(`max active xchain channels per owner (${_xcMaxActivePerOwner}) reached for ${c.owner}`); }
+  const now = Date.now(); c.status = XCHAIN_CHANNEL_MATURITY_V2.ACTIVE; c.updatedAt = now; c.lastTouchedAt = now; if (!c.activatedAt) c.activatedAt = now;
+  return { ...c, metadata: { ...c.metadata } };
+}
+export function pauseXchainChannelV2(id) { const c = _xcChans.get(id); if (!c) throw new Error(`xchain channel ${id} not found`); _xcCheckC(c.status, XCHAIN_CHANNEL_MATURITY_V2.PAUSED); c.status = XCHAIN_CHANNEL_MATURITY_V2.PAUSED; c.updatedAt = Date.now(); return { ...c, metadata: { ...c.metadata } }; }
+export function decommissionXchainChannelV2(id) { const c = _xcChans.get(id); if (!c) throw new Error(`xchain channel ${id} not found`); _xcCheckC(c.status, XCHAIN_CHANNEL_MATURITY_V2.DECOMMISSIONED); const now = Date.now(); c.status = XCHAIN_CHANNEL_MATURITY_V2.DECOMMISSIONED; c.updatedAt = now; if (!c.decommissionedAt) c.decommissionedAt = now; return { ...c, metadata: { ...c.metadata } }; }
+export function touchXchainChannelV2(id) { const c = _xcChans.get(id); if (!c) throw new Error(`xchain channel ${id} not found`); if (_xcChanTerminal.has(c.status)) throw new Error(`cannot touch terminal xchain channel ${id}`); const now = Date.now(); c.lastTouchedAt = now; c.updatedAt = now; return { ...c, metadata: { ...c.metadata } }; }
+export function getXchainChannelV2(id) { const c = _xcChans.get(id); if (!c) return null; return { ...c, metadata: { ...c.metadata } }; }
+export function listXchainChannelsV2() { return [..._xcChans.values()].map((c) => ({ ...c, metadata: { ...c.metadata } })); }
+
+function _xcCountPending(cid) { let n = 0; for (const t of _xcTxs.values()) if (t.channelId === cid && (t.status === XCHAIN_TRANSFER_LIFECYCLE_V2.QUEUED || t.status === XCHAIN_TRANSFER_LIFECYCLE_V2.RELAYING)) n++; return n; }
+
+export function createXchainTransferV2({ id, channelId, amount, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!channelId || typeof channelId !== "string") throw new Error("channelId is required");
+  if (_xcTxs.has(id)) throw new Error(`xchain transfer ${id} already exists`);
+  if (!_xcChans.has(channelId)) throw new Error(`xchain channel ${channelId} not found`);
+  const pending = _xcCountPending(channelId);
+  if (pending >= _xcMaxPendingPerChan) throw new Error(`max pending xchain transfers per channel (${_xcMaxPendingPerChan}) reached for ${channelId}`);
+  const now = Date.now();
+  const t = { id, channelId, amount: amount || "0", status: XCHAIN_TRANSFER_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _xcTxs.set(id, t);
+  return { ...t, metadata: { ...t.metadata } };
+}
+function _xcCheckT(from, to) { const a = _xcTxTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid xchain transfer transition ${from} → ${to}`); }
+export function startXchainTransferV2(id) { const t = _xcTxs.get(id); if (!t) throw new Error(`xchain transfer ${id} not found`); _xcCheckT(t.status, XCHAIN_TRANSFER_LIFECYCLE_V2.RELAYING); const now = Date.now(); t.status = XCHAIN_TRANSFER_LIFECYCLE_V2.RELAYING; t.updatedAt = now; if (!t.startedAt) t.startedAt = now; return { ...t, metadata: { ...t.metadata } }; }
+export function confirmXchainTransferV2(id) { const t = _xcTxs.get(id); if (!t) throw new Error(`xchain transfer ${id} not found`); _xcCheckT(t.status, XCHAIN_TRANSFER_LIFECYCLE_V2.CONFIRMED); const now = Date.now(); t.status = XCHAIN_TRANSFER_LIFECYCLE_V2.CONFIRMED; t.updatedAt = now; if (!t.settledAt) t.settledAt = now; return { ...t, metadata: { ...t.metadata } }; }
+export function failXchainTransferV2(id, reason) { const t = _xcTxs.get(id); if (!t) throw new Error(`xchain transfer ${id} not found`); _xcCheckT(t.status, XCHAIN_TRANSFER_LIFECYCLE_V2.FAILED); const now = Date.now(); t.status = XCHAIN_TRANSFER_LIFECYCLE_V2.FAILED; t.updatedAt = now; if (!t.settledAt) t.settledAt = now; if (reason) t.metadata.failReason = String(reason); return { ...t, metadata: { ...t.metadata } }; }
+export function cancelXchainTransferV2(id, reason) { const t = _xcTxs.get(id); if (!t) throw new Error(`xchain transfer ${id} not found`); _xcCheckT(t.status, XCHAIN_TRANSFER_LIFECYCLE_V2.CANCELLED); const now = Date.now(); t.status = XCHAIN_TRANSFER_LIFECYCLE_V2.CANCELLED; t.updatedAt = now; if (!t.settledAt) t.settledAt = now; if (reason) t.metadata.cancelReason = String(reason); return { ...t, metadata: { ...t.metadata } }; }
+export function getXchainTransferV2(id) { const t = _xcTxs.get(id); if (!t) return null; return { ...t, metadata: { ...t.metadata } }; }
+export function listXchainTransfersV2() { return [..._xcTxs.values()].map((t) => ({ ...t, metadata: { ...t.metadata } })); }
+
+export function autoPauseIdleXchainChannelsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const c of _xcChans.values()) if (c.status === XCHAIN_CHANNEL_MATURITY_V2.ACTIVE && (t - c.lastTouchedAt) >= _xcChanIdleMs) { c.status = XCHAIN_CHANNEL_MATURITY_V2.PAUSED; c.updatedAt = t; flipped.push(c.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckXchainTransfersV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const tx of _xcTxs.values()) if (tx.status === XCHAIN_TRANSFER_LIFECYCLE_V2.RELAYING && tx.startedAt != null && (t - tx.startedAt) >= _xcTxStuckMs) { tx.status = XCHAIN_TRANSFER_LIFECYCLE_V2.FAILED; tx.updatedAt = t; if (!tx.settledAt) tx.settledAt = t; tx.metadata.failReason = "auto-fail-stuck"; flipped.push(tx.id); } return { flipped, count: flipped.length }; }
+
+export function getCrossChainGovStatsV2() {
+  const channelsByStatus = {}; for (const s of Object.values(XCHAIN_CHANNEL_MATURITY_V2)) channelsByStatus[s] = 0; for (const c of _xcChans.values()) channelsByStatus[c.status]++;
+  const transfersByStatus = {}; for (const s of Object.values(XCHAIN_TRANSFER_LIFECYCLE_V2)) transfersByStatus[s] = 0; for (const t of _xcTxs.values()) transfersByStatus[t.status]++;
+  return { totalChannelsV2: _xcChans.size, totalTransfersV2: _xcTxs.size, maxActiveXchainChannelsPerOwner: _xcMaxActivePerOwner, maxPendingXchainTransfersPerChannel: _xcMaxPendingPerChan, xchainChannelIdleMs: _xcChanIdleMs, xchainTransferStuckMs: _xcTxStuckMs, channelsByStatus, transfersByStatus };
+}

package/src/lib/dao-governance.js

@@ -863,3 +863,108 @@ export function _resetState() {
     maxSingleAllocation: 100000,
   };
 }
+
+
+// ===== V2 Surface: DAO Governance overlay (CLI v0.136.0) =====
+export const DAO_ORG_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", DISSOLVED: "dissolved",
+});
+export const DAO_PROPOSAL_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", VOTING: "voting", PASSED: "passed", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _daoOrgTrans = new Map([
+  [DAO_ORG_MATURITY_V2.PENDING, new Set([DAO_ORG_MATURITY_V2.ACTIVE, DAO_ORG_MATURITY_V2.DISSOLVED])],
+  [DAO_ORG_MATURITY_V2.ACTIVE, new Set([DAO_ORG_MATURITY_V2.PAUSED, DAO_ORG_MATURITY_V2.DISSOLVED])],
+  [DAO_ORG_MATURITY_V2.PAUSED, new Set([DAO_ORG_MATURITY_V2.ACTIVE, DAO_ORG_MATURITY_V2.DISSOLVED])],
+  [DAO_ORG_MATURITY_V2.DISSOLVED, new Set()],
+]);
+const _daoOrgTerminal = new Set([DAO_ORG_MATURITY_V2.DISSOLVED]);
+const _daoPropTrans = new Map([
+  [DAO_PROPOSAL_LIFECYCLE_V2.QUEUED, new Set([DAO_PROPOSAL_LIFECYCLE_V2.VOTING, DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED])],
+  [DAO_PROPOSAL_LIFECYCLE_V2.VOTING, new Set([DAO_PROPOSAL_LIFECYCLE_V2.PASSED, DAO_PROPOSAL_LIFECYCLE_V2.FAILED, DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED])],
+  [DAO_PROPOSAL_LIFECYCLE_V2.PASSED, new Set()],
+  [DAO_PROPOSAL_LIFECYCLE_V2.FAILED, new Set()],
+  [DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _daoOrgs = new Map();
+const _daoProps = new Map();
+let _daoMaxActivePerOwner = 8;
+let _daoMaxPendingPerOrg = 50;
+let _daoOrgIdleMs = 7 * 24 * 60 * 60 * 1000;
+let _daoPropStuckMs = 2 * 60 * 1000;
+
+function _daoPos(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 setMaxActiveDaoOrgsPerOwnerV2(n) { _daoMaxActivePerOwner = _daoPos(n, "maxActiveDaoOrgsPerOwner"); }
+export function getMaxActiveDaoOrgsPerOwnerV2() { return _daoMaxActivePerOwner; }
+export function setMaxPendingDaoProposalsPerOrgV2(n) { _daoMaxPendingPerOrg = _daoPos(n, "maxPendingDaoProposalsPerOrg"); }
+export function getMaxPendingDaoProposalsPerOrgV2() { return _daoMaxPendingPerOrg; }
+export function setDaoOrgIdleMsV2(n) { _daoOrgIdleMs = _daoPos(n, "daoOrgIdleMs"); }
+export function getDaoOrgIdleMsV2() { return _daoOrgIdleMs; }
+export function setDaoProposalStuckMsV2(n) { _daoPropStuckMs = _daoPos(n, "daoProposalStuckMs"); }
+export function getDaoProposalStuckMsV2() { return _daoPropStuckMs; }
+
+export function _resetStateDaoGovernanceV2() {
+  _daoOrgs.clear(); _daoProps.clear();
+  _daoMaxActivePerOwner = 8; _daoMaxPendingPerOrg = 50;
+  _daoOrgIdleMs = 7 * 24 * 60 * 60 * 1000; _daoPropStuckMs = 2 * 60 * 1000;
+}
+
+export function registerDaoOrgV2({ 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 (_daoOrgs.has(id)) throw new Error(`dao org ${id} already registered`);
+  const now = Date.now();
+  const o = { id, owner, name: name || id, status: DAO_ORG_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, dissolvedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _daoOrgs.set(id, o);
+  return { ...o, metadata: { ...o.metadata } };
+}
+function _daoCheckO(from, to) { const a = _daoOrgTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid dao org transition ${from} → ${to}`); }
+function _daoCountActive(owner) { let n = 0; for (const o of _daoOrgs.values()) if (o.owner === owner && o.status === DAO_ORG_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateDaoOrgV2(id) {
+  const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`);
+  _daoCheckO(o.status, DAO_ORG_MATURITY_V2.ACTIVE);
+  const recovery = o.status === DAO_ORG_MATURITY_V2.PAUSED;
+  if (!recovery) { const a = _daoCountActive(o.owner); if (a >= _daoMaxActivePerOwner) throw new Error(`max active dao orgs per owner (${_daoMaxActivePerOwner}) reached for ${o.owner}`); }
+  const now = Date.now(); o.status = DAO_ORG_MATURITY_V2.ACTIVE; o.updatedAt = now; o.lastTouchedAt = now; if (!o.activatedAt) o.activatedAt = now;
+  return { ...o, metadata: { ...o.metadata } };
+}
+export function pauseDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`); _daoCheckO(o.status, DAO_ORG_MATURITY_V2.PAUSED); o.status = DAO_ORG_MATURITY_V2.PAUSED; o.updatedAt = Date.now(); return { ...o, metadata: { ...o.metadata } }; }
+export function dissolveDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`); _daoCheckO(o.status, DAO_ORG_MATURITY_V2.DISSOLVED); const now = Date.now(); o.status = DAO_ORG_MATURITY_V2.DISSOLVED; o.updatedAt = now; if (!o.dissolvedAt) o.dissolvedAt = now; return { ...o, metadata: { ...o.metadata } }; }
+export function touchDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) throw new Error(`dao org ${id} not found`); if (_daoOrgTerminal.has(o.status)) throw new Error(`cannot touch terminal dao org ${id}`); const now = Date.now(); o.lastTouchedAt = now; o.updatedAt = now; return { ...o, metadata: { ...o.metadata } }; }
+export function getDaoOrgV2(id) { const o = _daoOrgs.get(id); if (!o) return null; return { ...o, metadata: { ...o.metadata } }; }
+export function listDaoOrgsV2() { return [..._daoOrgs.values()].map((o) => ({ ...o, metadata: { ...o.metadata } })); }
+
+function _daoCountPending(oid) { let n = 0; for (const p of _daoProps.values()) if (p.orgId === oid && (p.status === DAO_PROPOSAL_LIFECYCLE_V2.QUEUED || p.status === DAO_PROPOSAL_LIFECYCLE_V2.VOTING)) n++; return n; }
+
+export function createDaoProposalV2({ id, orgId, title, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!orgId || typeof orgId !== "string") throw new Error("orgId is required");
+  if (_daoProps.has(id)) throw new Error(`dao proposal ${id} already exists`);
+  if (!_daoOrgs.has(orgId)) throw new Error(`dao org ${orgId} not found`);
+  const pending = _daoCountPending(orgId);
+  if (pending >= _daoMaxPendingPerOrg) throw new Error(`max pending dao proposals per org (${_daoMaxPendingPerOrg}) reached for ${orgId}`);
+  const now = Date.now();
+  const p = { id, orgId, title: title || id, status: DAO_PROPOSAL_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _daoProps.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+function _daoCheckP(from, to) { const a = _daoPropTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid dao proposal transition ${from} → ${to}`); }
+export function startDaoProposalV2(id) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.VOTING); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.VOTING; p.updatedAt = now; if (!p.startedAt) p.startedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function passDaoProposalV2(id) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.PASSED); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.PASSED; p.updatedAt = now; if (!p.settledAt) p.settledAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function failDaoProposalV2(id, reason) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.FAILED); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.FAILED; p.updatedAt = now; if (!p.settledAt) p.settledAt = now; if (reason) p.metadata.failReason = String(reason); return { ...p, metadata: { ...p.metadata } }; }
+export function cancelDaoProposalV2(id, reason) { const p = _daoProps.get(id); if (!p) throw new Error(`dao proposal ${id} not found`); _daoCheckP(p.status, DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED); const now = Date.now(); p.status = DAO_PROPOSAL_LIFECYCLE_V2.CANCELLED; p.updatedAt = now; if (!p.settledAt) p.settledAt = now; if (reason) p.metadata.cancelReason = String(reason); return { ...p, metadata: { ...p.metadata } }; }
+export function getDaoProposalV2(id) { const p = _daoProps.get(id); if (!p) return null; return { ...p, metadata: { ...p.metadata } }; }
+export function listDaoProposalsV2() { return [..._daoProps.values()].map((p) => ({ ...p, metadata: { ...p.metadata } })); }
+
+export function autoPauseIdleDaoOrgsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const o of _daoOrgs.values()) if (o.status === DAO_ORG_MATURITY_V2.ACTIVE && (t - o.lastTouchedAt) >= _daoOrgIdleMs) { o.status = DAO_ORG_MATURITY_V2.PAUSED; o.updatedAt = t; flipped.push(o.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckDaoProposalsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const p of _daoProps.values()) if (p.status === DAO_PROPOSAL_LIFECYCLE_V2.VOTING && p.startedAt != null && (t - p.startedAt) >= _daoPropStuckMs) { p.status = DAO_PROPOSAL_LIFECYCLE_V2.FAILED; p.updatedAt = t; if (!p.settledAt) p.settledAt = t; p.metadata.failReason = "auto-fail-stuck"; flipped.push(p.id); } return { flipped, count: flipped.length }; }
+
+export function getDaoGovernanceGovStatsV2() {
+  const orgsByStatus = {}; for (const s of Object.values(DAO_ORG_MATURITY_V2)) orgsByStatus[s] = 0; for (const o of _daoOrgs.values()) orgsByStatus[o.status]++;
+  const proposalsByStatus = {}; for (const s of Object.values(DAO_PROPOSAL_LIFECYCLE_V2)) proposalsByStatus[s] = 0; for (const p of _daoProps.values()) proposalsByStatus[p.status]++;
+  return { totalOrgsV2: _daoOrgs.size, totalProposalsV2: _daoProps.size, maxActiveDaoOrgsPerOwner: _daoMaxActivePerOwner, maxPendingDaoProposalsPerOrg: _daoMaxPendingPerOrg, daoOrgIdleMs: _daoOrgIdleMs, daoProposalStuckMs: _daoPropStuckMs, orgsByStatus, proposalsByStatus };
+}

package/src/lib/dlp-engine.js

@@ -691,3 +691,108 @@ export function getHighestUnresolvedSeverity() {
 }
 
 export { _v2PolicyMeta, _v2IncidentMeta, _builtinPolicyTemplates };
+
+
+// ===== V2 Surface: DLP Engine governance overlay (CLI v0.135.0) =====
+export const DLP_POLICY_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", SUSPENDED: "suspended", RETIRED: "retired",
+});
+export const DLP_SCAN_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", SCANNING: "scanning", COMPLETED: "completed", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _dlpPolTrans = new Map([
+  [DLP_POLICY_MATURITY_V2.PENDING, new Set([DLP_POLICY_MATURITY_V2.ACTIVE, DLP_POLICY_MATURITY_V2.RETIRED])],
+  [DLP_POLICY_MATURITY_V2.ACTIVE, new Set([DLP_POLICY_MATURITY_V2.SUSPENDED, DLP_POLICY_MATURITY_V2.RETIRED])],
+  [DLP_POLICY_MATURITY_V2.SUSPENDED, new Set([DLP_POLICY_MATURITY_V2.ACTIVE, DLP_POLICY_MATURITY_V2.RETIRED])],
+  [DLP_POLICY_MATURITY_V2.RETIRED, new Set()],
+]);
+const _dlpPolTerminal = new Set([DLP_POLICY_MATURITY_V2.RETIRED]);
+const _dlpScanTrans = new Map([
+  [DLP_SCAN_LIFECYCLE_V2.QUEUED, new Set([DLP_SCAN_LIFECYCLE_V2.SCANNING, DLP_SCAN_LIFECYCLE_V2.CANCELLED])],
+  [DLP_SCAN_LIFECYCLE_V2.SCANNING, new Set([DLP_SCAN_LIFECYCLE_V2.COMPLETED, DLP_SCAN_LIFECYCLE_V2.FAILED, DLP_SCAN_LIFECYCLE_V2.CANCELLED])],
+  [DLP_SCAN_LIFECYCLE_V2.COMPLETED, new Set()],
+  [DLP_SCAN_LIFECYCLE_V2.FAILED, new Set()],
+  [DLP_SCAN_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _dlpPols = new Map();
+const _dlpScans = new Map();
+let _dlpMaxActivePerOwner = 16;
+let _dlpMaxPendingPerPol = 20;
+let _dlpPolIdleMs = 12 * 60 * 60 * 1000;
+let _dlpScanStuckMs = 5 * 60 * 1000;
+
+function _dlpPos(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 setMaxActiveDlpPoliciesPerOwnerV2(n) { _dlpMaxActivePerOwner = _dlpPos(n, "maxActiveDlpPoliciesPerOwner"); }
+export function getMaxActiveDlpPoliciesPerOwnerV2() { return _dlpMaxActivePerOwner; }
+export function setMaxPendingDlpScansPerPolicyV2(n) { _dlpMaxPendingPerPol = _dlpPos(n, "maxPendingDlpScansPerPolicy"); }
+export function getMaxPendingDlpScansPerPolicyV2() { return _dlpMaxPendingPerPol; }
+export function setDlpPolicyIdleMsV2(n) { _dlpPolIdleMs = _dlpPos(n, "dlpPolicyIdleMs"); }
+export function getDlpPolicyIdleMsV2() { return _dlpPolIdleMs; }
+export function setDlpScanStuckMsV2(n) { _dlpScanStuckMs = _dlpPos(n, "dlpScanStuckMs"); }
+export function getDlpScanStuckMsV2() { return _dlpScanStuckMs; }
+
+export function _resetStateDlpEngineV2() {
+  _dlpPols.clear(); _dlpScans.clear();
+  _dlpMaxActivePerOwner = 16; _dlpMaxPendingPerPol = 20;
+  _dlpPolIdleMs = 12 * 60 * 60 * 1000; _dlpScanStuckMs = 5 * 60 * 1000;
+}
+
+export function registerDlpPolicyV2({ id, owner, classification, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_dlpPols.has(id)) throw new Error(`dlp policy ${id} already registered`);
+  const now = Date.now();
+  const p = { id, owner, classification: classification || "internal", status: DLP_POLICY_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, retiredAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _dlpPols.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+function _dlpCheckP(from, to) { const a = _dlpPolTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid dlp policy transition ${from} → ${to}`); }
+function _dlpCountActive(owner) { let n = 0; for (const p of _dlpPols.values()) if (p.owner === owner && p.status === DLP_POLICY_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateDlpPolicyV2(id) {
+  const p = _dlpPols.get(id); if (!p) throw new Error(`dlp policy ${id} not found`);
+  _dlpCheckP(p.status, DLP_POLICY_MATURITY_V2.ACTIVE);
+  const recovery = p.status === DLP_POLICY_MATURITY_V2.SUSPENDED;
+  if (!recovery) { const a = _dlpCountActive(p.owner); if (a >= _dlpMaxActivePerOwner) throw new Error(`max active dlp policies per owner (${_dlpMaxActivePerOwner}) reached for ${p.owner}`); }
+  const now = Date.now(); p.status = DLP_POLICY_MATURITY_V2.ACTIVE; p.updatedAt = now; p.lastTouchedAt = now; if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function suspendDlpPolicyV2(id) { const p = _dlpPols.get(id); if (!p) throw new Error(`dlp policy ${id} not found`); _dlpCheckP(p.status, DLP_POLICY_MATURITY_V2.SUSPENDED); p.status = DLP_POLICY_MATURITY_V2.SUSPENDED; p.updatedAt = Date.now(); return { ...p, metadata: { ...p.metadata } }; }
+export function retireDlpPolicyV2(id) { const p = _dlpPols.get(id); if (!p) throw new Error(`dlp policy ${id} not found`); _dlpCheckP(p.status, DLP_POLICY_MATURITY_V2.RETIRED); const now = Date.now(); p.status = DLP_POLICY_MATURITY_V2.RETIRED; p.updatedAt = now; if (!p.retiredAt) p.retiredAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function touchDlpPolicyV2(id) { const p = _dlpPols.get(id); if (!p) throw new Error(`dlp policy ${id} not found`); if (_dlpPolTerminal.has(p.status)) throw new Error(`cannot touch terminal dlp policy ${id}`); const now = Date.now(); p.lastTouchedAt = now; p.updatedAt = now; return { ...p, metadata: { ...p.metadata } }; }
+export function getDlpPolicyV2(id) { const p = _dlpPols.get(id); if (!p) return null; return { ...p, metadata: { ...p.metadata } }; }
+export function listDlpPoliciesV2() { return [..._dlpPols.values()].map((p) => ({ ...p, metadata: { ...p.metadata } })); }
+
+function _dlpCountPending(pid) { let n = 0; for (const s of _dlpScans.values()) if (s.policyId === pid && (s.status === DLP_SCAN_LIFECYCLE_V2.QUEUED || s.status === DLP_SCAN_LIFECYCLE_V2.SCANNING)) n++; return n; }
+
+export function createDlpScanV2({ id, policyId, target, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!policyId || typeof policyId !== "string") throw new Error("policyId is required");
+  if (_dlpScans.has(id)) throw new Error(`dlp scan ${id} already exists`);
+  if (!_dlpPols.has(policyId)) throw new Error(`dlp policy ${policyId} not found`);
+  const pending = _dlpCountPending(policyId);
+  if (pending >= _dlpMaxPendingPerPol) throw new Error(`max pending dlp scans per policy (${_dlpMaxPendingPerPol}) reached for ${policyId}`);
+  const now = Date.now();
+  const s = { id, policyId, target: target || "", status: DLP_SCAN_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _dlpScans.set(id, s);
+  return { ...s, metadata: { ...s.metadata } };
+}
+function _dlpCheckS(from, to) { const a = _dlpScanTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid dlp scan transition ${from} → ${to}`); }
+export function startDlpScanV2(id) { const s = _dlpScans.get(id); if (!s) throw new Error(`dlp scan ${id} not found`); _dlpCheckS(s.status, DLP_SCAN_LIFECYCLE_V2.SCANNING); const now = Date.now(); s.status = DLP_SCAN_LIFECYCLE_V2.SCANNING; s.updatedAt = now; if (!s.startedAt) s.startedAt = now; return { ...s, metadata: { ...s.metadata } }; }
+export function completeDlpScanV2(id) { const s = _dlpScans.get(id); if (!s) throw new Error(`dlp scan ${id} not found`); _dlpCheckS(s.status, DLP_SCAN_LIFECYCLE_V2.COMPLETED); const now = Date.now(); s.status = DLP_SCAN_LIFECYCLE_V2.COMPLETED; s.updatedAt = now; if (!s.settledAt) s.settledAt = now; return { ...s, metadata: { ...s.metadata } }; }
+export function failDlpScanV2(id, reason) { const s = _dlpScans.get(id); if (!s) throw new Error(`dlp scan ${id} not found`); _dlpCheckS(s.status, DLP_SCAN_LIFECYCLE_V2.FAILED); const now = Date.now(); s.status = DLP_SCAN_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 cancelDlpScanV2(id, reason) { const s = _dlpScans.get(id); if (!s) throw new Error(`dlp scan ${id} not found`); _dlpCheckS(s.status, DLP_SCAN_LIFECYCLE_V2.CANCELLED); const now = Date.now(); s.status = DLP_SCAN_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 getDlpScanV2(id) { const s = _dlpScans.get(id); if (!s) return null; return { ...s, metadata: { ...s.metadata } }; }
+export function listDlpScansV2() { return [..._dlpScans.values()].map((s) => ({ ...s, metadata: { ...s.metadata } })); }
+
+export function autoSuspendIdleDlpPoliciesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const p of _dlpPols.values()) if (p.status === DLP_POLICY_MATURITY_V2.ACTIVE && (t - p.lastTouchedAt) >= _dlpPolIdleMs) { p.status = DLP_POLICY_MATURITY_V2.SUSPENDED; p.updatedAt = t; flipped.push(p.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckDlpScansV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const s of _dlpScans.values()) if (s.status === DLP_SCAN_LIFECYCLE_V2.SCANNING && s.startedAt != null && (t - s.startedAt) >= _dlpScanStuckMs) { s.status = DLP_SCAN_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 getDlpEngineStatsV2() {
+  const policiesByStatus = {}; for (const s of Object.values(DLP_POLICY_MATURITY_V2)) policiesByStatus[s] = 0; for (const p of _dlpPols.values()) policiesByStatus[p.status]++;
+  const scansByStatus = {}; for (const s of Object.values(DLP_SCAN_LIFECYCLE_V2)) scansByStatus[s] = 0; for (const sc of _dlpScans.values()) scansByStatus[sc.status]++;
+  return { totalPoliciesV2: _dlpPols.size, totalScansV2: _dlpScans.size, maxActiveDlpPoliciesPerOwner: _dlpMaxActivePerOwner, maxPendingDlpScansPerPolicy: _dlpMaxPendingPerPol, dlpPolicyIdleMs: _dlpPolIdleMs, dlpScanStuckMs: _dlpScanStuckMs, policiesByStatus, scansByStatus };
+}

package/src/lib/evolution-system.js

@@ -959,3 +959,108 @@ export function _resetV2State() {
   _v2Config.predictionHorizonMs = 86400000;
   _v2Config.growthLogRetentionDays = 365;
 }
+
+
+// ===== V2 Surface: Evolution System governance overlay (CLI v0.137.0) =====
+export const EVO_GOAL_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", PAUSED: "paused", ARCHIVED: "archived",
+});
+export const EVO_CYCLE_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", RUNNING: "running", COMPLETED: "completed", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _evoGoalTrans = new Map([
+  [EVO_GOAL_MATURITY_V2.PENDING, new Set([EVO_GOAL_MATURITY_V2.ACTIVE, EVO_GOAL_MATURITY_V2.ARCHIVED])],
+  [EVO_GOAL_MATURITY_V2.ACTIVE, new Set([EVO_GOAL_MATURITY_V2.PAUSED, EVO_GOAL_MATURITY_V2.ARCHIVED])],
+  [EVO_GOAL_MATURITY_V2.PAUSED, new Set([EVO_GOAL_MATURITY_V2.ACTIVE, EVO_GOAL_MATURITY_V2.ARCHIVED])],
+  [EVO_GOAL_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _evoGoalTerminal = new Set([EVO_GOAL_MATURITY_V2.ARCHIVED]);
+const _evoCycleTrans = new Map([
+  [EVO_CYCLE_LIFECYCLE_V2.QUEUED, new Set([EVO_CYCLE_LIFECYCLE_V2.RUNNING, EVO_CYCLE_LIFECYCLE_V2.CANCELLED])],
+  [EVO_CYCLE_LIFECYCLE_V2.RUNNING, new Set([EVO_CYCLE_LIFECYCLE_V2.COMPLETED, EVO_CYCLE_LIFECYCLE_V2.FAILED, EVO_CYCLE_LIFECYCLE_V2.CANCELLED])],
+  [EVO_CYCLE_LIFECYCLE_V2.COMPLETED, new Set()],
+  [EVO_CYCLE_LIFECYCLE_V2.FAILED, new Set()],
+  [EVO_CYCLE_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _evoGoals = new Map();
+const _evoCycles = new Map();
+let _evoMaxActivePerOwner = 6;
+let _evoMaxPendingPerGoal = 12;
+let _evoGoalIdleMs = 14 * 24 * 60 * 60 * 1000;
+let _evoCycleStuckMs = 10 * 60 * 1000;
+
+function _evoPos(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 setMaxActiveEvoGoalsPerOwnerV2(n) { _evoMaxActivePerOwner = _evoPos(n, "maxActiveEvoGoalsPerOwner"); }
+export function getMaxActiveEvoGoalsPerOwnerV2() { return _evoMaxActivePerOwner; }
+export function setMaxPendingEvoCyclesPerGoalV2(n) { _evoMaxPendingPerGoal = _evoPos(n, "maxPendingEvoCyclesPerGoal"); }
+export function getMaxPendingEvoCyclesPerGoalV2() { return _evoMaxPendingPerGoal; }
+export function setEvoGoalIdleMsV2(n) { _evoGoalIdleMs = _evoPos(n, "evoGoalIdleMs"); }
+export function getEvoGoalIdleMsV2() { return _evoGoalIdleMs; }
+export function setEvoCycleStuckMsV2(n) { _evoCycleStuckMs = _evoPos(n, "evoCycleStuckMs"); }
+export function getEvoCycleStuckMsV2() { return _evoCycleStuckMs; }
+
+export function _resetStateEvolutionSystemV2() {
+  _evoGoals.clear(); _evoCycles.clear();
+  _evoMaxActivePerOwner = 6; _evoMaxPendingPerGoal = 12;
+  _evoGoalIdleMs = 14 * 24 * 60 * 60 * 1000; _evoCycleStuckMs = 10 * 60 * 1000;
+}
+
+export function registerEvoGoalV2({ id, owner, objective, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_evoGoals.has(id)) throw new Error(`evo goal ${id} already registered`);
+  const now = Date.now();
+  const g = { id, owner, objective: objective || "", status: EVO_GOAL_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, archivedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _evoGoals.set(id, g);
+  return { ...g, metadata: { ...g.metadata } };
+}
+function _evoCheckG(from, to) { const a = _evoGoalTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid evo goal transition ${from} → ${to}`); }
+function _evoCountActive(owner) { let n = 0; for (const g of _evoGoals.values()) if (g.owner === owner && g.status === EVO_GOAL_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateEvoGoalV2(id) {
+  const g = _evoGoals.get(id); if (!g) throw new Error(`evo goal ${id} not found`);
+  _evoCheckG(g.status, EVO_GOAL_MATURITY_V2.ACTIVE);
+  const recovery = g.status === EVO_GOAL_MATURITY_V2.PAUSED;
+  if (!recovery) { const a = _evoCountActive(g.owner); if (a >= _evoMaxActivePerOwner) throw new Error(`max active evo goals per owner (${_evoMaxActivePerOwner}) reached for ${g.owner}`); }
+  const now = Date.now(); g.status = EVO_GOAL_MATURITY_V2.ACTIVE; g.updatedAt = now; g.lastTouchedAt = now; if (!g.activatedAt) g.activatedAt = now;
+  return { ...g, metadata: { ...g.metadata } };
+}
+export function pauseEvoGoalV2(id) { const g = _evoGoals.get(id); if (!g) throw new Error(`evo goal ${id} not found`); _evoCheckG(g.status, EVO_GOAL_MATURITY_V2.PAUSED); g.status = EVO_GOAL_MATURITY_V2.PAUSED; g.updatedAt = Date.now(); return { ...g, metadata: { ...g.metadata } }; }
+export function archiveEvoGoalV2(id) { const g = _evoGoals.get(id); if (!g) throw new Error(`evo goal ${id} not found`); _evoCheckG(g.status, EVO_GOAL_MATURITY_V2.ARCHIVED); const now = Date.now(); g.status = EVO_GOAL_MATURITY_V2.ARCHIVED; g.updatedAt = now; if (!g.archivedAt) g.archivedAt = now; return { ...g, metadata: { ...g.metadata } }; }
+export function touchEvoGoalV2(id) { const g = _evoGoals.get(id); if (!g) throw new Error(`evo goal ${id} not found`); if (_evoGoalTerminal.has(g.status)) throw new Error(`cannot touch terminal evo goal ${id}`); const now = Date.now(); g.lastTouchedAt = now; g.updatedAt = now; return { ...g, metadata: { ...g.metadata } }; }
+export function getEvoGoalV2(id) { const g = _evoGoals.get(id); if (!g) return null; return { ...g, metadata: { ...g.metadata } }; }
+export function listEvoGoalsV2() { return [..._evoGoals.values()].map((g) => ({ ...g, metadata: { ...g.metadata } })); }
+
+function _evoCountPending(gid) { let n = 0; for (const c of _evoCycles.values()) if (c.goalId === gid && (c.status === EVO_CYCLE_LIFECYCLE_V2.QUEUED || c.status === EVO_CYCLE_LIFECYCLE_V2.RUNNING)) n++; return n; }
+
+export function createEvoCycleV2({ id, goalId, generation, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!goalId || typeof goalId !== "string") throw new Error("goalId is required");
+  if (_evoCycles.has(id)) throw new Error(`evo cycle ${id} already exists`);
+  if (!_evoGoals.has(goalId)) throw new Error(`evo goal ${goalId} not found`);
+  const pending = _evoCountPending(goalId);
+  if (pending >= _evoMaxPendingPerGoal) throw new Error(`max pending evo cycles per goal (${_evoMaxPendingPerGoal}) reached for ${goalId}`);
+  const now = Date.now();
+  const c = { id, goalId, generation: generation ?? 0, status: EVO_CYCLE_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _evoCycles.set(id, c);
+  return { ...c, metadata: { ...c.metadata } };
+}
+function _evoCheckC(from, to) { const a = _evoCycleTrans.get(from); if (!a || !a.has(to)) throw new Error(`invalid evo cycle transition ${from} → ${to}`); }
+export function startEvoCycleV2(id) { const c = _evoCycles.get(id); if (!c) throw new Error(`evo cycle ${id} not found`); _evoCheckC(c.status, EVO_CYCLE_LIFECYCLE_V2.RUNNING); const now = Date.now(); c.status = EVO_CYCLE_LIFECYCLE_V2.RUNNING; c.updatedAt = now; if (!c.startedAt) c.startedAt = now; return { ...c, metadata: { ...c.metadata } }; }
+export function completeEvoCycleV2(id) { const c = _evoCycles.get(id); if (!c) throw new Error(`evo cycle ${id} not found`); _evoCheckC(c.status, EVO_CYCLE_LIFECYCLE_V2.COMPLETED); const now = Date.now(); c.status = EVO_CYCLE_LIFECYCLE_V2.COMPLETED; c.updatedAt = now; if (!c.settledAt) c.settledAt = now; return { ...c, metadata: { ...c.metadata } }; }
+export function failEvoCycleV2(id, reason) { const c = _evoCycles.get(id); if (!c) throw new Error(`evo cycle ${id} not found`); _evoCheckC(c.status, EVO_CYCLE_LIFECYCLE_V2.FAILED); const now = Date.now(); c.status = EVO_CYCLE_LIFECYCLE_V2.FAILED; c.updatedAt = now; if (!c.settledAt) c.settledAt = now; if (reason) c.metadata.failReason = String(reason); return { ...c, metadata: { ...c.metadata } }; }
+export function cancelEvoCycleV2(id, reason) { const c = _evoCycles.get(id); if (!c) throw new Error(`evo cycle ${id} not found`); _evoCheckC(c.status, EVO_CYCLE_LIFECYCLE_V2.CANCELLED); const now = Date.now(); c.status = EVO_CYCLE_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 getEvoCycleV2(id) { const c = _evoCycles.get(id); if (!c) return null; return { ...c, metadata: { ...c.metadata } }; }
+export function listEvoCyclesV2() { return [..._evoCycles.values()].map((c) => ({ ...c, metadata: { ...c.metadata } })); }
+
+export function autoPauseIdleEvoGoalsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const g of _evoGoals.values()) if (g.status === EVO_GOAL_MATURITY_V2.ACTIVE && (t - g.lastTouchedAt) >= _evoGoalIdleMs) { g.status = EVO_GOAL_MATURITY_V2.PAUSED; g.updatedAt = t; flipped.push(g.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckEvoCyclesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const c of _evoCycles.values()) if (c.status === EVO_CYCLE_LIFECYCLE_V2.RUNNING && c.startedAt != null && (t - c.startedAt) >= _evoCycleStuckMs) { c.status = EVO_CYCLE_LIFECYCLE_V2.FAILED; c.updatedAt = t; if (!c.settledAt) c.settledAt = t; c.metadata.failReason = "auto-fail-stuck"; flipped.push(c.id); } return { flipped, count: flipped.length }; }
+
+export function getEvolutionSystemGovStatsV2() {
+  const goalsByStatus = {}; for (const s of Object.values(EVO_GOAL_MATURITY_V2)) goalsByStatus[s] = 0; for (const g of _evoGoals.values()) goalsByStatus[g.status]++;
+  const cyclesByStatus = {}; for (const s of Object.values(EVO_CYCLE_LIFECYCLE_V2)) cyclesByStatus[s] = 0; for (const c of _evoCycles.values()) cyclesByStatus[c.status]++;
+  return { totalGoalsV2: _evoGoals.size, totalCyclesV2: _evoCycles.size, maxActiveEvoGoalsPerOwner: _evoMaxActivePerOwner, maxPendingEvoCyclesPerGoal: _evoMaxPendingPerGoal, evoGoalIdleMs: _evoGoalIdleMs, evoCycleStuckMs: _evoCycleStuckMs, goalsByStatus, cyclesByStatus };
+}