chainlesschain 0.81.0 → 0.143.0

package/src/lib/threat-intel.js

@@ -266,3 +266,338 @@ export function clearAll(db) {
   const info = db.prepare(`DELETE FROM threat_intel_indicators`).run();
   return info.changes;
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — In-memory feed-maturity + indicator-lifecycle layer.
+ * Independent of the SQLite IoC catalog above; tracks feed sources
+ * and indicator lifecycle transitions with caps and auto-flip.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const FEED_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  TRUSTED: "trusted",
+  DEPRECATED: "deprecated",
+  RETIRED: "retired",
+});
+
+export const INDICATOR_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  EXPIRED: "expired",
+  REVOKED: "revoked",
+  SUPERSEDED: "superseded",
+});
+
+const FEED_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["trusted", "retired"])],
+  ["trusted", new Set(["deprecated", "retired"])],
+  ["deprecated", new Set(["trusted", "retired"])],
+  ["retired", new Set()],
+]);
+const FEED_TERMINALS_V2 = new Set(["retired"]);
+
+const INDICATOR_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["active", "revoked", "superseded"])],
+  ["active", new Set(["expired", "revoked", "superseded"])],
+  ["expired", new Set()],
+  ["revoked", new Set()],
+  ["superseded", new Set()],
+]);
+const INDICATOR_TERMINALS_V2 = new Set(["expired", "revoked", "superseded"]);
+
+export const TI_DEFAULT_MAX_ACTIVE_FEEDS_PER_OWNER = 15;
+export const TI_DEFAULT_MAX_ACTIVE_INDICATORS_PER_FEED = 500;
+export const TI_DEFAULT_FEED_IDLE_MS = 1000 * 60 * 60 * 24 * 60; // 60 days
+export const TI_DEFAULT_INDICATOR_STALE_MS = 1000 * 60 * 60 * 24 * 90; // 90 days
+
+const _feedsV2 = new Map();
+const _indicatorsV2 = new Map();
+let _maxActiveFeedsPerOwnerV2 = TI_DEFAULT_MAX_ACTIVE_FEEDS_PER_OWNER;
+let _maxActiveIndicatorsPerFeedV2 = TI_DEFAULT_MAX_ACTIVE_INDICATORS_PER_FEED;
+let _feedIdleMsV2 = TI_DEFAULT_FEED_IDLE_MS;
+let _indicatorStaleMsV2 = TI_DEFAULT_INDICATOR_STALE_MS;
+
+function _posIntV2(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 getMaxActiveFeedsPerOwnerV2() {
+  return _maxActiveFeedsPerOwnerV2;
+}
+export function setMaxActiveFeedsPerOwnerV2(n) {
+  _maxActiveFeedsPerOwnerV2 = _posIntV2(n, "maxActiveFeedsPerOwner");
+}
+export function getMaxActiveIndicatorsPerFeedV2() {
+  return _maxActiveIndicatorsPerFeedV2;
+}
+export function setMaxActiveIndicatorsPerFeedV2(n) {
+  _maxActiveIndicatorsPerFeedV2 = _posIntV2(n, "maxActiveIndicatorsPerFeed");
+}
+export function getFeedIdleMsV2() {
+  return _feedIdleMsV2;
+}
+export function setFeedIdleMsV2(n) {
+  _feedIdleMsV2 = _posIntV2(n, "feedIdleMs");
+}
+export function getIndicatorStaleMsV2() {
+  return _indicatorStaleMsV2;
+}
+export function setIndicatorStaleMsV2(n) {
+  _indicatorStaleMsV2 = _posIntV2(n, "indicatorStaleMs");
+}
+
+export function getActiveFeedCountV2(owner) {
+  let n = 0;
+  for (const f of _feedsV2.values()) {
+    if (f.owner === owner && f.maturity === "trusted") n += 1;
+  }
+  return n;
+}
+
+export function getActiveIndicatorCountV2(feedId) {
+  let n = 0;
+  for (const i of _indicatorsV2.values()) {
+    if (i.feedId === feedId && i.status === "active") n += 1;
+  }
+  return n;
+}
+
+function _copyFeedV2(f) {
+  return { ...f, metadata: { ...f.metadata } };
+}
+function _copyIndicatorV2(i) {
+  return { ...i, metadata: { ...i.metadata } };
+}
+
+export function registerFeedV2(id, { owner, name, metadata = {} } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!owner || typeof owner !== "string")
+    throw new Error("owner must be a string");
+  if (!name || typeof name !== "string")
+    throw new Error("name must be a string");
+  if (_feedsV2.has(id)) throw new Error(`feed ${id} already exists`);
+  const now = Date.now();
+  const feed = {
+    id,
+    owner,
+    name,
+    maturity: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    metadata: { ...metadata },
+  };
+  _feedsV2.set(id, feed);
+  return _copyFeedV2(feed);
+}
+
+export function getFeedV2(id) {
+  const f = _feedsV2.get(id);
+  return f ? _copyFeedV2(f) : null;
+}
+
+export function listFeedsV2({ owner, maturity } = {}) {
+  const out = [];
+  for (const f of _feedsV2.values()) {
+    if (owner && f.owner !== owner) continue;
+    if (maturity && f.maturity !== maturity) continue;
+    out.push(_copyFeedV2(f));
+  }
+  return out;
+}
+
+export function setFeedMaturityV2(id, next, { now = Date.now() } = {}) {
+  const f = _feedsV2.get(id);
+  if (!f) throw new Error(`feed ${id} not found`);
+  if (!FEED_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown feed maturity: ${next}`);
+  if (FEED_TERMINALS_V2.has(f.maturity))
+    throw new Error(`feed ${id} is in terminal state ${f.maturity}`);
+  const allowed = FEED_TRANSITIONS_V2.get(f.maturity);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition feed from ${f.maturity} to ${next}`);
+  if (next === "trusted") {
+    if (f.maturity === "pending") {
+      const count = getActiveFeedCountV2(f.owner);
+      if (count >= _maxActiveFeedsPerOwnerV2)
+        throw new Error(
+          `owner ${f.owner} already at active-feed cap (${_maxActiveFeedsPerOwnerV2})`,
+        );
+    }
+    if (!f.activatedAt) f.activatedAt = now;
+  }
+  f.maturity = next;
+  f.lastSeenAt = now;
+  return _copyFeedV2(f);
+}
+
+export function trustFeedV2(id, opts) {
+  return setFeedMaturityV2(id, "trusted", opts);
+}
+export function deprecateFeedV2(id, opts) {
+  return setFeedMaturityV2(id, "deprecated", opts);
+}
+export function retireFeedV2(id, opts) {
+  return setFeedMaturityV2(id, "retired", opts);
+}
+
+export function touchFeedV2(id, { now = Date.now() } = {}) {
+  const f = _feedsV2.get(id);
+  if (!f) throw new Error(`feed ${id} not found`);
+  f.lastSeenAt = now;
+  return _copyFeedV2(f);
+}
+
+export function createIndicatorV2(
+  id,
+  { feedId, iocType, value, metadata = {} } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!feedId || typeof feedId !== "string")
+    throw new Error("feedId must be a string");
+  if (!iocType || typeof iocType !== "string")
+    throw new Error("iocType must be a string");
+  if (!value || typeof value !== "string")
+    throw new Error("value must be a string");
+  if (!_feedsV2.has(feedId)) throw new Error(`feed ${feedId} not found`);
+  if (_indicatorsV2.has(id)) throw new Error(`indicator ${id} already exists`);
+  const now = Date.now();
+  const indicator = {
+    id,
+    feedId,
+    iocType,
+    value,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    resolvedAt: null,
+    metadata: { ...metadata },
+  };
+  _indicatorsV2.set(id, indicator);
+  return _copyIndicatorV2(indicator);
+}
+
+export function getIndicatorV2(id) {
+  const i = _indicatorsV2.get(id);
+  return i ? _copyIndicatorV2(i) : null;
+}
+
+export function listIndicatorsV2({ feedId, status } = {}) {
+  const out = [];
+  for (const i of _indicatorsV2.values()) {
+    if (feedId && i.feedId !== feedId) continue;
+    if (status && i.status !== status) continue;
+    out.push(_copyIndicatorV2(i));
+  }
+  return out;
+}
+
+export function setIndicatorStatusV2(id, next, { now = Date.now() } = {}) {
+  const i = _indicatorsV2.get(id);
+  if (!i) throw new Error(`indicator ${id} not found`);
+  if (!INDICATOR_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown indicator status: ${next}`);
+  if (INDICATOR_TERMINALS_V2.has(i.status))
+    throw new Error(`indicator ${id} is in terminal state ${i.status}`);
+  const allowed = INDICATOR_TRANSITIONS_V2.get(i.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition indicator from ${i.status} to ${next}`);
+  if (next === "active" && i.status === "pending") {
+    const count = getActiveIndicatorCountV2(i.feedId);
+    if (count >= _maxActiveIndicatorsPerFeedV2)
+      throw new Error(
+        `feed ${i.feedId} already at active-indicator cap (${_maxActiveIndicatorsPerFeedV2})`,
+      );
+    if (!i.activatedAt) i.activatedAt = now;
+  }
+  if (INDICATOR_TERMINALS_V2.has(next) && !i.resolvedAt) {
+    i.resolvedAt = now;
+  }
+  i.status = next;
+  i.lastSeenAt = now;
+  return _copyIndicatorV2(i);
+}
+
+export function activateIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "active", opts);
+}
+export function expireIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "expired", opts);
+}
+export function revokeIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "revoked", opts);
+}
+export function supersedeIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "superseded", opts);
+}
+
+export function refreshIndicatorV2(id, { now = Date.now() } = {}) {
+  const i = _indicatorsV2.get(id);
+  if (!i) throw new Error(`indicator ${id} not found`);
+  if (INDICATOR_TERMINALS_V2.has(i.status))
+    throw new Error(`indicator ${id} is in terminal state ${i.status}`);
+  i.lastSeenAt = now;
+  return _copyIndicatorV2(i);
+}
+
+export function autoDeprecateIdleFeedsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const f of _feedsV2.values()) {
+    if (f.maturity !== "trusted") continue;
+    if (now - f.lastSeenAt > _feedIdleMsV2) {
+      f.maturity = "deprecated";
+      f.lastSeenAt = now;
+      flipped.push(_copyFeedV2(f));
+    }
+  }
+  return flipped;
+}
+
+export function autoExpireStaleIndicatorsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const i of _indicatorsV2.values()) {
+    if (i.status !== "active") continue;
+    if (now - i.lastSeenAt > _indicatorStaleMsV2) {
+      i.status = "expired";
+      i.lastSeenAt = now;
+      if (!i.resolvedAt) i.resolvedAt = now;
+      flipped.push(_copyIndicatorV2(i));
+    }
+  }
+  return flipped;
+}
+
+export function getThreatIntelStatsV2() {
+  const feedsByMaturity = {};
+  for (const m of Object.values(FEED_MATURITY_V2)) feedsByMaturity[m] = 0;
+  for (const f of _feedsV2.values()) feedsByMaturity[f.maturity] += 1;
+
+  const indicatorsByStatus = {};
+  for (const s of Object.values(INDICATOR_LIFECYCLE_V2))
+    indicatorsByStatus[s] = 0;
+  for (const i of _indicatorsV2.values()) indicatorsByStatus[i.status] += 1;
+
+  return {
+    totalFeedsV2: _feedsV2.size,
+    totalIndicatorsV2: _indicatorsV2.size,
+    maxActiveFeedsPerOwner: _maxActiveFeedsPerOwnerV2,
+    maxActiveIndicatorsPerFeed: _maxActiveIndicatorsPerFeedV2,
+    feedIdleMs: _feedIdleMsV2,
+    indicatorStaleMs: _indicatorStaleMsV2,
+    feedsByMaturity,
+    indicatorsByStatus,
+  };
+}
+
+export function _resetStateThreatIntelV2() {
+  _feedsV2.clear();
+  _indicatorsV2.clear();
+  _maxActiveFeedsPerOwnerV2 = TI_DEFAULT_MAX_ACTIVE_FEEDS_PER_OWNER;
+  _maxActiveIndicatorsPerFeedV2 = TI_DEFAULT_MAX_ACTIVE_INDICATORS_PER_FEED;
+  _feedIdleMsV2 = TI_DEFAULT_FEED_IDLE_MS;
+  _indicatorStaleMsV2 = TI_DEFAULT_INDICATOR_STALE_MS;
+}

package/src/lib/todo-manager.js

@@ -106,3 +106,108 @@ export function resetAllStores() {
 }
 
 export const _deps = { _stores };
+
+
+// ===== V2 Surface: Todo Manager governance overlay (CLI v0.133.0) =====
+export const TODO_LIST_MATURITY_V2 = Object.freeze({
+  DRAFT: "draft", ACTIVE: "active", PAUSED: "paused", ARCHIVED: "archived",
+});
+export const TODO_ITEM_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending", IN_PROGRESS: "in_progress", COMPLETED: "completed", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _tlListTrans = new Map([
+  [TODO_LIST_MATURITY_V2.DRAFT, new Set([TODO_LIST_MATURITY_V2.ACTIVE, TODO_LIST_MATURITY_V2.ARCHIVED])],
+  [TODO_LIST_MATURITY_V2.ACTIVE, new Set([TODO_LIST_MATURITY_V2.PAUSED, TODO_LIST_MATURITY_V2.ARCHIVED])],
+  [TODO_LIST_MATURITY_V2.PAUSED, new Set([TODO_LIST_MATURITY_V2.ACTIVE, TODO_LIST_MATURITY_V2.ARCHIVED])],
+  [TODO_LIST_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _tlListTerminal = new Set([TODO_LIST_MATURITY_V2.ARCHIVED]);
+const _tlItemTrans = new Map([
+  [TODO_ITEM_LIFECYCLE_V2.PENDING, new Set([TODO_ITEM_LIFECYCLE_V2.IN_PROGRESS, TODO_ITEM_LIFECYCLE_V2.CANCELLED])],
+  [TODO_ITEM_LIFECYCLE_V2.IN_PROGRESS, new Set([TODO_ITEM_LIFECYCLE_V2.COMPLETED, TODO_ITEM_LIFECYCLE_V2.FAILED, TODO_ITEM_LIFECYCLE_V2.CANCELLED])],
+  [TODO_ITEM_LIFECYCLE_V2.COMPLETED, new Set()],
+  [TODO_ITEM_LIFECYCLE_V2.FAILED, new Set()],
+  [TODO_ITEM_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _tlLists = new Map();
+const _tlItems = new Map();
+let _tlMaxActivePerOwner = 10;
+let _tlMaxPendingPerList = 40;
+let _tlListIdleMs = 7 * 24 * 60 * 60 * 1000;
+let _tlItemStuckMs = 24 * 60 * 60 * 1000;
+
+function _tlPos(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 setMaxActiveTodoListsPerOwnerV2(n) { _tlMaxActivePerOwner = _tlPos(n, "maxActiveTodoListsPerOwner"); }
+export function getMaxActiveTodoListsPerOwnerV2() { return _tlMaxActivePerOwner; }
+export function setMaxPendingItemsPerTodoListV2(n) { _tlMaxPendingPerList = _tlPos(n, "maxPendingItemsPerTodoList"); }
+export function getMaxPendingItemsPerTodoListV2() { return _tlMaxPendingPerList; }
+export function setTodoListIdleMsV2(n) { _tlListIdleMs = _tlPos(n, "todoListIdleMs"); }
+export function getTodoListIdleMsV2() { return _tlListIdleMs; }
+export function setTodoItemStuckMsV2(n) { _tlItemStuckMs = _tlPos(n, "todoItemStuckMs"); }
+export function getTodoItemStuckMsV2() { return _tlItemStuckMs; }
+
+export function _resetStateTodoManagerV2() {
+  _tlLists.clear(); _tlItems.clear();
+  _tlMaxActivePerOwner = 10; _tlMaxPendingPerList = 40;
+  _tlListIdleMs = 7 * 24 * 60 * 60 * 1000; _tlItemStuckMs = 24 * 60 * 60 * 1000;
+}
+
+export function registerTodoListV2({ id, owner, title, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_tlLists.has(id)) throw new Error(`todo list ${id} already registered`);
+  const now = Date.now();
+  const l = { id, owner, title: title || id, status: TODO_LIST_MATURITY_V2.DRAFT, createdAt: now, updatedAt: now, activatedAt: null, archivedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _tlLists.set(id, l);
+  return { ...l, metadata: { ...l.metadata } };
+}
+function _tlCheckL(from, to) { const allowed = _tlListTrans.get(from); if (!allowed || !allowed.has(to)) throw new Error(`invalid todo list transition ${from} → ${to}`); }
+function _tlCountActive(owner) { let n = 0; for (const l of _tlLists.values()) if (l.owner === owner && l.status === TODO_LIST_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateTodoListV2(id) {
+  const l = _tlLists.get(id); if (!l) throw new Error(`todo list ${id} not found`);
+  _tlCheckL(l.status, TODO_LIST_MATURITY_V2.ACTIVE);
+  const recovery = l.status === TODO_LIST_MATURITY_V2.PAUSED;
+  if (!recovery) { const a = _tlCountActive(l.owner); if (a >= _tlMaxActivePerOwner) throw new Error(`max active todo lists per owner (${_tlMaxActivePerOwner}) reached for ${l.owner}`); }
+  const now = Date.now(); l.status = TODO_LIST_MATURITY_V2.ACTIVE; l.updatedAt = now; l.lastTouchedAt = now; if (!l.activatedAt) l.activatedAt = now;
+  return { ...l, metadata: { ...l.metadata } };
+}
+export function pauseTodoListV2(id) { const l = _tlLists.get(id); if (!l) throw new Error(`todo list ${id} not found`); _tlCheckL(l.status, TODO_LIST_MATURITY_V2.PAUSED); l.status = TODO_LIST_MATURITY_V2.PAUSED; l.updatedAt = Date.now(); return { ...l, metadata: { ...l.metadata } }; }
+export function archiveTodoListV2(id) { const l = _tlLists.get(id); if (!l) throw new Error(`todo list ${id} not found`); _tlCheckL(l.status, TODO_LIST_MATURITY_V2.ARCHIVED); const now = Date.now(); l.status = TODO_LIST_MATURITY_V2.ARCHIVED; l.updatedAt = now; if (!l.archivedAt) l.archivedAt = now; return { ...l, metadata: { ...l.metadata } }; }
+export function touchTodoListV2(id) { const l = _tlLists.get(id); if (!l) throw new Error(`todo list ${id} not found`); if (_tlListTerminal.has(l.status)) throw new Error(`cannot touch terminal todo list ${id}`); const now = Date.now(); l.lastTouchedAt = now; l.updatedAt = now; return { ...l, metadata: { ...l.metadata } }; }
+export function getTodoListV2(id) { const l = _tlLists.get(id); if (!l) return null; return { ...l, metadata: { ...l.metadata } }; }
+export function listTodoListsV2() { return [..._tlLists.values()].map((l) => ({ ...l, metadata: { ...l.metadata } })); }
+
+function _tlCountPending(lid) { let n = 0; for (const it of _tlItems.values()) if (it.listId === lid && (it.status === TODO_ITEM_LIFECYCLE_V2.PENDING || it.status === TODO_ITEM_LIFECYCLE_V2.IN_PROGRESS)) n++; return n; }
+
+export function createTodoItemV2({ id, listId, description, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!listId || typeof listId !== "string") throw new Error("listId is required");
+  if (_tlItems.has(id)) throw new Error(`todo item ${id} already exists`);
+  if (!_tlLists.has(listId)) throw new Error(`todo list ${listId} not found`);
+  const pending = _tlCountPending(listId);
+  if (pending >= _tlMaxPendingPerList) throw new Error(`max pending items per todo list (${_tlMaxPendingPerList}) reached for ${listId}`);
+  const now = Date.now();
+  const it = { id, listId, description: description || "", status: TODO_ITEM_LIFECYCLE_V2.PENDING, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _tlItems.set(id, it);
+  return { ...it, metadata: { ...it.metadata } };
+}
+function _tlCheckI(from, to) { const allowed = _tlItemTrans.get(from); if (!allowed || !allowed.has(to)) throw new Error(`invalid todo item transition ${from} → ${to}`); }
+export function startTodoItemV2(id) { const it = _tlItems.get(id); if (!it) throw new Error(`todo item ${id} not found`); _tlCheckI(it.status, TODO_ITEM_LIFECYCLE_V2.IN_PROGRESS); const now = Date.now(); it.status = TODO_ITEM_LIFECYCLE_V2.IN_PROGRESS; it.updatedAt = now; if (!it.startedAt) it.startedAt = now; return { ...it, metadata: { ...it.metadata } }; }
+export function completeTodoItemV2(id) { const it = _tlItems.get(id); if (!it) throw new Error(`todo item ${id} not found`); _tlCheckI(it.status, TODO_ITEM_LIFECYCLE_V2.COMPLETED); const now = Date.now(); it.status = TODO_ITEM_LIFECYCLE_V2.COMPLETED; it.updatedAt = now; if (!it.settledAt) it.settledAt = now; return { ...it, metadata: { ...it.metadata } }; }
+export function failTodoItemV2(id, reason) { const it = _tlItems.get(id); if (!it) throw new Error(`todo item ${id} not found`); _tlCheckI(it.status, TODO_ITEM_LIFECYCLE_V2.FAILED); const now = Date.now(); it.status = TODO_ITEM_LIFECYCLE_V2.FAILED; it.updatedAt = now; if (!it.settledAt) it.settledAt = now; if (reason) it.metadata.failReason = String(reason); return { ...it, metadata: { ...it.metadata } }; }
+export function cancelTodoItemV2(id, reason) { const it = _tlItems.get(id); if (!it) throw new Error(`todo item ${id} not found`); _tlCheckI(it.status, TODO_ITEM_LIFECYCLE_V2.CANCELLED); const now = Date.now(); it.status = TODO_ITEM_LIFECYCLE_V2.CANCELLED; it.updatedAt = now; if (!it.settledAt) it.settledAt = now; if (reason) it.metadata.cancelReason = String(reason); return { ...it, metadata: { ...it.metadata } }; }
+export function getTodoItemV2(id) { const it = _tlItems.get(id); if (!it) return null; return { ...it, metadata: { ...it.metadata } }; }
+export function listTodoItemsV2() { return [..._tlItems.values()].map((it) => ({ ...it, metadata: { ...it.metadata } })); }
+
+export function autoPauseIdleTodoListsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const l of _tlLists.values()) if (l.status === TODO_LIST_MATURITY_V2.ACTIVE && (t - l.lastTouchedAt) >= _tlListIdleMs) { l.status = TODO_LIST_MATURITY_V2.PAUSED; l.updatedAt = t; flipped.push(l.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckTodoItemsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const it of _tlItems.values()) if (it.status === TODO_ITEM_LIFECYCLE_V2.IN_PROGRESS && it.startedAt != null && (t - it.startedAt) >= _tlItemStuckMs) { it.status = TODO_ITEM_LIFECYCLE_V2.FAILED; it.updatedAt = t; if (!it.settledAt) it.settledAt = t; it.metadata.failReason = "auto-fail-stuck"; flipped.push(it.id); } return { flipped, count: flipped.length }; }
+
+export function getTodoManagerStatsV2() {
+  const listsByStatus = {}; for (const s of Object.values(TODO_LIST_MATURITY_V2)) listsByStatus[s] = 0; for (const l of _tlLists.values()) listsByStatus[l.status]++;
+  const itemsByStatus = {}; for (const s of Object.values(TODO_ITEM_LIFECYCLE_V2)) itemsByStatus[s] = 0; for (const it of _tlItems.values()) itemsByStatus[it.status]++;
+  return { totalListsV2: _tlLists.size, totalItemsV2: _tlItems.size, maxActiveTodoListsPerOwner: _tlMaxActivePerOwner, maxPendingItemsPerTodoList: _tlMaxPendingPerList, todoListIdleMs: _tlListIdleMs, todoItemStuckMs: _tlItemStuckMs, listsByStatus, itemsByStatus };
+}