chainlesschain 0.132.0 → 0.145.0

package/src/lib/cross-chain.js

@@ -1012,3 +1012,368 @@ 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,342 @@ 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,
+  };
+}