chainlesschain 0.152.0 → 0.156.2

package/src/commands/workflow.js

@@ -1051,3 +1051,212 @@ export function registerWfgovV2Commands(program) {
       );
     });
 }
+
+// === Iter26 V2 governance overlay ===
+export function registerWfexgovV2Commands(program) {
+  const parent = program.commands.find((c) => c.name() === "workflow");
+  if (!parent) return;
+  const L = async () => await import("../lib/workflow-expr.js");
+  parent
+    .command("wfexgov-enums-v2")
+    .description("Show V2 enums")
+    .action(async () => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          {
+            profileMaturity: m.WFEXGOV_PROFILE_MATURITY_V2,
+            evalLifecycle: m.WFEXGOV_EVAL_LIFECYCLE_V2,
+          },
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfexgov-config-v2")
+    .description("Show V2 config")
+    .action(async () => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          {
+            maxActive: m.getMaxActiveWfexgovProfilesPerOwnerV2(),
+            maxPending: m.getMaxPendingWfexgovEvalsPerProfileV2(),
+            idleMs: m.getWfexgovProfileIdleMsV2(),
+            stuckMs: m.getWfexgovEvalStuckMsV2(),
+          },
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfexgov-set-max-active-v2 <n>")
+    .description("Set max active")
+    .action(async (n) => {
+      (await L()).setMaxActiveWfexgovProfilesPerOwnerV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfexgov-set-max-pending-v2 <n>")
+    .description("Set max pending")
+    .action(async (n) => {
+      (await L()).setMaxPendingWfexgovEvalsPerProfileV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfexgov-set-idle-ms-v2 <n>")
+    .description("Set idle threshold ms")
+    .action(async (n) => {
+      (await L()).setWfexgovProfileIdleMsV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfexgov-set-stuck-ms-v2 <n>")
+    .description("Set stuck threshold ms")
+    .action(async (n) => {
+      (await L()).setWfexgovEvalStuckMsV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfexgov-register-v2 <id> <owner>")
+    .description("Register V2 profile")
+    .option("--language <v>", "language")
+    .action(async (id, owner, o) => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          m.registerWfexgovProfileV2({ id, owner, language: o.language }),
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfexgov-activate-v2 <id>")
+    .description("Activate profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).activateWfexgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-pause-v2 <id>")
+    .description("Pause profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).pauseWfexgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-archive-v2 <id>")
+    .description("Archive profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).archiveWfexgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-touch-v2 <id>")
+    .description("Touch profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).touchWfexgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-get-v2 <id>")
+    .description("Get profile")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).getWfexgovProfileV2(id), null, 2));
+    });
+  parent
+    .command("wfexgov-list-v2")
+    .description("List profiles")
+    .action(async () => {
+      console.log(JSON.stringify((await L()).listWfexgovProfilesV2(), null, 2));
+    });
+  parent
+    .command("wfexgov-create-eval-v2 <id> <profileId>")
+    .description("Create eval")
+    .option("--expression <v>", "expression")
+    .action(async (id, profileId, o) => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          m.createWfexgovEvalV2({ id, profileId, expression: o.expression }),
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfexgov-evaluating-eval-v2 <id>")
+    .description("Mark eval as evaluating")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).evaluatingWfexgovEvalV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-complete-eval-v2 <id>")
+    .description("Complete eval")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).completeEvalWfexgovV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-fail-eval-v2 <id> [reason]")
+    .description("Fail eval")
+    .action(async (id, reason) => {
+      console.log(
+        JSON.stringify((await L()).failWfexgovEvalV2(id, reason), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-cancel-eval-v2 <id> [reason]")
+    .description("Cancel eval")
+    .action(async (id, reason) => {
+      console.log(
+        JSON.stringify((await L()).cancelWfexgovEvalV2(id, reason), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-get-eval-v2 <id>")
+    .description("Get eval")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).getWfexgovEvalV2(id), null, 2));
+    });
+  parent
+    .command("wfexgov-list-evals-v2")
+    .description("List evals")
+    .action(async () => {
+      console.log(JSON.stringify((await L()).listWfexgovEvalsV2(), null, 2));
+    });
+  parent
+    .command("wfexgov-auto-pause-idle-v2")
+    .description("Auto-pause idle")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).autoPauseIdleWfexgovProfilesV2(), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-auto-fail-stuck-v2")
+    .description("Auto-fail stuck evals")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).autoFailStuckWfexgovEvalsV2(), null, 2),
+      );
+    });
+  parent
+    .command("wfexgov-gov-stats-v2")
+    .description("V2 gov stats")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).getWorkflowExprGovStatsV2(), null, 2),
+      );
+    });
+}

package/src/index.js

@@ -299,6 +299,62 @@ import { registerDevgovV2Commands } from "./commands/dev.js";
 import { registerTigovV2Commands } from "./commands/compliance.js";
 import { registerUebgovV2Commands } from "./commands/compliance.js";
 
+// Iter25 V2 governance overlays
+import { registerCttgovV2Commands } from "./commands/cowork.js";
+import { registerCtmgovV2Commands } from "./commands/cowork.js";
+import { registerClibgovV2Commands } from "./commands/cli-anything.js";
+import { registerArgovV2Commands } from "./commands/orchestrate.js";
+import { registerSaregovV2Commands } from "./commands/agent.js";
+import { registerTodogovV2Commands } from "./commands/agent.js";
+import { registerEbgovV2Commands } from "./commands/agent.js";
+import { registerEvfedgovV2Commands } from "./commands/evomap.js";
+
+// Iter26 V2 governance overlays
+import { registerPlannergovV2Commands } from "./commands/planmode.js";
+import { registerCtxenggovV2Commands } from "./commands/cli-anything.js";
+import { registerSactxgovV2Commands } from "./commands/agent.js";
+import { registerIagovV2Commands } from "./commands/chat.js";
+import { registerWfexgovV2Commands } from "./commands/workflow.js";
+import { registerPadgovV2Commands } from "./commands/plugin.js";
+import { registerHlgovV2Commands } from "./commands/memory.js";
+import { registerWebuigovV2Commands } from "./commands/ui.js";
+
+// Iter27 V2 governance overlays
+import { registerDlgovV2Commands } from "./commands/setup.js";
+import { registerSmcpgovV2Commands } from "./commands/skill.js";
+import { registerCmcpgovV2Commands } from "./commands/cowork.js";
+import { registerStixgovV2Commands } from "./commands/compliance.js";
+import { registerSapgovV2Commands } from "./commands/agent.js";
+import { registerCobsgovV2Commands } from "./commands/cowork.js";
+import { registerPmgrgovV2Commands } from "./commands/start.js";
+import { registerWscgovV2Commands } from "./commands/chat.js";
+import { registerEvcligovV2Commands } from "./commands/evomap.js";
+import { registerPoptgovV2Commands } from "./commands/llm.js";
+import { registerScsgovV2Commands } from "./commands/config.js";
+import { registerSmgrgovV2Commands } from "./commands/services.js";
+import { registerCeadgovV2Commands } from "./commands/cowork.js";
+import { registerPstrmgovV2Commands } from "./commands/stream.js";
+import { registerCohtgovV2Commands } from "./commands/cowork.js";
+import { registerCadpgovV2Commands } from "./commands/cowork.js";
+
+// Iter28 V2 governance overlays
+import { registerA2apV2Commands } from "./commands/a2a.js";
+import { registerAcrdV2Commands } from "./commands/orchestrate.js";
+import { registerAecoV2Commands } from "./commands/economy.js";
+import { registerAutagV2Commands } from "./commands/agent.js";
+import { registerCcoreV2Commands } from "./commands/chat.js";
+import { registerCmpmV2Commands } from "./commands/compliance.js";
+import { registerCrchV2Commands } from "./commands/crosschain.js";
+import { registerCryV2Commands } from "./commands/encrypt.js";
+import { registerDaomV2Commands } from "./commands/dao.js";
+import { registerEsysV2Commands } from "./commands/evolution.js";
+import { registerEmgrV2Commands } from "./commands/evomap.js";
+import { registerHmemV2Commands } from "./commands/hmemory.js";
+import { registerInfnetV2Commands } from "./commands/inference.js";
+import { registerKgV2Commands } from "./commands/kg.js";
+import { registerPmodeV2Commands } from "./commands/planmode.js";
+import { registerPipoV2Commands } from "./commands/pipeline.js";
+
 export function createProgram() {
   const program = new Command();
 
@@ -608,5 +664,61 @@ export function createProgram() {
   registerTigovV2Commands(program);
   registerUebgovV2Commands(program);
 
+  // Iter25 V2 governance overlays
+  registerCttgovV2Commands(program);
+  registerCtmgovV2Commands(program);
+  registerClibgovV2Commands(program);
+  registerArgovV2Commands(program);
+  registerSaregovV2Commands(program);
+  registerTodogovV2Commands(program);
+  registerEbgovV2Commands(program);
+  registerEvfedgovV2Commands(program);
+
+  // Iter26 V2 governance overlays
+  registerPlannergovV2Commands(program);
+  registerCtxenggovV2Commands(program);
+  registerSactxgovV2Commands(program);
+  registerIagovV2Commands(program);
+  registerWfexgovV2Commands(program);
+  registerPadgovV2Commands(program);
+  registerHlgovV2Commands(program);
+  registerWebuigovV2Commands(program);
+
+  // Iter27 V2 governance overlays
+  registerDlgovV2Commands(program);
+  registerSmcpgovV2Commands(program);
+  registerCmcpgovV2Commands(program);
+  registerStixgovV2Commands(program);
+  registerSapgovV2Commands(program);
+  registerCobsgovV2Commands(program);
+  registerPmgrgovV2Commands(program);
+  registerWscgovV2Commands(program);
+  registerEvcligovV2Commands(program);
+  registerPoptgovV2Commands(program);
+  registerScsgovV2Commands(program);
+  registerSmgrgovV2Commands(program);
+  registerCeadgovV2Commands(program);
+  registerPstrmgovV2Commands(program);
+  registerCohtgovV2Commands(program);
+  registerCadpgovV2Commands(program);
+
+  // Iter28 V2 governance overlays
+  registerA2apV2Commands(program);
+  registerAcrdV2Commands(program);
+  registerAecoV2Commands(program);
+  registerAutagV2Commands(program);
+  registerCcoreV2Commands(program);
+  registerCmpmV2Commands(program);
+  registerCrchV2Commands(program);
+  registerCryV2Commands(program);
+  registerDaomV2Commands(program);
+  registerEsysV2Commands(program);
+  registerEmgrV2Commands(program);
+  registerHmemV2Commands(program);
+  registerInfnetV2Commands(program);
+  registerKgV2Commands(program);
+  registerPmodeV2Commands(program);
+  registerPipoV2Commands(program);
+
   return program;
 }

package/src/lib/a2a-protocol.js

@@ -1193,3 +1193,335 @@ export function getA2aProtocolGovStatsV2() {
     messagesByStatus,
   };
 }
+
+// === Iter28 V2 governance overlay: A2apgov ===
+export const A2APGOV_PROFILE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  STALE: "stale",
+  ARCHIVED: "archived",
+});
+export const A2APGOV_MSG_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  DISPATCHING: "dispatching",
+  DELIVERED: "delivered",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+const _a2apgovPTrans = new Map([
+  [
+    A2APGOV_PROFILE_MATURITY_V2.PENDING,
+    new Set([
+      A2APGOV_PROFILE_MATURITY_V2.ACTIVE,
+      A2APGOV_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [
+    A2APGOV_PROFILE_MATURITY_V2.ACTIVE,
+    new Set([
+      A2APGOV_PROFILE_MATURITY_V2.STALE,
+      A2APGOV_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [
+    A2APGOV_PROFILE_MATURITY_V2.STALE,
+    new Set([
+      A2APGOV_PROFILE_MATURITY_V2.ACTIVE,
+      A2APGOV_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [A2APGOV_PROFILE_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _a2apgovPTerminal = new Set([A2APGOV_PROFILE_MATURITY_V2.ARCHIVED]);
+const _a2apgovJTrans = new Map([
+  [
+    A2APGOV_MSG_LIFECYCLE_V2.QUEUED,
+    new Set([
+      A2APGOV_MSG_LIFECYCLE_V2.DISPATCHING,
+      A2APGOV_MSG_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [
+    A2APGOV_MSG_LIFECYCLE_V2.DISPATCHING,
+    new Set([
+      A2APGOV_MSG_LIFECYCLE_V2.DELIVERED,
+      A2APGOV_MSG_LIFECYCLE_V2.FAILED,
+      A2APGOV_MSG_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [A2APGOV_MSG_LIFECYCLE_V2.DELIVERED, new Set()],
+  [A2APGOV_MSG_LIFECYCLE_V2.FAILED, new Set()],
+  [A2APGOV_MSG_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _a2apgovPsV2 = new Map();
+const _a2apgovJsV2 = new Map();
+let _a2apgovMaxActive = 8,
+  _a2apgovMaxPending = 20,
+  _a2apgovIdleMs = 2592000000,
+  _a2apgovStuckMs = 60 * 1000;
+function _a2apgovPos(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 _a2apgovCheckP(from, to) {
+  const a = _a2apgovPTrans.get(from);
+  if (!a || !a.has(to))
+    throw new Error(`invalid a2apgov profile transition ${from} → ${to}`);
+}
+function _a2apgovCheckJ(from, to) {
+  const a = _a2apgovJTrans.get(from);
+  if (!a || !a.has(to))
+    throw new Error(`invalid a2apgov msg transition ${from} → ${to}`);
+}
+function _a2apgovCountActive(owner) {
+  let c = 0;
+  for (const p of _a2apgovPsV2.values())
+    if (p.owner === owner && p.status === A2APGOV_PROFILE_MATURITY_V2.ACTIVE)
+      c++;
+  return c;
+}
+function _a2apgovCountPending(profileId) {
+  let c = 0;
+  for (const j of _a2apgovJsV2.values())
+    if (
+      j.profileId === profileId &&
+      (j.status === A2APGOV_MSG_LIFECYCLE_V2.QUEUED ||
+        j.status === A2APGOV_MSG_LIFECYCLE_V2.DISPATCHING)
+    )
+      c++;
+  return c;
+}
+export function setMaxActiveA2apProfilesPerOwnerV2(n) {
+  _a2apgovMaxActive = _a2apgovPos(n, "maxActiveA2apProfilesPerOwner");
+}
+export function getMaxActiveA2apProfilesPerOwnerV2() {
+  return _a2apgovMaxActive;
+}
+export function setMaxPendingA2apMsgsPerProfileV2(n) {
+  _a2apgovMaxPending = _a2apgovPos(n, "maxPendingA2apMsgsPerProfile");
+}
+export function getMaxPendingA2apMsgsPerProfileV2() {
+  return _a2apgovMaxPending;
+}
+export function setA2apProfileIdleMsV2(n) {
+  _a2apgovIdleMs = _a2apgovPos(n, "a2apgovProfileIdleMs");
+}
+export function getA2apProfileIdleMsV2() {
+  return _a2apgovIdleMs;
+}
+export function setA2apMsgStuckMsV2(n) {
+  _a2apgovStuckMs = _a2apgovPos(n, "a2apgovMsgStuckMs");
+}
+export function getA2apMsgStuckMsV2() {
+  return _a2apgovStuckMs;
+}
+export function _resetStateA2apgovV2() {
+  _a2apgovPsV2.clear();
+  _a2apgovJsV2.clear();
+  _a2apgovMaxActive = 8;
+  _a2apgovMaxPending = 20;
+  _a2apgovIdleMs = 2592000000;
+  _a2apgovStuckMs = 60 * 1000;
+}
+export function registerA2apProfileV2({ id, owner, endpoint, metadata } = {}) {
+  if (!id || !owner) throw new Error("id and owner required");
+  if (_a2apgovPsV2.has(id))
+    throw new Error(`a2apgov profile ${id} already exists`);
+  const now = Date.now();
+  const p = {
+    id,
+    owner,
+    endpoint: endpoint || "default",
+    status: A2APGOV_PROFILE_MATURITY_V2.PENDING,
+    createdAt: now,
+    updatedAt: now,
+    lastTouchedAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: { ...(metadata || {}) },
+  };
+  _a2apgovPsV2.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function activateA2apProfileV2(id) {
+  const p = _a2apgovPsV2.get(id);
+  if (!p) throw new Error(`a2apgov profile ${id} not found`);
+  const isInitial = p.status === A2APGOV_PROFILE_MATURITY_V2.PENDING;
+  _a2apgovCheckP(p.status, A2APGOV_PROFILE_MATURITY_V2.ACTIVE);
+  if (isInitial && _a2apgovCountActive(p.owner) >= _a2apgovMaxActive)
+    throw new Error(`max active a2apgov profiles for owner ${p.owner} reached`);
+  const now = Date.now();
+  p.status = A2APGOV_PROFILE_MATURITY_V2.ACTIVE;
+  p.updatedAt = now;
+  p.lastTouchedAt = now;
+  if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function staleA2apProfileV2(id) {
+  const p = _a2apgovPsV2.get(id);
+  if (!p) throw new Error(`a2apgov profile ${id} not found`);
+  _a2apgovCheckP(p.status, A2APGOV_PROFILE_MATURITY_V2.STALE);
+  p.status = A2APGOV_PROFILE_MATURITY_V2.STALE;
+  p.updatedAt = Date.now();
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function archiveA2apProfileV2(id) {
+  const p = _a2apgovPsV2.get(id);
+  if (!p) throw new Error(`a2apgov profile ${id} not found`);
+  _a2apgovCheckP(p.status, A2APGOV_PROFILE_MATURITY_V2.ARCHIVED);
+  const now = Date.now();
+  p.status = A2APGOV_PROFILE_MATURITY_V2.ARCHIVED;
+  p.updatedAt = now;
+  if (!p.archivedAt) p.archivedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function touchA2apProfileV2(id) {
+  const p = _a2apgovPsV2.get(id);
+  if (!p) throw new Error(`a2apgov profile ${id} not found`);
+  if (_a2apgovPTerminal.has(p.status))
+    throw new Error(`cannot touch terminal a2apgov profile ${id}`);
+  const now = Date.now();
+  p.lastTouchedAt = now;
+  p.updatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function getA2apProfileV2(id) {
+  const p = _a2apgovPsV2.get(id);
+  if (!p) return null;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function listA2apProfilesV2() {
+  return [..._a2apgovPsV2.values()].map((p) => ({
+    ...p,
+    metadata: { ...p.metadata },
+  }));
+}
+export function createA2apMsgV2({ id, profileId, messageId, metadata } = {}) {
+  if (!id || !profileId) throw new Error("id and profileId required");
+  if (_a2apgovJsV2.has(id)) throw new Error(`a2apgov msg ${id} already exists`);
+  if (!_a2apgovPsV2.has(profileId))
+    throw new Error(`a2apgov profile ${profileId} not found`);
+  if (_a2apgovCountPending(profileId) >= _a2apgovMaxPending)
+    throw new Error(
+      `max pending a2apgov msgs for profile ${profileId} reached`,
+    );
+  const now = Date.now();
+  const j = {
+    id,
+    profileId,
+    messageId: messageId || "",
+    status: A2APGOV_MSG_LIFECYCLE_V2.QUEUED,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: null,
+    settledAt: null,
+    metadata: { ...(metadata || {}) },
+  };
+  _a2apgovJsV2.set(id, j);
+  return { ...j, metadata: { ...j.metadata } };
+}
+export function dispatchingA2apMsgV2(id) {
+  const j = _a2apgovJsV2.get(id);
+  if (!j) throw new Error(`a2apgov msg ${id} not found`);
+  _a2apgovCheckJ(j.status, A2APGOV_MSG_LIFECYCLE_V2.DISPATCHING);
+  const now = Date.now();
+  j.status = A2APGOV_MSG_LIFECYCLE_V2.DISPATCHING;
+  j.updatedAt = now;
+  if (!j.startedAt) j.startedAt = now;
+  return { ...j, metadata: { ...j.metadata } };
+}
+export function completeMsgA2apV2(id) {
+  const j = _a2apgovJsV2.get(id);
+  if (!j) throw new Error(`a2apgov msg ${id} not found`);
+  _a2apgovCheckJ(j.status, A2APGOV_MSG_LIFECYCLE_V2.DELIVERED);
+  const now = Date.now();
+  j.status = A2APGOV_MSG_LIFECYCLE_V2.DELIVERED;
+  j.updatedAt = now;
+  if (!j.settledAt) j.settledAt = now;
+  return { ...j, metadata: { ...j.metadata } };
+}
+export function failA2apMsgV2(id, reason) {
+  const j = _a2apgovJsV2.get(id);
+  if (!j) throw new Error(`a2apgov msg ${id} not found`);
+  _a2apgovCheckJ(j.status, A2APGOV_MSG_LIFECYCLE_V2.FAILED);
+  const now = Date.now();
+  j.status = A2APGOV_MSG_LIFECYCLE_V2.FAILED;
+  j.updatedAt = now;
+  if (!j.settledAt) j.settledAt = now;
+  if (reason) j.metadata.failReason = String(reason);
+  return { ...j, metadata: { ...j.metadata } };
+}
+export function cancelA2apMsgV2(id, reason) {
+  const j = _a2apgovJsV2.get(id);
+  if (!j) throw new Error(`a2apgov msg ${id} not found`);
+  _a2apgovCheckJ(j.status, A2APGOV_MSG_LIFECYCLE_V2.CANCELLED);
+  const now = Date.now();
+  j.status = A2APGOV_MSG_LIFECYCLE_V2.CANCELLED;
+  j.updatedAt = now;
+  if (!j.settledAt) j.settledAt = now;
+  if (reason) j.metadata.cancelReason = String(reason);
+  return { ...j, metadata: { ...j.metadata } };
+}
+export function getA2apMsgV2(id) {
+  const j = _a2apgovJsV2.get(id);
+  if (!j) return null;
+  return { ...j, metadata: { ...j.metadata } };
+}
+export function listA2apMsgsV2() {
+  return [..._a2apgovJsV2.values()].map((j) => ({
+    ...j,
+    metadata: { ...j.metadata },
+  }));
+}
+export function autoStaleIdleA2apProfilesV2({ now } = {}) {
+  const t = now ?? Date.now();
+  const flipped = [];
+  for (const p of _a2apgovPsV2.values())
+    if (
+      p.status === A2APGOV_PROFILE_MATURITY_V2.ACTIVE &&
+      t - p.lastTouchedAt >= _a2apgovIdleMs
+    ) {
+      p.status = A2APGOV_PROFILE_MATURITY_V2.STALE;
+      p.updatedAt = t;
+      flipped.push(p.id);
+    }
+  return { flipped, count: flipped.length };
+}
+export function autoFailStuckA2apMsgsV2({ now } = {}) {
+  const t = now ?? Date.now();
+  const flipped = [];
+  for (const j of _a2apgovJsV2.values())
+    if (
+      j.status === A2APGOV_MSG_LIFECYCLE_V2.DISPATCHING &&
+      j.startedAt != null &&
+      t - j.startedAt >= _a2apgovStuckMs
+    ) {
+      j.status = A2APGOV_MSG_LIFECYCLE_V2.FAILED;
+      j.updatedAt = t;
+      if (!j.settledAt) j.settledAt = t;
+      j.metadata.failReason = "auto-fail-stuck";
+      flipped.push(j.id);
+    }
+  return { flipped, count: flipped.length };
+}
+export function getA2apgovStatsV2() {
+  const profilesByStatus = {};
+  for (const v of Object.values(A2APGOV_PROFILE_MATURITY_V2))
+    profilesByStatus[v] = 0;
+  for (const p of _a2apgovPsV2.values()) profilesByStatus[p.status]++;
+  const msgsByStatus = {};
+  for (const v of Object.values(A2APGOV_MSG_LIFECYCLE_V2)) msgsByStatus[v] = 0;
+  for (const j of _a2apgovJsV2.values()) msgsByStatus[j.status]++;
+  return {
+    totalA2apProfilesV2: _a2apgovPsV2.size,
+    totalA2apMsgsV2: _a2apgovJsV2.size,
+    maxActiveA2apProfilesPerOwner: _a2apgovMaxActive,
+    maxPendingA2apMsgsPerProfile: _a2apgovMaxPending,
+    a2apgovProfileIdleMs: _a2apgovIdleMs,
+    a2apgovMsgStuckMs: _a2apgovStuckMs,
+    profilesByStatus,
+    msgsByStatus,
+  };
+}