chainlesschain 0.66.0 → 0.81.0

package/src/commands/evomap.js

@@ -17,6 +17,14 @@ import {
   getPressureReport,
   recombineGenes,
   getLineage,
+  HUB_STATUS_V2,
+  TRUST_TIER,
+  MUTATION_TYPE,
+  trustTier,
+  setHubStatus,
+  listHubsV2,
+  buildFederationContext,
+  getFederationStatsV2,
 } from "../lib/evomap-federation.js";
 import {
   ensureEvoMapGovernanceTables,
@@ -25,6 +33,18 @@ import {
   createGovernanceProposal,
   voteOnGovernanceProposal,
   getGovernanceDashboard,
+  PROPOSAL_STATUS_V2,
+  PROPOSAL_TYPE,
+  VOTE_DIRECTION,
+  createGovernanceProposalV2,
+  castVoteV2,
+  setProposalStatus,
+  executeProposal,
+  cancelProposal,
+  expireProposalsV2,
+  listProposalsV2,
+  traceContributions,
+  getGovernanceStatsV2,
 } from "../lib/evomap-governance.js";
 
 export function registerEvoMapCommand(program) {
@@ -555,4 +575,378 @@ export function registerEvoMapCommand(program) {
         process.exit(1);
       }
     });
+
+  // ═══════════════════════════════════════════════════════════════
+  // V2 Canonical Subcommands (Phase 42)
+  // ═══════════════════════════════════════════════════════════════
+
+  federation
+    .command("hub-statuses")
+    .description("List V2 hub status values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(HUB_STATUS_V2), null, 2));
+    });
+
+  federation
+    .command("trust-tiers")
+    .description("List V2 trust tier values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(TRUST_TIER), null, 2));
+    });
+
+  federation
+    .command("mutation-types")
+    .description("List V2 mutation types")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(MUTATION_TYPE), null, 2));
+    });
+
+  federation
+    .command("trust-tier <score>")
+    .description("Classify a trust score as low|medium|high")
+    .action((score) => {
+      try {
+        const num = Number(score);
+        console.log(JSON.stringify({ score: num, tier: trustTier(num) }));
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  federation
+    .command("set-hub-status <hub-id> <status>")
+    .description("Transition a hub's status (V2 state machine)")
+    .action(async (hubId, status) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapFederationTables(db);
+        console.log(JSON.stringify(setHubStatus(db, hubId, status), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  federation
+    .command("list-hubs-v2")
+    .description("List hubs with V2 filters (trust tier, minTrust)")
+    .option("--status <status>", "Filter by hub status")
+    .option("--region <region>", "Filter by region")
+    .option("--min-trust <n>", "Minimum trust score (0-1)")
+    .option("--trust-tier <tier>", "Filter by trust tier (low|medium|high)")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapFederationTables(db);
+        const hubs = listHubsV2(db, {
+          status: options.status,
+          region: options.region,
+          minTrust: options.minTrust ? Number(options.minTrust) : undefined,
+          trustTier: options.trustTier,
+        });
+        console.log(JSON.stringify(hubs, null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  federation
+    .command("context")
+    .description("Build federation context for LLM consumption")
+    .action(async () => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapFederationTables(db);
+        console.log(JSON.stringify(buildFederationContext(), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  federation
+    .command("stats-v2")
+    .description("Show V2 federation stats (byStatus/byRegion/byTrustTier)")
+    .action(async () => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapFederationTables(db);
+        console.log(JSON.stringify(getFederationStatsV2(), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("proposal-statuses")
+    .description("List V2 proposal status values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(PROPOSAL_STATUS_V2), null, 2));
+    });
+
+  gov
+    .command("proposal-types")
+    .description("List V2 proposal type values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(PROPOSAL_TYPE), null, 2));
+    });
+
+  gov
+    .command("vote-directions")
+    .description("List V2 vote direction values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(VOTE_DIRECTION), null, 2));
+    });
+
+  gov
+    .command("propose-v2")
+    .description("Create a V2 governance proposal with type/quorum/threshold")
+    .requiredOption("-t, --title <title>", "Proposal title")
+    .option("-d, --description <text>", "Proposal description")
+    .option("-p, --proposer <did>", "Proposer DID", "cli-user")
+    .option(
+      "--type <type>",
+      "Proposal type (standard|gene_standard|...)",
+      "standard",
+    )
+    .option("--quorum <n>", "Quorum (min votes)", "3")
+    .option("--threshold <n>", "Threshold (0-1)", "0.5")
+    .option("--voting-duration-ms <n>", "Voting duration in ms")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        const p = createGovernanceProposalV2(db, {
+          title: options.title,
+          description: options.description,
+          proposerDid: options.proposer,
+          type: options.type,
+          quorum: Number(options.quorum),
+          threshold: Number(options.threshold),
+          votingDurationMs: options.votingDurationMs
+            ? Number(options.votingDurationMs)
+            : undefined,
+        });
+        console.log(JSON.stringify(p, null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("vote-v2 <proposal-id> <direction>")
+    .description("Cast a weighted V2 vote (for|against|abstain)")
+    .option("-v, --voter <did>", "Voter DID", "cli-user")
+    .option("-w, --weight <n>", "Vote weight", "1")
+    .action(async (proposalId, direction, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        const r = castVoteV2(db, {
+          proposalId,
+          voterDid: options.voter,
+          direction,
+          weight: Number(options.weight),
+        });
+        console.log(JSON.stringify(r, null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("set-status <proposal-id> <status>")
+    .description("Transition a proposal's status (V2 state machine)")
+    .action(async (proposalId, status) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        console.log(
+          JSON.stringify(setProposalStatus(db, proposalId, status), null, 2),
+        );
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("execute <proposal-id>")
+    .description("Execute a passed proposal")
+    .action(async (proposalId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        console.log(JSON.stringify(executeProposal(db, proposalId), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("cancel <proposal-id>")
+    .description("Cancel a proposal")
+    .action(async (proposalId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        console.log(JSON.stringify(cancelProposal(db, proposalId), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("expire")
+    .description("Bulk-expire active proposals past voting deadline (V2)")
+    .action(async () => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        console.log(JSON.stringify(expireProposalsV2(db), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("list-v2")
+    .description("List proposals with V2 filters")
+    .option("--status <status>", "Filter by status")
+    .option("--type <type>", "Filter by type")
+    .option("--proposer <did>", "Filter by proposer DID")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        console.log(
+          JSON.stringify(
+            listProposalsV2(db, {
+              status: options.status,
+              type: options.type,
+              proposerDid: options.proposer,
+            }),
+            null,
+            2,
+          ),
+        );
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("contributions <gene-id>")
+    .description("Trace gene contributions (V2 alias of ownership-trace)")
+    .action(async (geneId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        console.log(JSON.stringify(traceContributions(geneId), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  gov
+    .command("stats-v2")
+    .description("Show V2 governance stats (byStatus/byType, weight totals)")
+    .action(async () => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureEvoMapGovernanceTables(db);
+        console.log(JSON.stringify(getGovernanceStatsV2(), null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/federation.js

@@ -29,6 +29,28 @@ import {
   listPools,
   destroyPool,
   getFederationHardeningStats,
+  // V2 (Phase 58)
+  NODE_STATUS_V2,
+  FED_DEFAULT_FAILURE_THRESHOLD,
+  FED_DEFAULT_HALF_OPEN_COOLDOWN_MS,
+  FED_DEFAULT_UNHEALTHY_THRESHOLD,
+  FED_DEFAULT_MAX_ACTIVE_NODES,
+  setFailureThreshold,
+  getFailureThreshold,
+  setHalfOpenCooldownMs,
+  getHalfOpenCooldownMs,
+  setUnhealthyThreshold,
+  getUnhealthyThreshold,
+  setMaxActiveNodes,
+  getMaxActiveNodes,
+  getActiveNodeCount,
+  registerNodeV2,
+  getNodeStatusV2,
+  setNodeStatusV2,
+  recordHealthCheckV2,
+  tripCircuit,
+  autoIsolateUnhealthyNodes,
+  getFederationHardeningStatsV2,
 } from "../lib/federation-hardening.js";
 
 function _dbFromCtx(cmd) {
@@ -423,5 +445,266 @@ export function registerFederationCommand(program) {
       );
     });
 
+  /* ── V2 (Phase 58) ──────────────────────────────── */
+
+  fed
+    .command("node-statuses-v2")
+    .description("List V2 node lifecycle statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const statuses = Object.values(NODE_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(statuses, null, 2));
+      for (const s of statuses) console.log(`  ${s}`);
+    });
+
+  fed
+    .command("default-failure-threshold")
+    .description("Default circuit-breaker failure threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_FAILURE_THRESHOLD));
+      console.log(FED_DEFAULT_FAILURE_THRESHOLD);
+    });
+
+  fed
+    .command("failure-threshold")
+    .description("Current failure threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getFailureThreshold();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-failure-threshold <n>")
+    .description("Set failure threshold (positive integer)")
+    .option("--json", "JSON output")
+    .action((n, opts) => {
+      setFailureThreshold(Number(n));
+      const out = { failureThreshold: getFailureThreshold() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`failureThreshold = ${out.failureThreshold}`);
+    });
+
+  fed
+    .command("default-half-open-cooldown-ms")
+    .description("Default half-open cooldown in ms")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_HALF_OPEN_COOLDOWN_MS));
+      console.log(FED_DEFAULT_HALF_OPEN_COOLDOWN_MS);
+    });
+
+  fed
+    .command("half-open-cooldown-ms")
+    .description("Current half-open cooldown in ms")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getHalfOpenCooldownMs();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-half-open-cooldown-ms <ms>")
+    .description("Set half-open cooldown (positive integer ms)")
+    .option("--json", "JSON output")
+    .action((ms, opts) => {
+      setHalfOpenCooldownMs(Number(ms));
+      const out = { halfOpenCooldownMs: getHalfOpenCooldownMs() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`halfOpenCooldownMs = ${out.halfOpenCooldownMs}`);
+    });
+
+  fed
+    .command("default-unhealthy-threshold")
+    .description("Default consecutive-unhealthy isolation threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_UNHEALTHY_THRESHOLD));
+      console.log(FED_DEFAULT_UNHEALTHY_THRESHOLD);
+    });
+
+  fed
+    .command("unhealthy-threshold")
+    .description("Current consecutive-unhealthy threshold")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getUnhealthyThreshold();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-unhealthy-threshold <n>")
+    .description("Set consecutive-unhealthy threshold")
+    .option("--json", "JSON output")
+    .action((n, opts) => {
+      setUnhealthyThreshold(Number(n));
+      const out = { unhealthyThreshold: getUnhealthyThreshold() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`unhealthyThreshold = ${out.unhealthyThreshold}`);
+    });
+
+  fed
+    .command("default-max-active-nodes")
+    .description("Default max active nodes cap")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      if (opts.json)
+        return console.log(JSON.stringify(FED_DEFAULT_MAX_ACTIVE_NODES));
+      console.log(FED_DEFAULT_MAX_ACTIVE_NODES);
+    });
+
+  fed
+    .command("max-active-nodes")
+    .description("Current max active nodes cap")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getMaxActiveNodes();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("active-node-count")
+    .description("Number of currently ACTIVE nodes")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const n = getActiveNodeCount();
+      if (opts.json) return console.log(JSON.stringify(n));
+      console.log(n);
+    });
+
+  fed
+    .command("set-max-active-nodes <n>")
+    .description("Set max active nodes cap")
+    .option("--json", "JSON output")
+    .action((n, opts) => {
+      setMaxActiveNodes(Number(n));
+      const out = { maxActiveNodes: getMaxActiveNodes() };
+      if (opts.json) return console.log(JSON.stringify(out, null, 2));
+      console.log(`maxActiveNodes = ${out.maxActiveNodes}`);
+    });
+
+  fed
+    .command("register-v2 <node-id>")
+    .description("Register a node with V2 lifecycle tracking")
+    .option("-m, --metadata <json>", "JSON metadata")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const db = _dbFromCtx(fed);
+      const metadata = opts.metadata ? JSON.parse(opts.metadata) : undefined;
+      const r = registerNodeV2(db, { nodeId, metadata });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Registered ${nodeId} (status: ${r.status})`);
+    });
+
+  fed
+    .command("node-status-v2 <node-id>")
+    .description("Get V2 node status")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const r = getNodeStatusV2(nodeId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      if (!r) return console.log("(not found)");
+      console.log(`${nodeId}: ${r.status}${r.reason ? ` — ${r.reason}` : ""}`);
+    });
+
+  fed
+    .command("set-node-status-v2 <node-id> <status>")
+    .description("Transition node to a new status")
+    .option("-r, --reason <reason>")
+    .option("-m, --metadata <json>")
+    .option("--json", "JSON output")
+    .action((nodeId, status, opts) => {
+      const db = _dbFromCtx(fed);
+      const patch = {};
+      if (opts.reason !== undefined) patch.reason = opts.reason;
+      if (opts.metadata !== undefined)
+        patch.metadata = JSON.parse(opts.metadata);
+      const r = setNodeStatusV2(db, nodeId, status, patch);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`${nodeId} → ${r.status}`);
+    });
+
+  fed
+    .command("record-health-v2 <node-id>")
+    .description("Record a V2 health check (throws on invalid input)")
+    .option(
+      "-t, --type <checkType>",
+      "heartbeat|latency|success_rate|cpu_usage|memory_usage",
+      "heartbeat",
+    )
+    .option(
+      "-s, --status <status>",
+      "healthy|degraded|unhealthy|unknown",
+      "healthy",
+    )
+    .option("-m, --metrics <json>", "Optional metrics JSON")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const db = _dbFromCtx(fed);
+      const metrics = opts.metrics ? JSON.parse(opts.metrics) : undefined;
+      const r = recordHealthCheckV2(db, {
+        nodeId,
+        checkType: opts.type,
+        status: opts.status,
+        metrics,
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`recorded check ${r.checkId}`);
+    });
+
+  fed
+    .command("trip-circuit <node-id>")
+    .description("Force-trip a circuit breaker (closed/half_open → open)")
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const db = _dbFromCtx(fed);
+      const r = tripCircuit(db, nodeId);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`${nodeId} circuit → ${r.state}`);
+    });
+
+  fed
+    .command("auto-isolate-unhealthy")
+    .description(
+      "Bulk-isolate ACTIVE nodes with N consecutive UNHEALTHY checks",
+    )
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(fed);
+      const r = autoIsolateUnhealthyNodes(db);
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Isolated ${r.length} node(s)`);
+      for (const n of r) console.log(`  ${n.node_id}`);
+    });
+
+  fed
+    .command("stats-v2")
+    .description("V2 federation hardening statistics")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(fed);
+      const s = getFederationHardeningStatsV2(db);
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(
+        `Nodes: ${s.totalNodes} (active=${s.activeNodes}, isolated=${s.isolatedNodes})`,
+      );
+      console.log(`Circuits: ${s.totalCircuits}`);
+      for (const [state, count] of Object.entries(s.circuitsByState)) {
+        if (count > 0) console.log(`  ${state.padEnd(10)} ${count}`);
+      }
+      console.log(`Health checks: ${s.totalHealthChecks}`);
+      console.log(
+        `config: failureThreshold=${s.failureThreshold} halfOpenCooldownMs=${s.halfOpenCooldownMs} unhealthyThreshold=${s.unhealthyThreshold} maxActiveNodes=${s.maxActiveNodes}`,
+      );
+    });
+
   program.addCommand(fed);
 }