chainlesschain 0.81.0 → 0.143.0

package/src/commands/audit.js

@@ -15,6 +15,34 @@ import {
   purgeLogs,
   EVENT_TYPES,
   RISK_LEVELS,
+  // V2
+  LOG_STATUS_V2,
+  INTEGRITY_STATUS_V2,
+  ALERT_STATUS_V2,
+  EVENT_TYPES_V2,
+  RISK_LEVELS_V2,
+  AUDIT_DEFAULT_MAX_ALERTS_PER_ACTOR,
+  AUDIT_DEFAULT_ARCHIVE_RETENTION_MS,
+  AUDIT_DEFAULT_PURGE_RETENTION_MS,
+  setMaxAlertsPerActor,
+  setArchiveRetentionMs,
+  setPurgeRetentionMs,
+  getMaxAlertsPerActor,
+  getArchiveRetentionMs,
+  getPurgeRetentionMs,
+  getOpenAlertCount,
+  logEventV2,
+  getLogStatusV2,
+  setLogStatusV2,
+  verifyChainV2,
+  autoArchiveLogs,
+  autoPurgeLogs,
+  getAlertStatusV2,
+  setAlertStatusV2,
+  acknowledgeAlert,
+  resolveAlert,
+  dismissAlert,
+  getAuditStatsV2,
 } from "../lib/audit-logger.js";
 
 const RISK_COLORS = {
@@ -283,4 +311,278 @@ export function registerAuditCommand(program) {
         logger.log(`  ${color(value.padEnd(15))} ${chalk.gray(key)}`);
       }
     });
+
+  // ─────────────────────────────────────────────────────────────
+  // Phase 11 V2 — hash-chained integrity + log/alert lifecycle
+  // ─────────────────────────────────────────────────────────────
+
+  audit
+    .command("log-statuses-v2")
+    .description("List V2 log lifecycle states")
+    .action(() => {
+      for (const v of Object.values(LOG_STATUS_V2)) logger.log(v);
+    });
+
+  audit
+    .command("integrity-statuses-v2")
+    .description("List V2 integrity states")
+    .action(() => {
+      for (const v of Object.values(INTEGRITY_STATUS_V2)) logger.log(v);
+    });
+
+  audit
+    .command("alert-statuses-v2")
+    .description("List V2 alert lifecycle states")
+    .action(() => {
+      for (const v of Object.values(ALERT_STATUS_V2)) logger.log(v);
+    });
+
+  audit
+    .command("event-types-v2")
+    .description("List V2 event types")
+    .action(() => {
+      for (const v of EVENT_TYPES_V2) logger.log(v);
+    });
+
+  audit
+    .command("risk-levels-v2")
+    .description("List V2 risk levels")
+    .action(() => {
+      for (const v of RISK_LEVELS_V2) logger.log(v);
+    });
+
+  audit
+    .command("default-max-alerts-per-actor")
+    .description("Show default max alerts per actor")
+    .action(() => logger.log(String(AUDIT_DEFAULT_MAX_ALERTS_PER_ACTOR)));
+
+  audit
+    .command("max-alerts-per-actor")
+    .description("Show current max alerts per actor")
+    .action(() => logger.log(String(getMaxAlertsPerActor())));
+
+  audit
+    .command("set-max-alerts-per-actor <n>")
+    .description("Update max alerts per actor")
+    .action((n) => {
+      logger.log(String(setMaxAlertsPerActor(n)));
+    });
+
+  audit
+    .command("default-archive-retention-ms")
+    .description("Show default archive retention")
+    .action(() => logger.log(String(AUDIT_DEFAULT_ARCHIVE_RETENTION_MS)));
+
+  audit
+    .command("archive-retention-ms")
+    .description("Show current archive retention")
+    .action(() => logger.log(String(getArchiveRetentionMs())));
+
+  audit
+    .command("set-archive-retention-ms <ms>")
+    .description("Update archive retention (ms)")
+    .action((ms) => {
+      logger.log(String(setArchiveRetentionMs(ms)));
+    });
+
+  audit
+    .command("default-purge-retention-ms")
+    .description("Show default purge retention")
+    .action(() => logger.log(String(AUDIT_DEFAULT_PURGE_RETENTION_MS)));
+
+  audit
+    .command("purge-retention-ms")
+    .description("Show current purge retention")
+    .action(() => logger.log(String(getPurgeRetentionMs())));
+
+  audit
+    .command("set-purge-retention-ms <ms>")
+    .description("Update purge retention (ms)")
+    .action((ms) => {
+      logger.log(String(setPurgeRetentionMs(ms)));
+    });
+
+  audit
+    .command("open-alert-count")
+    .description("Count OPEN alerts (optionally scoped to actor)")
+    .option("-a, --actor <actor>", "Scope to actor")
+    .action((opts) => {
+      logger.log(String(getOpenAlertCount(opts.actor)));
+    });
+
+  audit
+    .command("log-event-v2 <log-id>")
+    .description("V2: register a hash-chained log entry")
+    .option("-t, --event-type <t>", "Event type (required)")
+    .option("-o, --operation <op>", "Operation (required)")
+    .option("-a, --actor <actor>", "Actor")
+    .option("-x, --target <target>", "Target")
+    .option("-d, --details <d>", "Details (JSON)")
+    .option("-r, --risk-level <rl>", "Risk level")
+    .option("-i, --ip-address <ip>", "IP address")
+    .option("-u, --user-agent <ua>", "User agent")
+    .action((logId, opts) => {
+      const db = bootstrap();
+      try {
+        const details = opts.details ? JSON.parse(opts.details) : undefined;
+        const entry = logEventV2(db, {
+          logId,
+          eventType: opts.eventType,
+          operation: opts.operation,
+          actor: opts.actor,
+          target: opts.target,
+          details,
+          riskLevel: opts.riskLevel,
+          ipAddress: opts.ipAddress,
+          userAgent: opts.userAgent,
+        });
+        logger.log(JSON.stringify(entry, null, 2));
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("log-status-v2 <log-id>")
+    .description("V2: show log status + integrity")
+    .action((logId) => {
+      const entry = getLogStatusV2(logId);
+      if (!entry) {
+        logger.log(chalk.yellow("(not found)"));
+        return;
+      }
+      logger.log(JSON.stringify(entry, null, 2));
+    });
+
+  audit
+    .command("set-log-status-v2 <log-id> <status>")
+    .description("V2: transition log status (active|archived|purged)")
+    .option("-r, --reason <reason>", "Reason")
+    .action((logId, status, opts) => {
+      const db = bootstrap();
+      try {
+        const entry = setLogStatusV2(db, logId, status, {
+          reason: opts.reason,
+        });
+        logger.log(JSON.stringify(entry, null, 2));
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("verify-chain-v2")
+    .description("V2: re-hash the chain and mark each entry verified/corrupted")
+    .action(() => {
+      const results = verifyChainV2();
+      logger.log(JSON.stringify(results, null, 2));
+    });
+
+  audit
+    .command("auto-archive-logs")
+    .description("V2: bulk-flip stale ACTIVE logs → ARCHIVED")
+    .action(() => {
+      const db = bootstrap();
+      try {
+        const archived = autoArchiveLogs(db);
+        logger.log(`Archived ${archived.length} log(s)`);
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("auto-purge-logs")
+    .description("V2: bulk-flip stale ARCHIVED logs → PURGED")
+    .action(() => {
+      const db = bootstrap();
+      try {
+        const purged = autoPurgeLogs(db);
+        logger.log(`Purged ${purged.length} log(s)`);
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("alert-status-v2 <alert-id>")
+    .description("V2: show alert status")
+    .action((alertId) => {
+      const entry = getAlertStatusV2(alertId);
+      if (!entry) {
+        logger.log(chalk.yellow("(not found)"));
+        return;
+      }
+      logger.log(JSON.stringify(entry, null, 2));
+    });
+
+  audit
+    .command("set-alert-status-v2 <alert-id> <status>")
+    .description(
+      "V2: transition alert status (open|acknowledged|resolved|dismissed)",
+    )
+    .option("-r, --reason <reason>", "Reason")
+    .option("-m, --metadata <meta>", "Metadata (JSON)")
+    .action((alertId, status, opts) => {
+      const db = bootstrap();
+      try {
+        const metadata = opts.metadata ? JSON.parse(opts.metadata) : undefined;
+        const entry = setAlertStatusV2(db, alertId, status, {
+          reason: opts.reason,
+          metadata,
+        });
+        logger.log(JSON.stringify(entry, null, 2));
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("acknowledge-alert <alert-id>")
+    .description("V2: shortcut → acknowledged")
+    .option("-r, --reason <reason>", "Reason")
+    .action((alertId, opts) => {
+      const db = bootstrap();
+      try {
+        const entry = acknowledgeAlert(db, alertId, opts.reason);
+        logger.log(JSON.stringify(entry, null, 2));
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("resolve-alert <alert-id>")
+    .description("V2: shortcut → resolved")
+    .option("-r, --reason <reason>", "Reason")
+    .action((alertId, opts) => {
+      const db = bootstrap();
+      try {
+        const entry = resolveAlert(db, alertId, opts.reason);
+        logger.log(JSON.stringify(entry, null, 2));
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("dismiss-alert <alert-id>")
+    .description("V2: shortcut → dismissed")
+    .option("-r, --reason <reason>", "Reason")
+    .action((alertId, opts) => {
+      const db = bootstrap();
+      try {
+        const entry = dismissAlert(db, alertId, opts.reason);
+        logger.log(JSON.stringify(entry, null, 2));
+      } finally {
+        shutdown();
+      }
+    });
+
+  audit
+    .command("stats-v2")
+    .description("V2: all-enum-key stats snapshot")
+    .action(() => {
+      logger.log(JSON.stringify(getAuditStatsV2(), null, 2));
+    });
 }

package/src/commands/automation.js

@@ -33,6 +33,37 @@ import {
   FLOW_STATUS,
   EXECUTION_STATUS,
   TRIGGER_TYPE,
+  AUTOMATION_MATURITY_V2,
+  EXECUTION_LIFECYCLE_V2,
+  getMaxActiveAutomationsPerOwnerV2,
+  setMaxActiveAutomationsPerOwnerV2,
+  getMaxRunningExecutionsPerAutomationV2,
+  setMaxRunningExecutionsPerAutomationV2,
+  getAutomationIdleMsV2,
+  setAutomationIdleMsV2,
+  getExecutionStuckMsV2,
+  setExecutionStuckMsV2,
+  registerAutomationV2,
+  getAutomationV2,
+  listAutomationsV2,
+  setAutomationStatusV2,
+  activateAutomationV2,
+  pauseAutomationV2,
+  retireAutomationV2,
+  touchAutomationV2,
+  getActiveAutomationCountV2,
+  createExecutionV2,
+  getExecutionV2 as getExecutionV2Surface,
+  listExecutionsV2,
+  setExecutionStatusV2,
+  startExecutionV2,
+  succeedExecutionV2,
+  failExecutionV2,
+  cancelExecutionV2,
+  getRunningExecutionCountV2,
+  autoPauseIdleAutomationsV2,
+  autoFailStuckExecutionsV2,
+  getAutomationEngineStatsV2,
 } from "../lib/automation-engine.js";
 
 function _dbFromCtx(cmd) {
@@ -68,7 +99,8 @@ export function registerAutomationCommand(program) {
       .description(
         "Workflow automation engine — 12 SaaS connectors + triggers (Phase 96)",
       )
-      .hook("preAction", async (thisCommand) => {
+      .hook("preAction", async (thisCommand, actionCommand) => {
+        if (actionCommand && actionCommand.name().endsWith("-v2")) return;
         const db = await _prepare(thisCommand);
         thisCommand._db = db;
       });
@@ -651,4 +683,242 @@ function _wire(root) {
         await shutdown();
       }
     });
+
+  // ── V2 Surface ──
+
+  const outV2 = (obj) => console.log(JSON.stringify(obj, null, 2));
+  const tryRunV2 = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  root
+    .command("automation-maturities-v2")
+    .description("List V2 automation maturity states")
+    .action(() => outV2(Object.values(AUTOMATION_MATURITY_V2)));
+
+  root
+    .command("execution-lifecycles-v2")
+    .description("List V2 execution lifecycle states")
+    .action(() => outV2(Object.values(EXECUTION_LIFECYCLE_V2)));
+
+  root
+    .command("stats-v2")
+    .description("V2 automation engine stats")
+    .action(() => outV2(getAutomationEngineStatsV2()));
+
+  root
+    .command("get-max-active-automations-v2")
+    .description("Get max active automations per owner (V2)")
+    .action(() =>
+      outV2({
+        maxActiveAutomationsPerOwner: getMaxActiveAutomationsPerOwnerV2(),
+      }),
+    );
+
+  root
+    .command("set-max-active-automations-v2 <n>")
+    .description("Set max active automations per owner (V2)")
+    .action((n) =>
+      tryRunV2(() => {
+        setMaxActiveAutomationsPerOwnerV2(Number(n));
+        outV2({
+          maxActiveAutomationsPerOwner: getMaxActiveAutomationsPerOwnerV2(),
+        });
+      }),
+    );
+
+  root
+    .command("get-max-running-executions-v2")
+    .description("Get max running executions per automation (V2)")
+    .action(() =>
+      outV2({
+        maxRunningExecutionsPerAutomation:
+          getMaxRunningExecutionsPerAutomationV2(),
+      }),
+    );
+
+  root
+    .command("set-max-running-executions-v2 <n>")
+    .description("Set max running executions per automation (V2)")
+    .action((n) =>
+      tryRunV2(() => {
+        setMaxRunningExecutionsPerAutomationV2(Number(n));
+        outV2({
+          maxRunningExecutionsPerAutomation:
+            getMaxRunningExecutionsPerAutomationV2(),
+        });
+      }),
+    );
+
+  root
+    .command("get-automation-idle-ms-v2")
+    .description("Get automation idle threshold (V2)")
+    .action(() => outV2({ automationIdleMs: getAutomationIdleMsV2() }));
+
+  root
+    .command("set-automation-idle-ms-v2 <ms>")
+    .description("Set automation idle threshold (V2)")
+    .action((ms) =>
+      tryRunV2(() => {
+        setAutomationIdleMsV2(Number(ms));
+        outV2({ automationIdleMs: getAutomationIdleMsV2() });
+      }),
+    );
+
+  root
+    .command("get-execution-stuck-ms-v2")
+    .description("Get execution stuck threshold (V2)")
+    .action(() => outV2({ executionStuckMs: getExecutionStuckMsV2() }));
+
+  root
+    .command("set-execution-stuck-ms-v2 <ms>")
+    .description("Set execution stuck threshold (V2)")
+    .action((ms) =>
+      tryRunV2(() => {
+        setExecutionStuckMsV2(Number(ms));
+        outV2({ executionStuckMs: getExecutionStuckMsV2() });
+      }),
+    );
+
+  root
+    .command("active-automation-count-v2 <ownerId>")
+    .description("Active automation count for owner (V2)")
+    .action((ownerId) =>
+      outV2({ ownerId, count: getActiveAutomationCountV2(ownerId) }),
+    );
+
+  root
+    .command("running-execution-count-v2 <automationId>")
+    .description("Running execution count for automation (V2)")
+    .action((automationId) =>
+      outV2({
+        automationId,
+        count: getRunningExecutionCountV2(automationId),
+      }),
+    );
+
+  root
+    .command("register-automation-v2 <id>")
+    .description("Register a V2 automation")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-n, --name <name>", "automation name")
+    .action((id, opts) =>
+      tryRunV2(() =>
+        outV2(
+          registerAutomationV2(id, { ownerId: opts.owner, name: opts.name }),
+        ),
+      ),
+    );
+
+  root
+    .command("get-automation-v2 <id>")
+    .description("Get a V2 automation")
+    .action((id) => outV2(getAutomationV2(id)));
+
+  root
+    .command("list-automations-v2")
+    .description("List V2 automations")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      outV2(listAutomationsV2({ ownerId: opts.owner, status: opts.status })),
+    );
+
+  root
+    .command("set-automation-status-v2 <id> <next>")
+    .description("Set V2 automation status")
+    .action((id, next) =>
+      tryRunV2(() => outV2(setAutomationStatusV2(id, next))),
+    );
+
+  root
+    .command("activate-automation-v2 <id>")
+    .description("Activate a V2 automation")
+    .action((id) => tryRunV2(() => outV2(activateAutomationV2(id))));
+
+  root
+    .command("pause-automation-v2 <id>")
+    .description("Pause a V2 automation")
+    .action((id) => tryRunV2(() => outV2(pauseAutomationV2(id))));
+
+  root
+    .command("retire-automation-v2 <id>")
+    .description("Retire a V2 automation")
+    .action((id) => tryRunV2(() => outV2(retireAutomationV2(id))));
+
+  root
+    .command("touch-automation-v2 <id>")
+    .description("Touch a V2 automation")
+    .action((id) => tryRunV2(() => outV2(touchAutomationV2(id))));
+
+  root
+    .command("create-execution-v2 <id>")
+    .description("Create a V2 execution")
+    .requiredOption("-a, --automation <id>", "automation id")
+    .action((id, opts) =>
+      tryRunV2(() =>
+        outV2(createExecutionV2(id, { automationId: opts.automation })),
+      ),
+    );
+
+  root
+    .command("get-execution-v2 <id>")
+    .description("Get a V2 execution")
+    .action((id) => outV2(getExecutionV2Surface(id)));
+
+  root
+    .command("list-executions-v2")
+    .description("List V2 executions")
+    .option("-a, --automation <id>", "filter by automation")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      outV2(
+        listExecutionsV2({
+          automationId: opts.automation,
+          status: opts.status,
+        }),
+      ),
+    );
+
+  root
+    .command("set-execution-status-v2 <id> <next>")
+    .description("Set V2 execution status")
+    .action((id, next) =>
+      tryRunV2(() => outV2(setExecutionStatusV2(id, next))),
+    );
+
+  root
+    .command("start-execution-v2 <id>")
+    .description("Start a V2 execution")
+    .action((id) => tryRunV2(() => outV2(startExecutionV2(id))));
+
+  root
+    .command("succeed-execution-v2 <id>")
+    .description("Succeed a V2 execution")
+    .action((id) => tryRunV2(() => outV2(succeedExecutionV2(id))));
+
+  root
+    .command("fail-execution-v2 <id>")
+    .description("Fail a V2 execution")
+    .action((id) => tryRunV2(() => outV2(failExecutionV2(id))));
+
+  root
+    .command("cancel-execution-v2 <id>")
+    .description("Cancel a V2 execution")
+    .action((id) => tryRunV2(() => outV2(cancelExecutionV2(id))));
+
+  root
+    .command("auto-pause-idle-automations-v2")
+    .description("Auto-pause idle V2 automations")
+    .action(() => outV2(autoPauseIdleAutomationsV2()));
+
+  root
+    .command("auto-fail-stuck-executions-v2")
+    .description("Auto-fail stuck V2 executions")
+    .action(() => outV2(autoFailStuckExecutionsV2()));
 }

package/src/commands/bi.js

@@ -585,4 +585,65 @@ export function registerBiCommand(program) {
         process.exit(1);
       }
     });
+  registerBiV2Command(bi);
+}
+
+
+import {
+  BI_DATASET_MATURITY_V2,
+  BI_QUERY_LIFECYCLE_V2,
+  registerBiDatasetV2,
+  activateBiDatasetV2,
+  staleBiDatasetV2,
+  archiveBiDatasetV2,
+  touchBiDatasetV2,
+  getBiDatasetV2,
+  listBiDatasetsV2,
+  createBiQueryV2,
+  startBiQueryV2,
+  completeBiQueryV2,
+  failBiQueryV2,
+  cancelBiQueryV2,
+  getBiQueryV2,
+  listBiQueriesV2,
+  setMaxActiveBiDatasetsPerOwnerV2,
+  getMaxActiveBiDatasetsPerOwnerV2,
+  setMaxPendingBiQueriesPerDatasetV2,
+  getMaxPendingBiQueriesPerDatasetV2,
+  setBiDatasetIdleMsV2,
+  getBiDatasetIdleMsV2,
+  setBiQueryStuckMsV2,
+  getBiQueryStuckMsV2,
+  autoStaleIdleBiDatasetsV2,
+  autoFailStuckBiQueriesV2,
+  getBiEngineStatsV2,
+} from "../lib/bi-engine.js";
+
+export function registerBiV2Command(bi) {
+  bi.command("enums-v2").description("Show V2 enums").action(() => { console.log(JSON.stringify({ BI_DATASET_MATURITY_V2, BI_QUERY_LIFECYCLE_V2 }, null, 2)); });
+  bi.command("register-dataset-v2").description("Register a BI dataset profile (pending)")
+    .requiredOption("--id <id>").requiredOption("--owner <owner>").option("--source <source>")
+    .action((o) => { console.log(JSON.stringify(registerBiDatasetV2(o), null, 2)); });
+  bi.command("activate-dataset-v2 <id>").description("Activate dataset").action((id) => { console.log(JSON.stringify(activateBiDatasetV2(id), null, 2)); });
+  bi.command("stale-dataset-v2 <id>").description("Mark dataset stale").action((id) => { console.log(JSON.stringify(staleBiDatasetV2(id), null, 2)); });
+  bi.command("archive-dataset-v2 <id>").description("Archive dataset (terminal)").action((id) => { console.log(JSON.stringify(archiveBiDatasetV2(id), null, 2)); });
+  bi.command("touch-dataset-v2 <id>").description("Refresh lastTouchedAt").action((id) => { console.log(JSON.stringify(touchBiDatasetV2(id), null, 2)); });
+  bi.command("get-dataset-v2 <id>").description("Get dataset").action((id) => { console.log(JSON.stringify(getBiDatasetV2(id), null, 2)); });
+  bi.command("list-datasets-v2").description("List datasets").action(() => { console.log(JSON.stringify(listBiDatasetsV2(), null, 2)); });
+  bi.command("create-query-v2").description("Create a BI query (queued)")
+    .requiredOption("--id <id>").requiredOption("--dataset-id <datasetId>").option("--sql <sql>")
+    .action((o) => { console.log(JSON.stringify(createBiQueryV2({ id: o.id, datasetId: o.datasetId, sql: o.sql }), null, 2)); });
+  bi.command("start-query-v2 <id>").description("Transition query to running").action((id) => { console.log(JSON.stringify(startBiQueryV2(id), null, 2)); });
+  bi.command("complete-query-v2 <id>").description("Transition query to completed").action((id) => { console.log(JSON.stringify(completeBiQueryV2(id), null, 2)); });
+  bi.command("fail-query-v2 <id>").description("Fail query").option("--reason <r>").action((id, o) => { console.log(JSON.stringify(failBiQueryV2(id, o.reason), null, 2)); });
+  bi.command("cancel-query-v2 <id>").description("Cancel query").option("--reason <r>").action((id, o) => { console.log(JSON.stringify(cancelBiQueryV2(id, o.reason), null, 2)); });
+  bi.command("get-query-v2 <id>").description("Get query").action((id) => { console.log(JSON.stringify(getBiQueryV2(id), null, 2)); });
+  bi.command("list-queries-v2").description("List queries").action(() => { console.log(JSON.stringify(listBiQueriesV2(), null, 2)); });
+  bi.command("set-max-active-datasets-v2 <n>").description("Set per-owner active cap").action((n) => { setMaxActiveBiDatasetsPerOwnerV2(Number(n)); console.log(JSON.stringify({ maxActiveBiDatasetsPerOwner: getMaxActiveBiDatasetsPerOwnerV2() }, null, 2)); });
+  bi.command("set-max-pending-queries-v2 <n>").description("Set per-dataset pending cap").action((n) => { setMaxPendingBiQueriesPerDatasetV2(Number(n)); console.log(JSON.stringify({ maxPendingBiQueriesPerDataset: getMaxPendingBiQueriesPerDatasetV2() }, null, 2)); });
+  bi.command("set-dataset-idle-ms-v2 <n>").description("Set idle threshold").action((n) => { setBiDatasetIdleMsV2(Number(n)); console.log(JSON.stringify({ biDatasetIdleMs: getBiDatasetIdleMsV2() }, null, 2)); });
+  bi.command("set-query-stuck-ms-v2 <n>").description("Set stuck threshold").action((n) => { setBiQueryStuckMsV2(Number(n)); console.log(JSON.stringify({ biQueryStuckMs: getBiQueryStuckMsV2() }, null, 2)); });
+  bi.command("auto-stale-idle-datasets-v2").description("Auto-stale idle datasets").action(() => { console.log(JSON.stringify(autoStaleIdleBiDatasetsV2(), null, 2)); });
+  bi.command("auto-fail-stuck-queries-v2").description("Auto-fail stuck running queries").action(() => { console.log(JSON.stringify(autoFailStuckBiQueriesV2(), null, 2)); });
+  bi.command("gov-stats-v2").description("V2 governance aggregate stats").action(() => { console.log(JSON.stringify(getBiEngineStatsV2(), null, 2)); });
 }