chainlesschain 0.66.0 → 0.132.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/export.js

@@ -8,7 +8,41 @@ import ora from "ora";
 import { resolve } from "path";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
-import { exportToMarkdown, exportToSite } from "../lib/knowledge-exporter.js";
+import {
+  exportToMarkdown,
+  exportToSite,
+  TARGET_MATURITY_V2,
+  EXPORT_JOB_LIFECYCLE_V2,
+  getMaxActiveTargetsPerOwnerV2,
+  setMaxActiveTargetsPerOwnerV2,
+  getMaxPendingJobsPerTargetV2,
+  setMaxPendingJobsPerTargetV2,
+  getTargetIdleMsV2,
+  setTargetIdleMsV2,
+  getJobStuckMsV2,
+  setJobStuckMsV2,
+  registerTargetV2,
+  getTargetV2,
+  listTargetsV2,
+  setTargetStatusV2,
+  activateTargetV2,
+  pauseTargetV2,
+  archiveTargetV2,
+  touchTargetV2,
+  getActiveTargetCountV2,
+  createExportJobV2,
+  getExportJobV2,
+  listExportJobsV2,
+  setExportJobStatusV2,
+  startExportJobV2,
+  completeExportJobV2,
+  failExportJobV2,
+  cancelExportJobV2,
+  getPendingJobCountV2,
+  autoPauseIdleTargetsV2,
+  autoFailStuckExportJobsV2,
+  getKnowledgeExporterStatsV2,
+} from "../lib/knowledge-exporter.js";
 
 export function registerExportCommand(program) {
   const exp = program
@@ -122,4 +156,225 @@ export function registerExportCommand(program) {
         process.exit(1);
       }
     });
+
+  // ─── V2 Governance Layer ──────────────────────────────────────────
+  const out = (obj) => console.log(JSON.stringify(obj, null, 2));
+  const tryRun = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  exp
+    .command("target-maturities-v2")
+    .description("List V2 target maturity states")
+    .action(() => out(Object.values(TARGET_MATURITY_V2)));
+
+  exp
+    .command("export-job-lifecycles-v2")
+    .description("List V2 export-job lifecycle states")
+    .action(() => out(Object.values(EXPORT_JOB_LIFECYCLE_V2)));
+
+  exp
+    .command("stats-v2")
+    .description("V2 knowledge-exporter stats")
+    .action(() => out(getKnowledgeExporterStatsV2()));
+
+  exp
+    .command("get-max-active-targets-v2")
+    .description("Get max active targets per owner (V2)")
+    .action(() =>
+      out({ maxActiveTargetsPerOwner: getMaxActiveTargetsPerOwnerV2() }),
+    );
+
+  exp
+    .command("set-max-active-targets-v2 <n>")
+    .description("Set max active targets per owner (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveTargetsPerOwnerV2(Number(n));
+        out({ maxActiveTargetsPerOwner: getMaxActiveTargetsPerOwnerV2() });
+      }),
+    );
+
+  exp
+    .command("get-max-pending-jobs-v2")
+    .description("Get max pending jobs per target (V2)")
+    .action(() =>
+      out({ maxPendingJobsPerTarget: getMaxPendingJobsPerTargetV2() }),
+    );
+
+  exp
+    .command("set-max-pending-jobs-v2 <n>")
+    .description("Set max pending jobs per target (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingJobsPerTargetV2(Number(n));
+        out({ maxPendingJobsPerTarget: getMaxPendingJobsPerTargetV2() });
+      }),
+    );
+
+  exp
+    .command("get-target-idle-ms-v2")
+    .description("Get target idle threshold (V2)")
+    .action(() => out({ targetIdleMs: getTargetIdleMsV2() }));
+
+  exp
+    .command("set-target-idle-ms-v2 <ms>")
+    .description("Set target idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setTargetIdleMsV2(Number(ms));
+        out({ targetIdleMs: getTargetIdleMsV2() });
+      }),
+    );
+
+  exp
+    .command("get-job-stuck-ms-v2")
+    .description("Get export-job stuck threshold (V2)")
+    .action(() => out({ jobStuckMs: getJobStuckMsV2() }));
+
+  exp
+    .command("set-job-stuck-ms-v2 <ms>")
+    .description("Set export-job stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setJobStuckMsV2(Number(ms));
+        out({ jobStuckMs: getJobStuckMsV2() });
+      }),
+    );
+
+  exp
+    .command("active-target-count-v2 <ownerId>")
+    .description("Active target count for owner (V2)")
+    .action((ownerId) =>
+      out({ ownerId, count: getActiveTargetCountV2(ownerId) }),
+    );
+
+  exp
+    .command("pending-job-count-v2 <targetId>")
+    .description("Pending export-job count for target (V2)")
+    .action((targetId) =>
+      out({ targetId, count: getPendingJobCountV2(targetId) }),
+    );
+
+  exp
+    .command("register-target-v2 <id>")
+    .description("Register a V2 export target")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-l, --label <label>", "target label")
+    .option("-f, --format <format>", "target format", "markdown")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          registerTargetV2(id, {
+            ownerId: opts.owner,
+            label: opts.label,
+            format: opts.format,
+          }),
+        ),
+      ),
+    );
+
+  exp
+    .command("get-target-v2 <id>")
+    .description("Get a V2 target")
+    .action((id) => out(getTargetV2(id)));
+
+  exp
+    .command("list-targets-v2")
+    .description("List V2 targets")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listTargetsV2({ ownerId: opts.owner, status: opts.status })),
+    );
+
+  exp
+    .command("set-target-status-v2 <id> <next>")
+    .description("Set V2 target status")
+    .action((id, next) => tryRun(() => out(setTargetStatusV2(id, next))));
+
+  exp
+    .command("activate-target-v2 <id>")
+    .description("Activate a V2 target")
+    .action((id) => tryRun(() => out(activateTargetV2(id))));
+
+  exp
+    .command("pause-target-v2 <id>")
+    .description("Pause a V2 target")
+    .action((id) => tryRun(() => out(pauseTargetV2(id))));
+
+  exp
+    .command("archive-target-v2 <id>")
+    .description("Archive a V2 target")
+    .action((id) => tryRun(() => out(archiveTargetV2(id))));
+
+  exp
+    .command("touch-target-v2 <id>")
+    .description("Touch a V2 target")
+    .action((id) => tryRun(() => out(touchTargetV2(id))));
+
+  exp
+    .command("create-export-job-v2 <id>")
+    .description("Create a V2 export job")
+    .requiredOption("-t, --target <id>", "target id")
+    .option("-k, --kind <kind>", "job kind", "snapshot")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(createExportJobV2(id, { targetId: opts.target, kind: opts.kind })),
+      ),
+    );
+
+  exp
+    .command("get-export-job-v2 <id>")
+    .description("Get a V2 export job")
+    .action((id) => out(getExportJobV2(id)));
+
+  exp
+    .command("list-export-jobs-v2")
+    .description("List V2 export jobs")
+    .option("-t, --target <id>", "filter by target")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listExportJobsV2({ targetId: opts.target, status: opts.status })),
+    );
+
+  exp
+    .command("set-export-job-status-v2 <id> <next>")
+    .description("Set V2 export-job status")
+    .action((id, next) => tryRun(() => out(setExportJobStatusV2(id, next))));
+
+  exp
+    .command("start-export-job-v2 <id>")
+    .description("Start a V2 export job")
+    .action((id) => tryRun(() => out(startExportJobV2(id))));
+
+  exp
+    .command("complete-export-job-v2 <id>")
+    .description("Complete a V2 export job")
+    .action((id) => tryRun(() => out(completeExportJobV2(id))));
+
+  exp
+    .command("fail-export-job-v2 <id>")
+    .description("Fail a V2 export job")
+    .action((id) => tryRun(() => out(failExportJobV2(id))));
+
+  exp
+    .command("cancel-export-job-v2 <id>")
+    .description("Cancel a V2 export job")
+    .action((id) => tryRun(() => out(cancelExportJobV2(id))));
+
+  exp
+    .command("auto-pause-idle-targets-v2")
+    .description("Auto-pause idle V2 targets")
+    .action(() => out(autoPauseIdleTargetsV2()));
+
+  exp
+    .command("auto-fail-stuck-export-jobs-v2")
+    .description("Auto-fail stuck V2 export jobs")
+    .action(() => out(autoFailStuckExportJobsV2()));
 }