chainlesschain 0.81.0 → 0.132.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.81.0",
+  "version": "0.132.0",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/commands/agent-network.js

@@ -50,6 +50,37 @@ import {
   getTopAgents,
   getNetworkStats,
   getNetworkConfig,
+  AGENT_MATURITY_V2,
+  TASK_LIFECYCLE_V2,
+  getMaxActiveAgentsPerNetworkV2,
+  setMaxActiveAgentsPerNetworkV2,
+  getMaxPendingTasksPerAgentV2,
+  setMaxPendingTasksPerAgentV2,
+  getAgentIdleMsV2,
+  setAgentIdleMsV2,
+  getTaskStuckMsV2,
+  setTaskStuckMsV2,
+  registerAgentV2,
+  getAgentV2,
+  listAgentsV2,
+  setAgentStatusV2,
+  activateAgentV2,
+  suspendAgentV2,
+  revokeAgentV2,
+  touchAgentV2,
+  createTaskV2,
+  getTaskV2,
+  listTasksV2,
+  setTaskStatusV2,
+  startTaskV2,
+  completeTaskV2,
+  failTaskV2,
+  cancelTaskV2,
+  getActiveAgentCountV2,
+  getPendingTaskCountV2,
+  autoSuspendIdleAgentsV2,
+  autoFailStuckTasksV2,
+  getAgentNetworkStatsV2,
 } from "../lib/agent-network.js";
 
 function _dbFromCtx(cmd) {
@@ -81,7 +112,8 @@ export function registerAgentNetworkCommand(program) {
     .description(
       "Decentralized Agent Network (Phase 24) — DID / registry / credentials / task routing",
     )
-    .hook("preAction", (thisCmd) => {
+    .hook("preAction", (thisCmd, actionCommand) => {
+      if (actionCommand && actionCommand.name().endsWith("-v2")) return;
       const db = _dbFromCtx(thisCmd);
       if (db) ensureAgentNetworkTables(db);
     });
@@ -780,6 +812,227 @@ export function registerAgentNetworkCommand(program) {
       console.log(`Peers: ${s.peers}`);
     });
 
+  // ─── V2 Governance Layer ──────────────────────────────────────────
+  const out = (obj) => console.log(JSON.stringify(obj, null, 2));
+  const tryRun = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  anet
+    .command("agent-maturities-v2")
+    .description("List V2 agent maturity states")
+    .action(() => out(Object.values(AGENT_MATURITY_V2)));
+
+  anet
+    .command("task-lifecycles-v2")
+    .description("List V2 task lifecycle states")
+    .action(() => out(Object.values(TASK_LIFECYCLE_V2)));
+
+  anet
+    .command("stats-v2")
+    .description("V2 agent-network stats")
+    .action(() => out(getAgentNetworkStatsV2()));
+
+  anet
+    .command("get-max-active-agents-v2")
+    .description("Get max active agents per network (V2)")
+    .action(() =>
+      out({ maxActiveAgentsPerNetwork: getMaxActiveAgentsPerNetworkV2() }),
+    );
+
+  anet
+    .command("set-max-active-agents-v2 <n>")
+    .description("Set max active agents per network (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveAgentsPerNetworkV2(Number(n));
+        out({ maxActiveAgentsPerNetwork: getMaxActiveAgentsPerNetworkV2() });
+      }),
+    );
+
+  anet
+    .command("get-max-pending-tasks-v2")
+    .description("Get max pending tasks per agent (V2)")
+    .action(() =>
+      out({ maxPendingTasksPerAgent: getMaxPendingTasksPerAgentV2() }),
+    );
+
+  anet
+    .command("set-max-pending-tasks-v2 <n>")
+    .description("Set max pending tasks per agent (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingTasksPerAgentV2(Number(n));
+        out({ maxPendingTasksPerAgent: getMaxPendingTasksPerAgentV2() });
+      }),
+    );
+
+  anet
+    .command("get-agent-idle-ms-v2")
+    .description("Get agent idle threshold (V2)")
+    .action(() => out({ agentIdleMs: getAgentIdleMsV2() }));
+
+  anet
+    .command("set-agent-idle-ms-v2 <ms>")
+    .description("Set agent idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setAgentIdleMsV2(Number(ms));
+        out({ agentIdleMs: getAgentIdleMsV2() });
+      }),
+    );
+
+  anet
+    .command("get-task-stuck-ms-v2")
+    .description("Get task stuck threshold (V2)")
+    .action(() => out({ taskStuckMs: getTaskStuckMsV2() }));
+
+  anet
+    .command("set-task-stuck-ms-v2 <ms>")
+    .description("Set task stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setTaskStuckMsV2(Number(ms));
+        out({ taskStuckMs: getTaskStuckMsV2() });
+      }),
+    );
+
+  anet
+    .command("active-agent-count-v2 <networkId>")
+    .description("Active agent count for network (V2)")
+    .action((networkId) =>
+      out({ networkId, count: getActiveAgentCountV2(networkId) }),
+    );
+
+  anet
+    .command("pending-task-count-v2 <agentId>")
+    .description("Pending task count for agent (V2)")
+    .action((agentId) =>
+      out({ agentId, count: getPendingTaskCountV2(agentId) }),
+    );
+
+  anet
+    .command("register-agent-v2 <id>")
+    .description("Register a V2 agent")
+    .requiredOption("-n, --network <id>", "network id")
+    .requiredOption("-d, --did <did>", "agent DID")
+    .option("--display <name>", "display name")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          registerAgentV2(id, {
+            networkId: opts.network,
+            did: opts.did,
+            displayName: opts.display,
+          }),
+        ),
+      ),
+    );
+
+  anet
+    .command("get-agent-v2 <id>")
+    .description("Get a V2 agent")
+    .action((id) => out(getAgentV2(id)));
+
+  anet
+    .command("list-agents-v2")
+    .description("List V2 agents")
+    .option("-n, --network <id>", "filter by network")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listAgentsV2({ networkId: opts.network, status: opts.status })),
+    );
+
+  anet
+    .command("set-agent-status-v2 <id> <next>")
+    .description("Set V2 agent status")
+    .action((id, next) => tryRun(() => out(setAgentStatusV2(id, next))));
+
+  anet
+    .command("activate-agent-v2 <id>")
+    .description("Activate a V2 agent")
+    .action((id) => tryRun(() => out(activateAgentV2(id))));
+
+  anet
+    .command("suspend-agent-v2 <id>")
+    .description("Suspend a V2 agent")
+    .action((id) => tryRun(() => out(suspendAgentV2(id))));
+
+  anet
+    .command("revoke-agent-v2 <id>")
+    .description("Revoke a V2 agent")
+    .action((id) => tryRun(() => out(revokeAgentV2(id))));
+
+  anet
+    .command("touch-agent-v2 <id>")
+    .description("Touch a V2 agent")
+    .action((id) => tryRun(() => out(touchAgentV2(id))));
+
+  anet
+    .command("create-task-v2 <id>")
+    .description("Create a V2 task")
+    .requiredOption("-a, --agent <id>", "agent id")
+    .option("-k, --kind <kind>", "task kind", "invoke")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(createTaskV2(id, { agentId: opts.agent, kind: opts.kind })),
+      ),
+    );
+
+  anet
+    .command("get-task-v2 <id>")
+    .description("Get a V2 task")
+    .action((id) => out(getTaskV2(id)));
+
+  anet
+    .command("list-tasks-v2")
+    .description("List V2 tasks")
+    .option("-a, --agent <id>", "filter by agent")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listTasksV2({ agentId: opts.agent, status: opts.status })),
+    );
+
+  anet
+    .command("set-task-status-v2 <id> <next>")
+    .description("Set V2 task status")
+    .action((id, next) => tryRun(() => out(setTaskStatusV2(id, next))));
+
+  anet
+    .command("start-task-v2 <id>")
+    .description("Start a V2 task")
+    .action((id) => tryRun(() => out(startTaskV2(id))));
+
+  anet
+    .command("complete-task-v2 <id>")
+    .description("Complete a V2 task")
+    .action((id) => tryRun(() => out(completeTaskV2(id))));
+
+  anet
+    .command("fail-task-v2 <id>")
+    .description("Fail a V2 task")
+    .action((id) => tryRun(() => out(failTaskV2(id))));
+
+  anet
+    .command("cancel-task-v2 <id>")
+    .description("Cancel a V2 task")
+    .action((id) => tryRun(() => out(cancelTaskV2(id))));
+
+  anet
+    .command("auto-suspend-idle-agents-v2")
+    .description("Auto-suspend idle V2 agents")
+    .action(() => out(autoSuspendIdleAgentsV2()));
+
+  anet
+    .command("auto-fail-stuck-tasks-v2")
+    .description("Auto-fail stuck V2 tasks")
+    .action(() => out(autoFailStuckTasksV2()));
+
   program.addCommand(anet);
   return anet;
 }

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));
+    });
 }