chainlesschain 0.145.0 → 0.152.0

package/src/commands/wallet.js

@@ -691,3 +691,212 @@ export function registerWalletCommand(program) {
       console.log(JSON.stringify(autoFailStuckTxV2(), null, 2));
     });
 }
+
+// === Iter20 V2 governance overlay ===
+export function registerWalgovV2Commands(program) {
+  const parent = program.commands.find((c) => c.name() === "wallet");
+  if (!parent) return;
+  const L = async () => await import("../lib/wallet-manager.js");
+  parent
+    .command("walgov-enums-v2")
+    .description("Show V2 enums")
+    .action(async () => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          {
+            profileMaturity: m.WALGOV_PROFILE_MATURITY_V2,
+            transferLifecycle: m.WALGOV_TRANSFER_LIFECYCLE_V2,
+          },
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("walgov-config-v2")
+    .description("Show V2 config")
+    .action(async () => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          {
+            maxActive: m.getMaxActiveWalgovProfilesPerOwnerV2(),
+            maxPending: m.getMaxPendingWalgovTransfersPerProfileV2(),
+            idleMs: m.getWalgovProfileIdleMsV2(),
+            stuckMs: m.getWalgovTransferStuckMsV2(),
+          },
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("walgov-set-max-active-v2 <n>")
+    .description("Set max active")
+    .action(async (n) => {
+      (await L()).setMaxActiveWalgovProfilesPerOwnerV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("walgov-set-max-pending-v2 <n>")
+    .description("Set max pending")
+    .action(async (n) => {
+      (await L()).setMaxPendingWalgovTransfersPerProfileV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("walgov-set-idle-ms-v2 <n>")
+    .description("Set idle threshold ms")
+    .action(async (n) => {
+      (await L()).setWalgovProfileIdleMsV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("walgov-set-stuck-ms-v2 <n>")
+    .description("Set stuck threshold ms")
+    .action(async (n) => {
+      (await L()).setWalgovTransferStuckMsV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("walgov-register-v2 <id> <owner>")
+    .description("Register V2 profile")
+    .option("--chain <v>", "chain")
+    .action(async (id, owner, o) => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          m.registerWalgovProfileV2({ id, owner, chain: o.chain }),
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("walgov-activate-v2 <id>")
+    .description("Activate profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).activateWalgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("walgov-freeze-v2 <id>")
+    .description("Freeze profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).freezeWalgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("walgov-archive-v2 <id>")
+    .description("Archive profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).archiveWalgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("walgov-touch-v2 <id>")
+    .description("Touch profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).touchWalgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("walgov-get-v2 <id>")
+    .description("Get profile")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).getWalgovProfileV2(id), null, 2));
+    });
+  parent
+    .command("walgov-list-v2")
+    .description("List profiles")
+    .action(async () => {
+      console.log(JSON.stringify((await L()).listWalgovProfilesV2(), null, 2));
+    });
+  parent
+    .command("walgov-create-transfer-v2 <id> <profileId>")
+    .description("Create transfer")
+    .option("--to <v>", "to")
+    .action(async (id, profileId, o) => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          m.createWalgovTransferV2({ id, profileId, to: o.to }),
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("walgov-signing-transfer-v2 <id>")
+    .description("Mark transfer as signing")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).signingWalgovTransferV2(id), null, 2),
+      );
+    });
+  parent
+    .command("walgov-complete-transfer-v2 <id>")
+    .description("Complete transfer")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).completeTransferWalgovV2(id), null, 2),
+      );
+    });
+  parent
+    .command("walgov-fail-transfer-v2 <id> [reason]")
+    .description("Fail transfer")
+    .action(async (id, reason) => {
+      console.log(
+        JSON.stringify((await L()).failWalgovTransferV2(id, reason), null, 2),
+      );
+    });
+  parent
+    .command("walgov-cancel-transfer-v2 <id> [reason]")
+    .description("Cancel transfer")
+    .action(async (id, reason) => {
+      console.log(
+        JSON.stringify((await L()).cancelWalgovTransferV2(id, reason), null, 2),
+      );
+    });
+  parent
+    .command("walgov-get-transfer-v2 <id>")
+    .description("Get transfer")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).getWalgovTransferV2(id), null, 2));
+    });
+  parent
+    .command("walgov-list-transfers-v2")
+    .description("List transfers")
+    .action(async () => {
+      console.log(JSON.stringify((await L()).listWalgovTransfersV2(), null, 2));
+    });
+  parent
+    .command("walgov-auto-freeze-idle-v2")
+    .description("Auto-freeze idle")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).autoFreezeIdleWalgovProfilesV2(), null, 2),
+      );
+    });
+  parent
+    .command("walgov-auto-fail-stuck-v2")
+    .description("Auto-fail stuck transfers")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).autoFailStuckWalgovTransfersV2(), null, 2),
+      );
+    });
+  parent
+    .command("walgov-gov-stats-v2")
+    .description("V2 gov stats")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).getWalletManagerGovStatsV2(), null, 2),
+      );
+    });
+}

package/src/commands/workflow.js

@@ -848,3 +848,206 @@ export function registerWorkflowCommand(program) {
     .description("V2 auto-fail stuck")
     .action(() => _v2json(autoFailStuckRunsV2()));
 }
+
+// === Iter21 V2 governance overlay ===
+export function registerWfgovV2Commands(program) {
+  const parent = program.commands.find((c) => c.name() === "workflow");
+  if (!parent) return;
+  const L = async () => await import("../lib/workflow-engine.js");
+  parent
+    .command("wfgov-enums-v2")
+    .description("Show V2 enums")
+    .action(async () => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          {
+            profileMaturity: m.WFGOV_PROFILE_MATURITY_V2,
+            stepLifecycle: m.WFGOV_STEP_LIFECYCLE_V2,
+          },
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfgov-config-v2")
+    .description("Show V2 config")
+    .action(async () => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          {
+            maxActive: m.getMaxActiveWfgovProfilesPerOwnerV2(),
+            maxPending: m.getMaxPendingWfgovStepsPerProfileV2(),
+            idleMs: m.getWfgovProfileIdleMsV2(),
+            stuckMs: m.getWfgovStepStuckMsV2(),
+          },
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfgov-set-max-active-v2 <n>")
+    .description("Set max active")
+    .action(async (n) => {
+      (await L()).setMaxActiveWfgovProfilesPerOwnerV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfgov-set-max-pending-v2 <n>")
+    .description("Set max pending")
+    .action(async (n) => {
+      (await L()).setMaxPendingWfgovStepsPerProfileV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfgov-set-idle-ms-v2 <n>")
+    .description("Set idle threshold ms")
+    .action(async (n) => {
+      (await L()).setWfgovProfileIdleMsV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfgov-set-stuck-ms-v2 <n>")
+    .description("Set stuck threshold ms")
+    .action(async (n) => {
+      (await L()).setWfgovStepStuckMsV2(Number(n));
+      console.log("ok");
+    });
+  parent
+    .command("wfgov-register-v2 <id> <owner>")
+    .description("Register V2 profile")
+    .option("--kind <v>", "kind")
+    .action(async (id, owner, o) => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          m.registerWfgovProfileV2({ id, owner, kind: o.kind }),
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfgov-activate-v2 <id>")
+    .description("Activate profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).activateWfgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfgov-pause-v2 <id>")
+    .description("Pause profile")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).pauseWfgovProfileV2(id), null, 2));
+    });
+  parent
+    .command("wfgov-archive-v2 <id>")
+    .description("Archive profile")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).archiveWfgovProfileV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfgov-touch-v2 <id>")
+    .description("Touch profile")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).touchWfgovProfileV2(id), null, 2));
+    });
+  parent
+    .command("wfgov-get-v2 <id>")
+    .description("Get profile")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).getWfgovProfileV2(id), null, 2));
+    });
+  parent
+    .command("wfgov-list-v2")
+    .description("List profiles")
+    .action(async () => {
+      console.log(JSON.stringify((await L()).listWfgovProfilesV2(), null, 2));
+    });
+  parent
+    .command("wfgov-create-step-v2 <id> <profileId>")
+    .description("Create step")
+    .option("--stepName <v>", "stepName")
+    .action(async (id, profileId, o) => {
+      const m = await L();
+      console.log(
+        JSON.stringify(
+          m.createWfgovStepV2({ id, profileId, stepName: o.stepName }),
+          null,
+          2,
+        ),
+      );
+    });
+  parent
+    .command("wfgov-executing-step-v2 <id>")
+    .description("Mark step as executing")
+    .action(async (id) => {
+      console.log(
+        JSON.stringify((await L()).executingWfgovStepV2(id), null, 2),
+      );
+    });
+  parent
+    .command("wfgov-complete-step-v2 <id>")
+    .description("Complete step")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).completeStepWfgovV2(id), null, 2));
+    });
+  parent
+    .command("wfgov-fail-step-v2 <id> [reason]")
+    .description("Fail step")
+    .action(async (id, reason) => {
+      console.log(
+        JSON.stringify((await L()).failWfgovStepV2(id, reason), null, 2),
+      );
+    });
+  parent
+    .command("wfgov-cancel-step-v2 <id> [reason]")
+    .description("Cancel step")
+    .action(async (id, reason) => {
+      console.log(
+        JSON.stringify((await L()).cancelWfgovStepV2(id, reason), null, 2),
+      );
+    });
+  parent
+    .command("wfgov-get-step-v2 <id>")
+    .description("Get step")
+    .action(async (id) => {
+      console.log(JSON.stringify((await L()).getWfgovStepV2(id), null, 2));
+    });
+  parent
+    .command("wfgov-list-steps-v2")
+    .description("List steps")
+    .action(async () => {
+      console.log(JSON.stringify((await L()).listWfgovStepsV2(), null, 2));
+    });
+  parent
+    .command("wfgov-auto-pause-idle-v2")
+    .description("Auto-pause idle")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).autoPauseIdleWfgovProfilesV2(), null, 2),
+      );
+    });
+  parent
+    .command("wfgov-auto-fail-stuck-v2")
+    .description("Auto-fail stuck steps")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).autoFailStuckWfgovStepsV2(), null, 2),
+      );
+    });
+  parent
+    .command("wfgov-gov-stats-v2")
+    .description("V2 gov stats")
+    .action(async () => {
+      console.log(
+        JSON.stringify((await L()).getWorkflowEngineGovStatsV2(), null, 2),
+      );
+    });
+}

package/src/index.js

@@ -229,6 +229,76 @@ import { registerPcgovV2Commands } from "./commands/privacy.js";
 import { registerIncgovV2Commands } from "./commands/incentive.js";
 import { registerHardgovV2Commands } from "./commands/hardening.js";
 
+// Iter18 V2 governance overlays
+import { registerAiopsgovV2Commands } from "./commands/ops.js";
+import { registerMmgovV2Commands } from "./commands/multimodal.js";
+import { registerInstgovV2Commands } from "./commands/instinct.js";
+import { registerTnsgovV2Commands } from "./commands/tenant.js";
+import { registerQntgovV2Commands } from "./commands/quantization.js";
+import { registerTrustgovV2Commands } from "./commands/trust.js";
+import { registerNlpgovV2Commands } from "./commands/nlprog.js";
+import { registerPercgovV2Commands } from "./commands/perception.js";
+
+// Iter19 V2 governance overlays
+import { registerCdagovV2Commands } from "./commands/codegen.js";
+import { registerCogovV2Commands } from "./commands/collab.js";
+import { registerCommgovV2Commands } from "./commands/governance.js";
+import { registerDidgovV2Commands } from "./commands/did.js";
+import { registerSsogovV2Commands } from "./commands/sso.js";
+import { registerOrggovV2Commands } from "./commands/org.js";
+import { registerScimgovV2Commands } from "./commands/scim.js";
+import { registerSyncgovV2Commands } from "./commands/sync.js";
+
+// Iter20 V2 governance overlays
+import { registerAnetgovV2Commands } from "./commands/agent-network.js";
+import { registerBagovV2Commands } from "./commands/browse.js";
+import { registerDlpgovV2Commands } from "./commands/dlp.js";
+import { registerEvgovV2Commands } from "./commands/evomap.js";
+import { registerFedgovV2Commands } from "./commands/federation.js";
+import { registerIpfsgovV2Commands } from "./commands/ipfs.js";
+import { registerP2pgovV2Commands } from "./commands/p2p.js";
+import { registerWalgovV2Commands } from "./commands/wallet.js";
+
+// Iter21 V2 governance overlays
+import { registerApgovV2Commands } from "./commands/activitypub.js";
+import { registerMatgovV2Commands } from "./commands/matrix.js";
+import { registerNosgovV2Commands } from "./commands/nostr.js";
+import { registerBigovV2Commands } from "./commands/bi.js";
+import { registerMemgovV2Commands } from "./commands/memory.js";
+import { registerSesgovV2Commands } from "./commands/session.js";
+import { registerHookgovV2Commands } from "./commands/hook.js";
+import { registerWfgovV2Commands } from "./commands/workflow.js";
+
+// Iter22 V2 governance overlays
+import { registerAugovV2Commands } from "./commands/automation.js";
+import { registerShgovV2Commands } from "./commands/cowork.js";
+import { registerDv2govV2Commands } from "./commands/did-v2.js";
+import { registerKexpgovV2Commands } from "./commands/export.js";
+import { registerKimpgovV2Commands } from "./commands/import.js";
+import { registerLlmgovV2Commands } from "./commands/llm.js";
+import { registerPqcgovV2Commands } from "./commands/pqc.js";
+import { registerSmgovV2Commands } from "./commands/social.js";
+
+// Iter23 V2 governance overlays
+import { registerRcgovV2Commands } from "./commands/rcache.js";
+import { registerTechgovV2Commands } from "./commands/tech.js";
+import { registerRtgovV2Commands } from "./commands/runtime.js";
+import { registerNtgovV2Commands } from "./commands/note.js";
+import { registerPmgovV2Commands } from "./commands/permmem.js";
+import { registerPfgovV2Commands } from "./commands/fusion.js";
+import { registerDbevogovV2Commands } from "./commands/dbevo.js";
+import { registerDigovV2Commands } from "./commands/infra.js";
+
+// Iter24 V2 governance overlays
+import { registerRcmdgovV2Commands } from "./commands/recommend.js";
+import { registerMcpgovV2Commands } from "./commands/mcp.js";
+import { registerEcogovV2Commands } from "./commands/plugin-ecosystem.js";
+import { registerSklgovV2Commands } from "./commands/skill.js";
+import { registerToktgovV2Commands } from "./commands/tokens.js";
+import { registerDevgovV2Commands } from "./commands/dev.js";
+import { registerTigovV2Commands } from "./commands/compliance.js";
+import { registerUebgovV2Commands } from "./commands/compliance.js";
+
 export function createProgram() {
   const program = new Command();
 
@@ -468,5 +538,75 @@ export function createProgram() {
   registerIncgovV2Commands(program);
   registerHardgovV2Commands(program);
 
+  // Iter18 V2 governance overlays
+  registerAiopsgovV2Commands(program);
+  registerMmgovV2Commands(program);
+  registerInstgovV2Commands(program);
+  registerTnsgovV2Commands(program);
+  registerQntgovV2Commands(program);
+  registerTrustgovV2Commands(program);
+  registerNlpgovV2Commands(program);
+  registerPercgovV2Commands(program);
+
+  // Iter19 V2 governance overlays
+  registerCdagovV2Commands(program);
+  registerCogovV2Commands(program);
+  registerCommgovV2Commands(program);
+  registerDidgovV2Commands(program);
+  registerSsogovV2Commands(program);
+  registerOrggovV2Commands(program);
+  registerScimgovV2Commands(program);
+  registerSyncgovV2Commands(program);
+
+  // Iter20 V2 governance overlays
+  registerAnetgovV2Commands(program);
+  registerBagovV2Commands(program);
+  registerDlpgovV2Commands(program);
+  registerEvgovV2Commands(program);
+  registerFedgovV2Commands(program);
+  registerIpfsgovV2Commands(program);
+  registerP2pgovV2Commands(program);
+  registerWalgovV2Commands(program);
+
+  // Iter21 V2 governance overlays
+  registerApgovV2Commands(program);
+  registerMatgovV2Commands(program);
+  registerNosgovV2Commands(program);
+  registerBigovV2Commands(program);
+  registerMemgovV2Commands(program);
+  registerSesgovV2Commands(program);
+  registerHookgovV2Commands(program);
+  registerWfgovV2Commands(program);
+
+  // Iter22 V2 governance overlays
+  registerAugovV2Commands(program);
+  registerShgovV2Commands(program);
+  registerDv2govV2Commands(program);
+  registerKexpgovV2Commands(program);
+  registerKimpgovV2Commands(program);
+  registerLlmgovV2Commands(program);
+  registerPqcgovV2Commands(program);
+  registerSmgovV2Commands(program);
+
+  // Iter23 V2 governance overlays
+  registerRcgovV2Commands(program);
+  registerTechgovV2Commands(program);
+  registerRtgovV2Commands(program);
+  registerNtgovV2Commands(program);
+  registerPmgovV2Commands(program);
+  registerPfgovV2Commands(program);
+  registerDbevogovV2Commands(program);
+  registerDigovV2Commands(program);
+
+  // Iter24 V2 governance overlays
+  registerRcmdgovV2Commands(program);
+  registerMcpgovV2Commands(program);
+  registerEcogovV2Commands(program);
+  registerSklgovV2Commands(program);
+  registerToktgovV2Commands(program);
+  registerDevgovV2Commands(program);
+  registerTigovV2Commands(program);
+  registerUebgovV2Commands(program);
+
   return program;
 }