chainlesschain 0.81.0 → 0.143.0

package/src/harness/prompt-compressor.js

@@ -414,3 +414,334 @@ export class PromptCompressor {
     return result;
   }
 }
+
+
+// =====================================================================
+// Prompt Compressor V2 governance overlay
+// =====================================================================
+export const PCOMP_PROFILE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  STALE: "stale",
+  ARCHIVED: "archived",
+});
+export const PCOMP_RUN_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  COMPRESSING: "compressing",
+  COMPRESSED: "compressed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+const _pcompPTrans = new Map([
+  [
+    PCOMP_PROFILE_MATURITY_V2.PENDING,
+    new Set([
+      PCOMP_PROFILE_MATURITY_V2.ACTIVE,
+      PCOMP_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [
+    PCOMP_PROFILE_MATURITY_V2.ACTIVE,
+    new Set([
+      PCOMP_PROFILE_MATURITY_V2.STALE,
+      PCOMP_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [
+    PCOMP_PROFILE_MATURITY_V2.STALE,
+    new Set([
+      PCOMP_PROFILE_MATURITY_V2.ACTIVE,
+      PCOMP_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [PCOMP_PROFILE_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _pcompPTerminal = new Set([PCOMP_PROFILE_MATURITY_V2.ARCHIVED]);
+const _pcompRTrans = new Map([
+  [
+    PCOMP_RUN_LIFECYCLE_V2.QUEUED,
+    new Set([
+      PCOMP_RUN_LIFECYCLE_V2.COMPRESSING,
+      PCOMP_RUN_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [
+    PCOMP_RUN_LIFECYCLE_V2.COMPRESSING,
+    new Set([
+      PCOMP_RUN_LIFECYCLE_V2.COMPRESSED,
+      PCOMP_RUN_LIFECYCLE_V2.FAILED,
+      PCOMP_RUN_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [PCOMP_RUN_LIFECYCLE_V2.COMPRESSED, new Set()],
+  [PCOMP_RUN_LIFECYCLE_V2.FAILED, new Set()],
+  [PCOMP_RUN_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _pcompPsV2 = new Map();
+const _pcompRsV2 = new Map();
+let _pcompMaxActive = 8,
+  _pcompMaxPending = 20,
+  _pcompIdleMs = 30 * 24 * 60 * 60 * 1000,
+  _pcompStuckMs = 60 * 1000;
+function _pcompPos(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0)
+    throw new Error(`${label} must be positive integer`);
+  return v;
+}
+function _pcompCheckP(from, to) {
+  const a = _pcompPTrans.get(from);
+  if (!a || !a.has(to))
+    throw new Error(`invalid pcomp profile transition ${from} → ${to}`);
+}
+function _pcompCheckR(from, to) {
+  const a = _pcompRTrans.get(from);
+  if (!a || !a.has(to))
+    throw new Error(`invalid pcomp run transition ${from} → ${to}`);
+}
+function _pcompCountActive(owner) {
+  let c = 0;
+  for (const p of _pcompPsV2.values())
+    if (p.owner === owner && p.status === PCOMP_PROFILE_MATURITY_V2.ACTIVE) c++;
+  return c;
+}
+function _pcompCountPending(profileId) {
+  let c = 0;
+  for (const r of _pcompRsV2.values())
+    if (
+      r.profileId === profileId &&
+      (r.status === PCOMP_RUN_LIFECYCLE_V2.QUEUED ||
+        r.status === PCOMP_RUN_LIFECYCLE_V2.COMPRESSING)
+    )
+      c++;
+  return c;
+}
+export function setMaxActivePcompProfilesPerOwnerV2(n) {
+  _pcompMaxActive = _pcompPos(n, "maxActivePcompProfilesPerOwner");
+}
+export function getMaxActivePcompProfilesPerOwnerV2() {
+  return _pcompMaxActive;
+}
+export function setMaxPendingPcompRunsPerProfileV2(n) {
+  _pcompMaxPending = _pcompPos(n, "maxPendingPcompRunsPerProfile");
+}
+export function getMaxPendingPcompRunsPerProfileV2() {
+  return _pcompMaxPending;
+}
+export function setPcompProfileIdleMsV2(n) {
+  _pcompIdleMs = _pcompPos(n, "pcompProfileIdleMs");
+}
+export function getPcompProfileIdleMsV2() {
+  return _pcompIdleMs;
+}
+export function setPcompRunStuckMsV2(n) {
+  _pcompStuckMs = _pcompPos(n, "pcompRunStuckMs");
+}
+export function getPcompRunStuckMsV2() {
+  return _pcompStuckMs;
+}
+export function _resetStatePromptCompressorV2() {
+  _pcompPsV2.clear();
+  _pcompRsV2.clear();
+  _pcompMaxActive = 8;
+  _pcompMaxPending = 20;
+  _pcompIdleMs = 30 * 24 * 60 * 60 * 1000;
+  _pcompStuckMs = 60 * 1000;
+}
+export function registerPcompProfileV2({ id, owner, variant, metadata } = {}) {
+  if (!id || !owner) throw new Error("id and owner required");
+  if (_pcompPsV2.has(id)) throw new Error(`pcomp profile ${id} already exists`);
+  const now = Date.now();
+  const p = {
+    id,
+    owner,
+    variant: variant || "default",
+    status: PCOMP_PROFILE_MATURITY_V2.PENDING,
+    createdAt: now,
+    updatedAt: now,
+    lastTouchedAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: { ...(metadata || {}) },
+  };
+  _pcompPsV2.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function activatePcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  const isInitial = p.status === PCOMP_PROFILE_MATURITY_V2.PENDING;
+  _pcompCheckP(p.status, PCOMP_PROFILE_MATURITY_V2.ACTIVE);
+  if (isInitial && _pcompCountActive(p.owner) >= _pcompMaxActive)
+    throw new Error(`max active pcomp profiles for owner ${p.owner} reached`);
+  const now = Date.now();
+  p.status = PCOMP_PROFILE_MATURITY_V2.ACTIVE;
+  p.updatedAt = now;
+  p.lastTouchedAt = now;
+  if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function stalePcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  _pcompCheckP(p.status, PCOMP_PROFILE_MATURITY_V2.STALE);
+  p.status = PCOMP_PROFILE_MATURITY_V2.STALE;
+  p.updatedAt = Date.now();
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function archivePcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  _pcompCheckP(p.status, PCOMP_PROFILE_MATURITY_V2.ARCHIVED);
+  const now = Date.now();
+  p.status = PCOMP_PROFILE_MATURITY_V2.ARCHIVED;
+  p.updatedAt = now;
+  if (!p.archivedAt) p.archivedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function touchPcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  if (_pcompPTerminal.has(p.status))
+    throw new Error(`cannot touch terminal pcomp profile ${id}`);
+  const now = Date.now();
+  p.lastTouchedAt = now;
+  p.updatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function getPcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) return null;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function listPcompProfilesV2() {
+  return [..._pcompPsV2.values()].map((p) => ({
+    ...p,
+    metadata: { ...p.metadata },
+  }));
+}
+export function createPcompRunV2({ id, profileId, input, metadata } = {}) {
+  if (!id || !profileId) throw new Error("id and profileId required");
+  if (_pcompRsV2.has(id)) throw new Error(`pcomp run ${id} already exists`);
+  if (!_pcompPsV2.has(profileId))
+    throw new Error(`pcomp profile ${profileId} not found`);
+  if (_pcompCountPending(profileId) >= _pcompMaxPending)
+    throw new Error(`max pending pcomp runs for profile ${profileId} reached`);
+  const now = Date.now();
+  const r = {
+    id,
+    profileId,
+    input: input || "",
+    status: PCOMP_RUN_LIFECYCLE_V2.QUEUED,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: null,
+    settledAt: null,
+    metadata: { ...(metadata || {}) },
+  };
+  _pcompRsV2.set(id, r);
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function compressingPcompRunV2(id) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.COMPRESSING);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.COMPRESSING;
+  r.updatedAt = now;
+  if (!r.startedAt) r.startedAt = now;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function compressPcompRunV2(id) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.COMPRESSED);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.COMPRESSED;
+  r.updatedAt = now;
+  if (!r.settledAt) r.settledAt = now;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function failPcompRunV2(id, reason) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.FAILED);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.FAILED;
+  r.updatedAt = now;
+  if (!r.settledAt) r.settledAt = now;
+  if (reason) r.metadata.failReason = String(reason);
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function cancelPcompRunV2(id, reason) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.CANCELLED);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.CANCELLED;
+  r.updatedAt = now;
+  if (!r.settledAt) r.settledAt = now;
+  if (reason) r.metadata.cancelReason = String(reason);
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function getPcompRunV2(id) {
+  const r = _pcompRsV2.get(id);
+  if (!r) return null;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function listPcompRunsV2() {
+  return [..._pcompRsV2.values()].map((r) => ({
+    ...r,
+    metadata: { ...r.metadata },
+  }));
+}
+export function autoStaleIdlePcompProfilesV2({ now } = {}) {
+  const t = now ?? Date.now();
+  const flipped = [];
+  for (const p of _pcompPsV2.values())
+    if (
+      p.status === PCOMP_PROFILE_MATURITY_V2.ACTIVE &&
+      t - p.lastTouchedAt >= _pcompIdleMs
+    ) {
+      p.status = PCOMP_PROFILE_MATURITY_V2.STALE;
+      p.updatedAt = t;
+      flipped.push(p.id);
+    }
+  return { flipped, count: flipped.length };
+}
+export function autoFailStuckPcompRunsV2({ now } = {}) {
+  const t = now ?? Date.now();
+  const flipped = [];
+  for (const r of _pcompRsV2.values())
+    if (
+      r.status === PCOMP_RUN_LIFECYCLE_V2.COMPRESSING &&
+      r.startedAt != null &&
+      t - r.startedAt >= _pcompStuckMs
+    ) {
+      r.status = PCOMP_RUN_LIFECYCLE_V2.FAILED;
+      r.updatedAt = t;
+      if (!r.settledAt) r.settledAt = t;
+      r.metadata.failReason = "auto-fail-stuck";
+      flipped.push(r.id);
+    }
+  return { flipped, count: flipped.length };
+}
+export function getPromptCompressorGovStatsV2() {
+  const profilesByStatus = {};
+  for (const v of Object.values(PCOMP_PROFILE_MATURITY_V2))
+    profilesByStatus[v] = 0;
+  for (const p of _pcompPsV2.values()) profilesByStatus[p.status]++;
+  const runsByStatus = {};
+  for (const v of Object.values(PCOMP_RUN_LIFECYCLE_V2)) runsByStatus[v] = 0;
+  for (const r of _pcompRsV2.values()) runsByStatus[r.status]++;
+  return {
+    totalPcompProfilesV2: _pcompPsV2.size,
+    totalPcompRunsV2: _pcompRsV2.size,
+    maxActivePcompProfilesPerOwner: _pcompMaxActive,
+    maxPendingPcompRunsPerProfile: _pcompMaxPending,
+    pcompProfileIdleMs: _pcompIdleMs,
+    pcompRunStuckMs: _pcompStuckMs,
+    profilesByStatus,
+    runsByStatus,
+  };
+}

package/src/index.js

@@ -13,13 +13,46 @@ import { registerNoteCommand } from "./commands/note.js";
 import { registerChatCommand } from "./commands/chat.js";
 import { registerAskCommand } from "./commands/ask.js";
 import { registerLlmCommand } from "./commands/llm.js";
-import { registerAgentCommand } from "./commands/agent.js";
+import {
+  registerAgentCommand,
+  registerSubAgentV2Command,
+  registerExecBackendV2Command,
+  registerTodoV2Command,
+  registerAutoAgentV2Command,
+} from "./commands/agent.js";
+import { registerOrchGovCommand } from "./commands/orchgov.js";
+import { registerTopicClsCommand } from "./commands/topiccls.js";
+import { registerItBudgetCommand } from "./commands/itbudget.js";
+import { registerPlanModeCommand } from "./commands/planmode.js";
+import { registerPermCommand } from "./commands/perm.js";
+import { registerUprofCommand } from "./commands/uprof.js";
+import { registerSvcContCommand } from "./commands/svccont.js";
+import { registerTmsCommand } from "./commands/tms.js";
+import { registerSlotfillCommand } from "./commands/slotfill.js";
+import { registerWebfetchCommand } from "./commands/webfetch.js";
+import { registerMeminjCommand } from "./commands/meminj.js";
+import { registerSeshsearchCommand } from "./commands/seshsearch.js";
+import { registerSeshtailCommand } from "./commands/seshtail.js";
+import { registerSeshuCommand } from "./commands/seshu.js";
+import { registerSeshhookCommand } from "./commands/seshhook.js";
+import { registerMcpscafCommand } from "./commands/mcpscaf.js";
+import { registerFflagCommand } from "./commands/fflag.js";
+import { registerPromcompCommand } from "./commands/promcomp.js";
+import { registerCcronCommand } from "./commands/ccron.js";
+import { registerVcheckCommand } from "./commands/vcheck.js";
+import { registerPdfpCommand } from "./commands/pdfp.js";
+import { registerBm25Command } from "./commands/bm25.js";
+import { registerComptCommand } from "./commands/compt.js";
+import { registerSganalCommand } from "./commands/sganal.js";
 import { registerStreamCommand } from "./commands/stream.js";
 import { registerSkillCommand } from "./commands/skill.js";
 import { registerSearchCommand } from "./commands/search.js";
 import { registerTokensCommand } from "./commands/tokens.js";
 import { registerMemoryCommand } from "./commands/memory.js";
+import { registerPermMemCommand } from "./commands/permmem.js";
+import { registerRCacheCommand } from "./commands/rcache.js";
 import { registerSessionCommand } from "./commands/session.js";
+import { registerConsolCommand } from "./commands/consol.js";
 import { registerImportCommand } from "./commands/import.js";
 import { registerExportCommand } from "./commands/export.js";
 import { registerGitCommand } from "./commands/git.js";
@@ -209,6 +242,34 @@ export function createProgram() {
   registerAskCommand(program);
   registerLlmCommand(program);
   registerAgentCommand(program);
+  registerSubAgentV2Command(program);
+  registerExecBackendV2Command(program);
+  registerTodoV2Command(program);
+  registerAutoAgentV2Command(program);
+  registerOrchGovCommand(program);
+  registerTopicClsCommand(program);
+  registerItBudgetCommand(program);
+  registerPlanModeCommand(program);
+  registerPermCommand(program);
+  registerUprofCommand(program);
+  registerSvcContCommand(program);
+  registerTmsCommand(program);
+  registerSlotfillCommand(program);
+  registerWebfetchCommand(program);
+  registerMeminjCommand(program);
+  registerSeshsearchCommand(program);
+  registerSeshtailCommand(program);
+  registerSeshuCommand(program);
+  registerSeshhookCommand(program);
+  registerMcpscafCommand(program);
+  registerFflagCommand(program);
+  registerPromcompCommand(program);
+  registerCcronCommand(program);
+  registerVcheckCommand(program);
+  registerPdfpCommand(program);
+  registerBm25Command(program);
+  registerComptCommand(program);
+  registerSganalCommand(program);
   registerStreamCommand(program);
   registerSkillCommand(program);
 
@@ -216,7 +277,10 @@ export function createProgram() {
   registerSearchCommand(program);
   registerTokensCommand(program);
   registerMemoryCommand(program);
+  registerPermMemCommand(program);
+  registerRCacheCommand(program);
   registerSessionCommand(program);
+  registerConsolCommand(program);
 
   // Phase 2: Knowledge & content management
   registerImportCommand(program);

package/src/lib/a2a-protocol.js

@@ -820,3 +820,108 @@ export function _resetV2State() {
 }
 
 export { _v2Tasks, _v2Cards, _v2TypedSubs };
+
+
+// ===== V2 Surface: A2A Protocol governance overlay (CLI v0.136.0) =====
+export const A2A_AGENT_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", SUSPENDED: "suspended", RETIRED: "retired",
+});
+export const A2A_MESSAGE_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", SENDING: "sending", DELIVERED: "delivered", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _a2aAgentTrans = new Map([
+  [A2A_AGENT_MATURITY_V2.PENDING, new Set([A2A_AGENT_MATURITY_V2.ACTIVE, A2A_AGENT_MATURITY_V2.RETIRED])],
+  [A2A_AGENT_MATURITY_V2.ACTIVE, new Set([A2A_AGENT_MATURITY_V2.SUSPENDED, A2A_AGENT_MATURITY_V2.RETIRED])],
+  [A2A_AGENT_MATURITY_V2.SUSPENDED, new Set([A2A_AGENT_MATURITY_V2.ACTIVE, A2A_AGENT_MATURITY_V2.RETIRED])],
+  [A2A_AGENT_MATURITY_V2.RETIRED, new Set()],
+]);
+const _a2aAgentTerminal = new Set([A2A_AGENT_MATURITY_V2.RETIRED]);
+const _a2aMsgTrans = new Map([
+  [A2A_MESSAGE_LIFECYCLE_V2.QUEUED, new Set([A2A_MESSAGE_LIFECYCLE_V2.SENDING, A2A_MESSAGE_LIFECYCLE_V2.CANCELLED])],
+  [A2A_MESSAGE_LIFECYCLE_V2.SENDING, new Set([A2A_MESSAGE_LIFECYCLE_V2.DELIVERED, A2A_MESSAGE_LIFECYCLE_V2.FAILED, A2A_MESSAGE_LIFECYCLE_V2.CANCELLED])],
+  [A2A_MESSAGE_LIFECYCLE_V2.DELIVERED, new Set()],
+  [A2A_MESSAGE_LIFECYCLE_V2.FAILED, new Set()],
+  [A2A_MESSAGE_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _a2aAgents = new Map();
+const _a2aMsgs = new Map();
+let _a2aMaxActivePerOwner = 12;
+let _a2aMaxPendingPerAgent = 20;
+let _a2aAgentIdleMs = 6 * 60 * 60 * 1000;
+let _a2aMsgStuckMs = 3 * 60 * 1000;
+
+function _a2aPos(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 setMaxActiveA2aAgentsPerOwnerV2(n) { _a2aMaxActivePerOwner = _a2aPos(n, "maxActiveA2aAgentsPerOwner"); }
+export function getMaxActiveA2aAgentsPerOwnerV2() { return _a2aMaxActivePerOwner; }
+export function setMaxPendingA2aMessagesPerAgentV2(n) { _a2aMaxPendingPerAgent = _a2aPos(n, "maxPendingA2aMessagesPerAgent"); }
+export function getMaxPendingA2aMessagesPerAgentV2() { return _a2aMaxPendingPerAgent; }
+export function setA2aAgentIdleMsV2(n) { _a2aAgentIdleMs = _a2aPos(n, "a2aAgentIdleMs"); }
+export function getA2aAgentIdleMsV2() { return _a2aAgentIdleMs; }
+export function setA2aMessageStuckMsV2(n) { _a2aMsgStuckMs = _a2aPos(n, "a2aMessageStuckMs"); }
+export function getA2aMessageStuckMsV2() { return _a2aMsgStuckMs; }
+
+export function _resetStateA2aProtocolV2() {
+  _a2aAgents.clear(); _a2aMsgs.clear();
+  _a2aMaxActivePerOwner = 12; _a2aMaxPendingPerAgent = 20;
+  _a2aAgentIdleMs = 6 * 60 * 60 * 1000; _a2aMsgStuckMs = 3 * 60 * 1000;
+}
+
+export function registerA2aAgentV2({ id, owner, capabilities, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_a2aAgents.has(id)) throw new Error(`a2a agent ${id} already registered`);
+  const now = Date.now();
+  const a = { id, owner, capabilities: Array.isArray(capabilities) ? [...capabilities] : [], status: A2A_AGENT_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, retiredAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _a2aAgents.set(id, a);
+  return { ...a, capabilities: [...a.capabilities], metadata: { ...a.metadata } };
+}
+function _a2aCheckA(from, to) { const al = _a2aAgentTrans.get(from); if (!al || !al.has(to)) throw new Error(`invalid a2a agent transition ${from} → ${to}`); }
+function _a2aCountActive(owner) { let n = 0; for (const a of _a2aAgents.values()) if (a.owner === owner && a.status === A2A_AGENT_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateA2aAgentV2(id) {
+  const a = _a2aAgents.get(id); if (!a) throw new Error(`a2a agent ${id} not found`);
+  _a2aCheckA(a.status, A2A_AGENT_MATURITY_V2.ACTIVE);
+  const recovery = a.status === A2A_AGENT_MATURITY_V2.SUSPENDED;
+  if (!recovery) { const c = _a2aCountActive(a.owner); if (c >= _a2aMaxActivePerOwner) throw new Error(`max active a2a agents per owner (${_a2aMaxActivePerOwner}) reached for ${a.owner}`); }
+  const now = Date.now(); a.status = A2A_AGENT_MATURITY_V2.ACTIVE; a.updatedAt = now; a.lastTouchedAt = now; if (!a.activatedAt) a.activatedAt = now;
+  return { ...a, capabilities: [...a.capabilities], metadata: { ...a.metadata } };
+}
+export function suspendA2aAgentV2(id) { const a = _a2aAgents.get(id); if (!a) throw new Error(`a2a agent ${id} not found`); _a2aCheckA(a.status, A2A_AGENT_MATURITY_V2.SUSPENDED); a.status = A2A_AGENT_MATURITY_V2.SUSPENDED; a.updatedAt = Date.now(); return { ...a, capabilities: [...a.capabilities], metadata: { ...a.metadata } }; }
+export function retireA2aAgentV2(id) { const a = _a2aAgents.get(id); if (!a) throw new Error(`a2a agent ${id} not found`); _a2aCheckA(a.status, A2A_AGENT_MATURITY_V2.RETIRED); const now = Date.now(); a.status = A2A_AGENT_MATURITY_V2.RETIRED; a.updatedAt = now; if (!a.retiredAt) a.retiredAt = now; return { ...a, capabilities: [...a.capabilities], metadata: { ...a.metadata } }; }
+export function touchA2aAgentV2(id) { const a = _a2aAgents.get(id); if (!a) throw new Error(`a2a agent ${id} not found`); if (_a2aAgentTerminal.has(a.status)) throw new Error(`cannot touch terminal a2a agent ${id}`); const now = Date.now(); a.lastTouchedAt = now; a.updatedAt = now; return { ...a, capabilities: [...a.capabilities], metadata: { ...a.metadata } }; }
+export function getA2aAgentV2(id) { const a = _a2aAgents.get(id); if (!a) return null; return { ...a, capabilities: [...a.capabilities], metadata: { ...a.metadata } }; }
+export function listA2aAgentsV2() { return [..._a2aAgents.values()].map((a) => ({ ...a, capabilities: [...a.capabilities], metadata: { ...a.metadata } })); }
+
+function _a2aCountPending(aid) { let n = 0; for (const m of _a2aMsgs.values()) if (m.agentId === aid && (m.status === A2A_MESSAGE_LIFECYCLE_V2.QUEUED || m.status === A2A_MESSAGE_LIFECYCLE_V2.SENDING)) n++; return n; }
+
+export function createA2aMessageV2({ id, agentId, peerId, payload, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!agentId || typeof agentId !== "string") throw new Error("agentId is required");
+  if (_a2aMsgs.has(id)) throw new Error(`a2a message ${id} already exists`);
+  if (!_a2aAgents.has(agentId)) throw new Error(`a2a agent ${agentId} not found`);
+  const pending = _a2aCountPending(agentId);
+  if (pending >= _a2aMaxPendingPerAgent) throw new Error(`max pending a2a messages per agent (${_a2aMaxPendingPerAgent}) reached for ${agentId}`);
+  const now = Date.now();
+  const m = { id, agentId, peerId: peerId || "", payload: payload || "", status: A2A_MESSAGE_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _a2aMsgs.set(id, m);
+  return { ...m, metadata: { ...m.metadata } };
+}
+function _a2aCheckM(from, to) { const al = _a2aMsgTrans.get(from); if (!al || !al.has(to)) throw new Error(`invalid a2a message transition ${from} → ${to}`); }
+export function startA2aMessageV2(id) { const m = _a2aMsgs.get(id); if (!m) throw new Error(`a2a message ${id} not found`); _a2aCheckM(m.status, A2A_MESSAGE_LIFECYCLE_V2.SENDING); const now = Date.now(); m.status = A2A_MESSAGE_LIFECYCLE_V2.SENDING; m.updatedAt = now; if (!m.startedAt) m.startedAt = now; return { ...m, metadata: { ...m.metadata } }; }
+export function deliverA2aMessageV2(id) { const m = _a2aMsgs.get(id); if (!m) throw new Error(`a2a message ${id} not found`); _a2aCheckM(m.status, A2A_MESSAGE_LIFECYCLE_V2.DELIVERED); const now = Date.now(); m.status = A2A_MESSAGE_LIFECYCLE_V2.DELIVERED; m.updatedAt = now; if (!m.settledAt) m.settledAt = now; return { ...m, metadata: { ...m.metadata } }; }
+export function failA2aMessageV2(id, reason) { const m = _a2aMsgs.get(id); if (!m) throw new Error(`a2a message ${id} not found`); _a2aCheckM(m.status, A2A_MESSAGE_LIFECYCLE_V2.FAILED); const now = Date.now(); m.status = A2A_MESSAGE_LIFECYCLE_V2.FAILED; m.updatedAt = now; if (!m.settledAt) m.settledAt = now; if (reason) m.metadata.failReason = String(reason); return { ...m, metadata: { ...m.metadata } }; }
+export function cancelA2aMessageV2(id, reason) { const m = _a2aMsgs.get(id); if (!m) throw new Error(`a2a message ${id} not found`); _a2aCheckM(m.status, A2A_MESSAGE_LIFECYCLE_V2.CANCELLED); const now = Date.now(); m.status = A2A_MESSAGE_LIFECYCLE_V2.CANCELLED; m.updatedAt = now; if (!m.settledAt) m.settledAt = now; if (reason) m.metadata.cancelReason = String(reason); return { ...m, metadata: { ...m.metadata } }; }
+export function getA2aMessageV2(id) { const m = _a2aMsgs.get(id); if (!m) return null; return { ...m, metadata: { ...m.metadata } }; }
+export function listA2aMessagesV2() { return [..._a2aMsgs.values()].map((m) => ({ ...m, metadata: { ...m.metadata } })); }
+
+export function autoSuspendIdleA2aAgentsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const a of _a2aAgents.values()) if (a.status === A2A_AGENT_MATURITY_V2.ACTIVE && (t - a.lastTouchedAt) >= _a2aAgentIdleMs) { a.status = A2A_AGENT_MATURITY_V2.SUSPENDED; a.updatedAt = t; flipped.push(a.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckA2aMessagesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const m of _a2aMsgs.values()) if (m.status === A2A_MESSAGE_LIFECYCLE_V2.SENDING && m.startedAt != null && (t - m.startedAt) >= _a2aMsgStuckMs) { m.status = A2A_MESSAGE_LIFECYCLE_V2.FAILED; m.updatedAt = t; if (!m.settledAt) m.settledAt = t; m.metadata.failReason = "auto-fail-stuck"; flipped.push(m.id); } return { flipped, count: flipped.length }; }
+
+export function getA2aProtocolGovStatsV2() {
+  const agentsByStatus = {}; for (const s of Object.values(A2A_AGENT_MATURITY_V2)) agentsByStatus[s] = 0; for (const a of _a2aAgents.values()) agentsByStatus[a.status]++;
+  const messagesByStatus = {}; for (const s of Object.values(A2A_MESSAGE_LIFECYCLE_V2)) messagesByStatus[s] = 0; for (const m of _a2aMsgs.values()) messagesByStatus[m.status]++;
+  return { totalAgentsV2: _a2aAgents.size, totalMessagesV2: _a2aMsgs.size, maxActiveA2aAgentsPerOwner: _a2aMaxActivePerOwner, maxPendingA2aMessagesPerAgent: _a2aMaxPendingPerAgent, a2aAgentIdleMs: _a2aAgentIdleMs, a2aMessageStuckMs: _a2aMsgStuckMs, agentsByStatus, messagesByStatus };
+}

package/src/lib/activitypub-bridge.js

@@ -621,3 +621,108 @@ export function _resetState() {
 }
 
 export const _constants = { PUBLIC_AUDIENCE, CONTEXT, DEFAULT_ORIGIN };
+
+
+// ===== V2 Surface: ActivityPub Bridge governance overlay (CLI v0.135.0) =====
+export const AP_ACTOR_MATURITY_V2 = Object.freeze({
+  PENDING: "pending", ACTIVE: "active", SUSPENDED: "suspended", DEACTIVATED: "deactivated",
+});
+export const AP_ACTIVITY_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued", DELIVERING: "delivering", DELIVERED: "delivered", FAILED: "failed", CANCELLED: "cancelled",
+});
+
+const _apActorTrans = new Map([
+  [AP_ACTOR_MATURITY_V2.PENDING, new Set([AP_ACTOR_MATURITY_V2.ACTIVE, AP_ACTOR_MATURITY_V2.DEACTIVATED])],
+  [AP_ACTOR_MATURITY_V2.ACTIVE, new Set([AP_ACTOR_MATURITY_V2.SUSPENDED, AP_ACTOR_MATURITY_V2.DEACTIVATED])],
+  [AP_ACTOR_MATURITY_V2.SUSPENDED, new Set([AP_ACTOR_MATURITY_V2.ACTIVE, AP_ACTOR_MATURITY_V2.DEACTIVATED])],
+  [AP_ACTOR_MATURITY_V2.DEACTIVATED, new Set()],
+]);
+const _apActorTerminal = new Set([AP_ACTOR_MATURITY_V2.DEACTIVATED]);
+const _apActTrans = new Map([
+  [AP_ACTIVITY_LIFECYCLE_V2.QUEUED, new Set([AP_ACTIVITY_LIFECYCLE_V2.DELIVERING, AP_ACTIVITY_LIFECYCLE_V2.CANCELLED])],
+  [AP_ACTIVITY_LIFECYCLE_V2.DELIVERING, new Set([AP_ACTIVITY_LIFECYCLE_V2.DELIVERED, AP_ACTIVITY_LIFECYCLE_V2.FAILED, AP_ACTIVITY_LIFECYCLE_V2.CANCELLED])],
+  [AP_ACTIVITY_LIFECYCLE_V2.DELIVERED, new Set()],
+  [AP_ACTIVITY_LIFECYCLE_V2.FAILED, new Set()],
+  [AP_ACTIVITY_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _apActors = new Map();
+const _apActs = new Map();
+let _apMaxActivePerOwner = 15;
+let _apMaxPendingPerActor = 25;
+let _apActorIdleMs = 24 * 60 * 60 * 1000;
+let _apActStuckMs = 3 * 60 * 1000;
+
+function _apPos(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 setMaxActiveApActorsPerOwnerV2(n) { _apMaxActivePerOwner = _apPos(n, "maxActiveApActorsPerOwner"); }
+export function getMaxActiveApActorsPerOwnerV2() { return _apMaxActivePerOwner; }
+export function setMaxPendingApActivitiesPerActorV2(n) { _apMaxPendingPerActor = _apPos(n, "maxPendingApActivitiesPerActor"); }
+export function getMaxPendingApActivitiesPerActorV2() { return _apMaxPendingPerActor; }
+export function setApActorIdleMsV2(n) { _apActorIdleMs = _apPos(n, "apActorIdleMs"); }
+export function getApActorIdleMsV2() { return _apActorIdleMs; }
+export function setApActivityStuckMsV2(n) { _apActStuckMs = _apPos(n, "apActivityStuckMs"); }
+export function getApActivityStuckMsV2() { return _apActStuckMs; }
+
+export function _resetStateActivityPubBridgeV2() {
+  _apActors.clear(); _apActs.clear();
+  _apMaxActivePerOwner = 15; _apMaxPendingPerActor = 25;
+  _apActorIdleMs = 24 * 60 * 60 * 1000; _apActStuckMs = 3 * 60 * 1000;
+}
+
+export function registerApActorV2({ id, owner, handle, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!owner || typeof owner !== "string") throw new Error("owner is required");
+  if (_apActors.has(id)) throw new Error(`activitypub actor ${id} already registered`);
+  const now = Date.now();
+  const a = { id, owner, handle: handle || id, status: AP_ACTOR_MATURITY_V2.PENDING, createdAt: now, updatedAt: now, activatedAt: null, deactivatedAt: null, lastTouchedAt: now, metadata: { ...(metadata || {}) } };
+  _apActors.set(id, a);
+  return { ...a, metadata: { ...a.metadata } };
+}
+function _apCheckA(from, to) { const al = _apActorTrans.get(from); if (!al || !al.has(to)) throw new Error(`invalid activitypub actor transition ${from} → ${to}`); }
+function _apCountActive(owner) { let n = 0; for (const a of _apActors.values()) if (a.owner === owner && a.status === AP_ACTOR_MATURITY_V2.ACTIVE) n++; return n; }
+
+export function activateApActorV2(id) {
+  const a = _apActors.get(id); if (!a) throw new Error(`activitypub actor ${id} not found`);
+  _apCheckA(a.status, AP_ACTOR_MATURITY_V2.ACTIVE);
+  const recovery = a.status === AP_ACTOR_MATURITY_V2.SUSPENDED;
+  if (!recovery) { const c = _apCountActive(a.owner); if (c >= _apMaxActivePerOwner) throw new Error(`max active activitypub actors per owner (${_apMaxActivePerOwner}) reached for ${a.owner}`); }
+  const now = Date.now(); a.status = AP_ACTOR_MATURITY_V2.ACTIVE; a.updatedAt = now; a.lastTouchedAt = now; if (!a.activatedAt) a.activatedAt = now;
+  return { ...a, metadata: { ...a.metadata } };
+}
+export function suspendApActorV2(id) { const a = _apActors.get(id); if (!a) throw new Error(`activitypub actor ${id} not found`); _apCheckA(a.status, AP_ACTOR_MATURITY_V2.SUSPENDED); a.status = AP_ACTOR_MATURITY_V2.SUSPENDED; a.updatedAt = Date.now(); return { ...a, metadata: { ...a.metadata } }; }
+export function deactivateApActorV2(id) { const a = _apActors.get(id); if (!a) throw new Error(`activitypub actor ${id} not found`); _apCheckA(a.status, AP_ACTOR_MATURITY_V2.DEACTIVATED); const now = Date.now(); a.status = AP_ACTOR_MATURITY_V2.DEACTIVATED; a.updatedAt = now; if (!a.deactivatedAt) a.deactivatedAt = now; return { ...a, metadata: { ...a.metadata } }; }
+export function touchApActorV2(id) { const a = _apActors.get(id); if (!a) throw new Error(`activitypub actor ${id} not found`); if (_apActorTerminal.has(a.status)) throw new Error(`cannot touch terminal activitypub actor ${id}`); const now = Date.now(); a.lastTouchedAt = now; a.updatedAt = now; return { ...a, metadata: { ...a.metadata } }; }
+export function getApActorV2(id) { const a = _apActors.get(id); if (!a) return null; return { ...a, metadata: { ...a.metadata } }; }
+export function listApActorsV2() { return [..._apActors.values()].map((a) => ({ ...a, metadata: { ...a.metadata } })); }
+
+function _apCountPending(aid) { let n = 0; for (const ac of _apActs.values()) if (ac.actorId === aid && (ac.status === AP_ACTIVITY_LIFECYCLE_V2.QUEUED || ac.status === AP_ACTIVITY_LIFECYCLE_V2.DELIVERING)) n++; return n; }
+
+export function createApActivityV2({ id, actorId, kind, metadata } = {}) {
+  if (!id || typeof id !== "string") throw new Error("id is required");
+  if (!actorId || typeof actorId !== "string") throw new Error("actorId is required");
+  if (_apActs.has(id)) throw new Error(`activitypub activity ${id} already exists`);
+  if (!_apActors.has(actorId)) throw new Error(`activitypub actor ${actorId} not found`);
+  const pending = _apCountPending(actorId);
+  if (pending >= _apMaxPendingPerActor) throw new Error(`max pending activitypub activities per actor (${_apMaxPendingPerActor}) reached for ${actorId}`);
+  const now = Date.now();
+  const ac = { id, actorId, kind: kind || "Note", status: AP_ACTIVITY_LIFECYCLE_V2.QUEUED, createdAt: now, updatedAt: now, startedAt: null, settledAt: null, metadata: { ...(metadata || {}) } };
+  _apActs.set(id, ac);
+  return { ...ac, metadata: { ...ac.metadata } };
+}
+function _apCheckAct(from, to) { const al = _apActTrans.get(from); if (!al || !al.has(to)) throw new Error(`invalid activitypub activity transition ${from} → ${to}`); }
+export function startApActivityV2(id) { const ac = _apActs.get(id); if (!ac) throw new Error(`activitypub activity ${id} not found`); _apCheckAct(ac.status, AP_ACTIVITY_LIFECYCLE_V2.DELIVERING); const now = Date.now(); ac.status = AP_ACTIVITY_LIFECYCLE_V2.DELIVERING; ac.updatedAt = now; if (!ac.startedAt) ac.startedAt = now; return { ...ac, metadata: { ...ac.metadata } }; }
+export function deliverApActivityV2(id) { const ac = _apActs.get(id); if (!ac) throw new Error(`activitypub activity ${id} not found`); _apCheckAct(ac.status, AP_ACTIVITY_LIFECYCLE_V2.DELIVERED); const now = Date.now(); ac.status = AP_ACTIVITY_LIFECYCLE_V2.DELIVERED; ac.updatedAt = now; if (!ac.settledAt) ac.settledAt = now; return { ...ac, metadata: { ...ac.metadata } }; }
+export function failApActivityV2(id, reason) { const ac = _apActs.get(id); if (!ac) throw new Error(`activitypub activity ${id} not found`); _apCheckAct(ac.status, AP_ACTIVITY_LIFECYCLE_V2.FAILED); const now = Date.now(); ac.status = AP_ACTIVITY_LIFECYCLE_V2.FAILED; ac.updatedAt = now; if (!ac.settledAt) ac.settledAt = now; if (reason) ac.metadata.failReason = String(reason); return { ...ac, metadata: { ...ac.metadata } }; }
+export function cancelApActivityV2(id, reason) { const ac = _apActs.get(id); if (!ac) throw new Error(`activitypub activity ${id} not found`); _apCheckAct(ac.status, AP_ACTIVITY_LIFECYCLE_V2.CANCELLED); const now = Date.now(); ac.status = AP_ACTIVITY_LIFECYCLE_V2.CANCELLED; ac.updatedAt = now; if (!ac.settledAt) ac.settledAt = now; if (reason) ac.metadata.cancelReason = String(reason); return { ...ac, metadata: { ...ac.metadata } }; }
+export function getApActivityV2(id) { const ac = _apActs.get(id); if (!ac) return null; return { ...ac, metadata: { ...ac.metadata } }; }
+export function listApActivitiesV2() { return [..._apActs.values()].map((ac) => ({ ...ac, metadata: { ...ac.metadata } })); }
+
+export function autoSuspendIdleApActorsV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const a of _apActors.values()) if (a.status === AP_ACTOR_MATURITY_V2.ACTIVE && (t - a.lastTouchedAt) >= _apActorIdleMs) { a.status = AP_ACTOR_MATURITY_V2.SUSPENDED; a.updatedAt = t; flipped.push(a.id); } return { flipped, count: flipped.length }; }
+export function autoFailStuckApActivitiesV2({ now } = {}) { const t = now ?? Date.now(); const flipped = []; for (const ac of _apActs.values()) if (ac.status === AP_ACTIVITY_LIFECYCLE_V2.DELIVERING && ac.startedAt != null && (t - ac.startedAt) >= _apActStuckMs) { ac.status = AP_ACTIVITY_LIFECYCLE_V2.FAILED; ac.updatedAt = t; if (!ac.settledAt) ac.settledAt = t; ac.metadata.failReason = "auto-fail-stuck"; flipped.push(ac.id); } return { flipped, count: flipped.length }; }
+
+export function getActivityPubBridgeStatsV2() {
+  const actorsByStatus = {}; for (const s of Object.values(AP_ACTOR_MATURITY_V2)) actorsByStatus[s] = 0; for (const a of _apActors.values()) actorsByStatus[a.status]++;
+  const activitiesByStatus = {}; for (const s of Object.values(AP_ACTIVITY_LIFECYCLE_V2)) activitiesByStatus[s] = 0; for (const ac of _apActs.values()) activitiesByStatus[ac.status]++;
+  return { totalActorsV2: _apActors.size, totalActivitiesV2: _apActs.size, maxActiveApActorsPerOwner: _apMaxActivePerOwner, maxPendingApActivitiesPerActor: _apMaxPendingPerActor, apActorIdleMs: _apActorIdleMs, apActivityStuckMs: _apActStuckMs, actorsByStatus, activitiesByStatus };
+}