chainlesschain 0.158.0 → 0.160.1

package/src/commands/mtc.js

@@ -11,30 +11,72 @@
 import fs from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
+import { ed25519 as nobleEd25519 } from "@noble/curves/ed25519";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import { getAllIdentities, getIdentity } from "../lib/did-manager.js";
 import { CLISkillLoader } from "../lib/skill-loader.js";
+import { getHomeDir } from "../lib/paths.js";
 import mtcLib from "@chainlesschain/core-mtc";
 
 const {
-  MerkleTree,
   encodeHashStr,
   sha256,
-  leafHash,
   jcs,
   LandmarkCache,
   verify,
-  SCHEMA_ENVELOPE,
-  SCHEMA_TREE_HEAD,
   SCHEMA_LANDMARK,
-  TREE_HEAD_SIG_PREFIX,
   ed25519,
+  slhDsa,
+  assembleBatch,
 } = mtcLib;
 
 const STOPGAP_BANNER = chalk.yellow(
-  "⚠ STOPGAP — tree-head signed with Ed25519 (will switch to SLH-DSA when @noble/post-quantum lands).",
+  "⚠ Tree-head signed with Ed25519 (classical default). Pass --alg slh-dsa-128f for FIPS 205 post-quantum signatures.",
 );
+const PQC_BANNER = chalk.green(
+  "✓ Tree-head signed with SLH-DSA-SHA2-128F (FIPS 205 post-quantum).",
+);
+
+/**
+ * Resolve --alg flag to a signer module + key sizes for read-back.
+ * ed25519 (classical, 32-byte sk) is the default; slh-dsa-128f is opt-in.
+ */
+/**
+ * Build a verifier that handles either Ed25519 or SLH-DSA tree-head signatures
+ * based on the landmark's trust_anchors. Each per-algorithm verifier rejects
+ * signatures of the wrong alg via `signatureObj.alg !== ALG`, so chaining
+ * them is safe — at most one will accept.
+ */
+function makeMultiAlgVerifier(landmark) {
+  const ed = ed25519.makeVerifierFromLandmark(landmark);
+  const slh = slhDsa.makeVerifierFromLandmark(landmark);
+  return (signingInput, signatureObj) =>
+    ed(signingInput, signatureObj) || slh(signingInput, signatureObj);
+}
+
+function resolveSigner(algFlag) {
+  const alg = (algFlag || "ed25519").toLowerCase();
+  if (alg === "ed25519") {
+    return {
+      name: "ed25519",
+      signer: ed25519,
+      secretKeyLen: 32,
+      banner: STOPGAP_BANNER,
+    };
+  }
+  if (alg === "slh-dsa-128f" || alg === "slh-dsa-sha2-128f") {
+    return {
+      name: "slh-dsa-128f",
+      signer: slhDsa,
+      secretKeyLen: 64,
+      banner: PQC_BANNER,
+    };
+  }
+  throw new Error(
+    `Unknown --alg: ${algFlag} (supported: ed25519, slh-dsa-128f)`,
+  );
+}
 
 function readJsonFile(filePath) {
   const raw = fs.readFileSync(filePath, "utf-8");
@@ -50,91 +92,362 @@ function writeJsonFile(filePath, obj) {
   fs.writeFileSync(filePath, JSON.stringify(obj, null, 2), "utf-8");
 }
 
-function loadOrGenerateKeyPair(secretKeyPath) {
+function loadOrGenerateKeyPair(secretKeyPath, signerInfo) {
+  const sig = signerInfo || resolveSigner(null);
   if (secretKeyPath && fs.existsSync(secretKeyPath)) {
     const secretKey = Buffer.from(
       fs.readFileSync(secretKeyPath, "utf-8").trim(),
       "hex",
     );
-    if (secretKey.length !== 32) {
+    if (secretKey.length !== sig.secretKeyLen) {
       throw new Error(
-        `Secret key file ${secretKeyPath} must contain 32 bytes (64 hex chars)`,
+        `Secret key file ${secretKeyPath} must contain ${sig.secretKeyLen} bytes for ${sig.name}`,
       );
     }
-    // Derive publicKey from secretKey via @noble/curves through ed25519.* — use generateKeyPair-style reload
-    // Simpler: re-derive via a helper. Since lib doesn't expose pubkey-from-secret directly, sign a probe
-    // and use ed25519.signRaw + ed25519.signTreeHead to recover pubkey isn't possible. Fall back to using
-    // a fresh keypair if no helper. Rather than add a helper, use @noble/curves directly here.
-    const { ed25519: ed25519Curve } = require("@noble/curves/ed25519");
-    const publicKey = Buffer.from(ed25519Curve.getPublicKey(secretKey));
+    let publicKey;
+    if (sig.name === "ed25519") {
+      publicKey = Buffer.from(nobleEd25519.getPublicKey(secretKey));
+    } else {
+      publicKey = sig.signer.getPublicKey(secretKey);
+    }
     return {
       secretKey,
       publicKey,
-      pubkeyId: ed25519.pubkeyId(publicKey),
+      pubkeyId: sig.signer.pubkeyId(publicKey),
     };
   }
-  return ed25519.generateKeyPair();
+  return sig.signer.generateKeyPair();
 }
 
 function buildBatch(rawLeaves, opts) {
-  const namespace = opts.namespace;
-  const issuer = opts.issuer;
-  const issuedAt = opts.issuedAt || new Date().toISOString();
-  const expiresAt =
-    opts.expiresAt || new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString();
+  // Phase 3.2: federation path takes precedence when --federation is set.
+  if (opts.federation) {
+    return buildFederatedBatch(rawLeaves, opts);
+  }
 
-  const keys = loadOrGenerateKeyPair(opts.secretKeyFile);
+  const sig = resolveSigner(opts.alg);
+  const keys = loadOrGenerateKeyPair(opts.secretKeyFile, sig);
+  const { landmark, envelopes, treeHeadId } = assembleBatch(
+    rawLeaves,
+    keys,
+    {
+      namespace: opts.namespace,
+      issuer: opts.issuer,
+      issuedAt: opts.issuedAt,
+      expiresAt: opts.expiresAt,
+    },
+    sig.signer,
+  );
+  return { landmark, envelopes, treeHeadId, keys, signerInfo: sig };
+}
 
-  const leafHashes = rawLeaves.map((l) => leafHash(jcs(l)));
-  const tree = new MerkleTree(leafHashes);
-  const root = tree.root();
+/**
+ * Federation-mode batch: loads all members of the named federation from
+ * the local registry, signs the tree_head with each member's key, and
+ * assembles an M-of-N landmark via assembleBatchFederated.
+ *
+ * @param {Array<object>} rawLeaves
+ * @param {{
+ *   federation: string,           // federation id from `cc mtc federation join <id>`
+ *   threshold?: number,            // M (default = N = all members)
+ *   namespace: string,
+ *   issuer: string,                // federation-level issuer (overrides individual member issuers in tree_head only)
+ *   issuedAt?: string,
+ *   expiresAt?: string,
+ * }} opts
+ */
+function buildFederatedBatch(rawLeaves, opts) {
+  const registry = loadFederationRegistry();
+  const fed = registry.federations[opts.federation];
+  if (!fed) {
+    throw new Error(
+      `unknown federation "${opts.federation}" — run \`cc mtc federation join ${opts.federation} --member-id <m>\` first`,
+    );
+  }
+  const members = Object.values(fed.members || {});
+  if (members.length === 0) {
+    throw new Error(`federation "${opts.federation}" has no members`);
+  }
 
-  const treeHead = {
-    schema: SCHEMA_TREE_HEAD,
-    namespace,
-    tree_size: leafHashes.length,
-    root_hash: encodeHashStr(root),
-    issued_at: issuedAt,
-    expires_at: expiresAt,
-    issuer,
-  };
-  const canonical = jcs(treeHead);
-  const treeHeadId = encodeHashStr(sha256(canonical));
-  const signingInput = Buffer.concat([TREE_HEAD_SIG_PREFIX, canonical]);
-  const signature = ed25519.signTreeHead(signingInput, {
-    secretKey: keys.secretKey,
-    publicKey: keys.publicKey,
-    issuer,
+  const threshold = Number.isInteger(opts.threshold)
+    ? opts.threshold
+    : members.length;
+
+  // Load each member's signing key from disk
+  const signers = members.map((m) => {
+    if (!m.key_file || !fs.existsSync(m.key_file)) {
+      throw new Error(
+        `member "${m.member_id}" key file missing: ${m.key_file}`,
+      );
+    }
+    // Match alg from registry, not from --alg flag (each member is fixed)
+    let sigInfo;
+    if (m.alg === "Ed25519") {
+      sigInfo = resolveSigner("ed25519");
+    } else if (m.alg === "SLH-DSA-SHA2-128F") {
+      sigInfo = resolveSigner("slh-dsa-128f");
+    } else {
+      throw new Error(`member "${m.member_id}" has unknown alg: ${m.alg}`);
+    }
+    const keys = loadOrGenerateKeyPair(m.key_file, sigInfo);
+    return {
+      secretKey: keys.secretKey,
+      publicKey: keys.publicKey,
+      signer: sigInfo.signer,
+      issuer: m.issuer,
+    };
   });
 
-  const landmark = {
-    schema: SCHEMA_LANDMARK,
-    namespace: namespace.split("/").slice(0, -1).join("/"),
-    snapshots: [{ tree_head: treeHead, tree_head_id: treeHeadId, signature }],
-    trust_anchors: [ed25519.trustAnchorEntry(keys.publicKey, issuer)],
-    published_at: issuedAt,
-    publisher_signature: {
-      alg: "Ed25519",
-      key_id: issuer + "#key-1",
-      sig: "TODO-PUBLISHER-SIG",
+  const fedSignerInfo = {
+    name: "federation",
+    threshold,
+    members: members.length,
+    member_ids: members.map((m) => m.member_id),
+    banner: chalk.cyan(
+      `✓ Federated tree-head — ${threshold}-of-${members.length} multi-signature (federation: ${opts.federation})`,
+    ),
+  };
+
+  const { landmark, envelopes, treeHeadId } = mtcLib.assembleBatchFederated(
+    rawLeaves,
+    signers,
+    {
+      namespace: opts.namespace,
+      issuer: opts.issuer,
+      threshold,
+      issuedAt: opts.issuedAt,
+      expiresAt: opts.expiresAt,
     },
+  );
+
+  return {
+    landmark,
+    envelopes,
+    treeHeadId,
+    keys: signers[0], // first member's key (publish-skills tries to persist; harmless to surface)
+    signerInfo: fedSignerInfo,
   };
+}
 
-  const envelopes = rawLeaves.map((leaf, i) => ({
-    schema: SCHEMA_ENVELOPE,
-    namespace,
-    tree_head_id: treeHeadId,
-    leaf,
-    inclusion_proof: {
-      leaf_index: i,
-      tree_size: leafHashes.length,
-      audit_path: tree.prove(i).map((b) => encodeHashStr(b)),
+// ─────────────────────────────────────────────────────────────────────
+// Marketplace publisher daemon (Phase 2 marketplace path)
+// ─────────────────────────────────────────────────────────────────────
+
+const PUBLISH_STATE_SCHEMA = "mtc-skill-publish-state/v1";
+
+function canonicalSkillsFingerprint(skills) {
+  // Sort by id for deterministic fingerprint, then JCS-canonicalize a tuple
+  // of (id, version, content_hash). This matches what batch-skills hashes
+  // into each leaf, so changing only metadata doesn't trigger churn but
+  // bumping a skill's version or body does.
+  const sorted = [...skills].sort((a, b) => a.id.localeCompare(b.id));
+  const tuples = sorted.map((s) => ({
+    id: s.id,
+    version: s.version,
+    category: s.category,
+    activation: s.activation,
+    description: s.description,
+  }));
+  return encodeHashStr(sha256(jcs(tuples)));
+}
+
+function loadPublishState(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    return {
+      schema: PUBLISH_STATE_SCHEMA,
+      last_seq: 0,
+      last_fingerprint: null,
+      last_published_at: null,
+      history: [],
+    };
+  }
+  const obj = readJsonFile(filePath);
+  if (obj.schema !== PUBLISH_STATE_SCHEMA) {
+    throw new Error(`state file ${filePath} has unknown schema: ${obj.schema}`);
+  }
+  return obj;
+}
+
+function savePublishState(filePath, state) {
+  // Atomic write: tmp + rename. Avoids the next run reading a truncated state
+  // file if the process crashes mid-write (which would silently reset last_seq
+  // and start re-publishing batches at 000001).
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+  fs.renameSync(tmp, filePath);
+}
+
+/**
+ * One iteration: load skills, compare fingerprint, optionally build a batch
+ * and persist state. Returns a structured result regardless of whether a
+ * batch was produced (for json output + tests).
+ */
+function publishSkillsOnce(options) {
+  const loader = new CLISkillLoader();
+  const allSkills = loader.loadAll();
+
+  let skills;
+  if (options.skill && options.skill.length > 0) {
+    const want = new Set(options.skill);
+    skills = allSkills.filter((s) => want.has(s.id));
+  } else {
+    skills = allSkills;
+  }
+
+  const state = loadPublishState(options.stateFile);
+  if (skills.length === 0) {
+    return {
+      iteration: "skipped",
+      reason: "no skills discovered",
+      skills_count: 0,
+      last_seq: state.last_seq,
+    };
+  }
+
+  const fingerprint = canonicalSkillsFingerprint(skills);
+  if (state.last_fingerprint === fingerprint) {
+    return {
+      iteration: "skipped",
+      reason: "fingerprint unchanged",
+      skills_count: skills.length,
+      last_seq: state.last_seq,
+      fingerprint,
+    };
+  }
+
+  const nextSeq = state.last_seq + 1;
+  const seqStr = String(nextSeq).padStart(6, "0");
+  const namespace = `${options.namespacePrefix}/${seqStr}`;
+  const batchDir = path.resolve(options.out, seqStr);
+
+  const rawLeaves = skills.map((s) => ({
+    kind: "skill-manifest",
+    content_hash: encodeHashStr(
+      sha256(
+        jcs({
+          id: s.id,
+          displayName: s.displayName,
+          description: s.description,
+          version: s.version,
+          category: s.category,
+          activation: s.activation,
+          tags: s.tags,
+        }),
+      ),
+    ),
+    issued_at: new Date().toISOString(),
+    subject: `skill:cc:${s.id}@${s.version}`,
+    metadata: {
+      publisher: options.issuer,
+      skill_id: s.id,
+      version: s.version,
+      category: s.category,
     },
   }));
 
-  return { landmark, envelopes, treeHeadId, keys };
+  const { landmark, envelopes, treeHeadId, keys } = buildBatch(rawLeaves, {
+    namespace,
+    issuer: options.issuer,
+    secretKeyFile: options.secretKeyFile,
+    alg: options.alg,
+  });
+
+  fs.mkdirSync(batchDir, { recursive: true });
+  const landmarkPath = path.join(batchDir, "landmark.json");
+  writeJsonFile(landmarkPath, landmark);
+  if (options.secretKeyFile && !fs.existsSync(options.secretKeyFile)) {
+    fs.mkdirSync(path.dirname(options.secretKeyFile), { recursive: true });
+    fs.writeFileSync(options.secretKeyFile, keys.secretKey.toString("hex"), {
+      mode: 0o600,
+    });
+  }
+  const envelopePaths = [];
+  for (let i = 0; i < envelopes.length; i++) {
+    const p = path.join(
+      batchDir,
+      `envelope-${String(i).padStart(6, "0")}.json`,
+    );
+    writeJsonFile(p, envelopes[i]);
+    envelopePaths.push(p);
+  }
+
+  const publishedAt = new Date().toISOString();
+  state.last_seq = nextSeq;
+  state.last_fingerprint = fingerprint;
+  state.last_published_at = publishedAt;
+  state.history.push({
+    seq: seqStr,
+    namespace,
+    tree_head_id: treeHeadId,
+    root_hash: landmark.snapshots[0].tree_head.root_hash,
+    tree_size: skills.length,
+    fingerprint,
+    published_at: publishedAt,
+    batch_dir: batchDir,
+  });
+  savePublishState(options.stateFile, state);
+
+  return {
+    iteration: "published",
+    seq: seqStr,
+    namespace,
+    tree_head_id: treeHeadId,
+    tree_size: skills.length,
+    batch_dir: batchDir,
+    landmark_path: landmarkPath,
+    envelope_paths: envelopePaths,
+    fingerprint,
+  };
+}
+
+async function publishSkillsLoop(options) {
+  const tick = () => {
+    try {
+      const result = publishSkillsOnce(options);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.iteration === "published") {
+        logger.success(
+          `[seq ${result.seq}] published ${result.tree_size} skill(s) → ${result.batch_dir}`,
+        );
+        logger.log(`  ${chalk.bold("Tree head ID:")} ${result.tree_head_id}`);
+      } else {
+        logger.info(`skipped: ${result.reason}`);
+      }
+    } catch (err) {
+      logger.error(`iteration failed: ${err.message}`);
+      if (options.once) throw err;
+    }
+  };
+
+  if (options.once) {
+    tick();
+    return;
+  }
+
+  tick();
+  const ms = Math.max(1, options.interval) * 1000;
+  const timer = setInterval(tick, ms);
+  const cleanup = () => {
+    clearInterval(timer);
+    process.exit(0);
+  };
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+  // Daemon: never resolve.
+  await new Promise(() => {});
 }
 
+// Export internals for unit tests
+export const _publishInternals = {
+  publishSkillsOnce,
+  loadPublishState,
+  savePublishState,
+  canonicalSkillsFingerprint,
+  PUBLISH_STATE_SCHEMA,
+};
+
 export function registerMtcCommand(program) {
   const mtc = program
     .command("mtc")
@@ -155,7 +468,21 @@ export function registerMtcCommand(program) {
     .option("--expires-at <iso>", "Override expires_at timestamp")
     .option(
       "--secret-key-file <path>",
-      "Reuse Ed25519 secret key from this hex file (creates one if missing)",
+      "Reuse secret key from hex file (creates one if missing); 32 B for ed25519, 64 B for slh-dsa-128f",
+    )
+    .option(
+      "--alg <name>",
+      "Signing algorithm: ed25519 (default, classical) | slh-dsa-128f (FIPS 205 post-quantum)",
+      "ed25519",
+    )
+    .option(
+      "--federation <id>",
+      "Use federation M-of-N multi-sig (overrides --alg / --secret-key-file; signers come from `cc mtc federation join` registry)",
+    )
+    .option(
+      "--threshold <n>",
+      "Federation threshold M (default: N = all members)",
+      (v) => parseInt(v, 10),
     )
     .option("--json", "Print JSON summary instead of human output")
     .action(async (inputPath, options) => {
@@ -165,16 +492,17 @@ export function registerMtcCommand(program) {
           throw new Error("Input must be a non-empty JSON array of leaves");
         }
 
-        const { landmark, envelopes, treeHeadId, keys } = buildBatch(
-          rawLeaves,
-          {
+        const { landmark, envelopes, treeHeadId, keys, signerInfo } =
+          buildBatch(rawLeaves, {
             namespace: options.namespace,
             issuer: options.issuer,
             issuedAt: options.issuedAt,
             expiresAt: options.expiresAt,
             secretKeyFile: options.secretKeyFile,
-          },
-        );
+            alg: options.alg,
+            federation: options.federation,
+            threshold: options.threshold,
+          });
 
         const outDir = path.resolve(options.out);
         const landmarkPath = path.join(outDir, "landmark.json");
@@ -218,7 +546,7 @@ export function registerMtcCommand(program) {
             ),
           );
         } else {
-          logger.log(STOPGAP_BANNER);
+          logger.log(signerInfo ? signerInfo.banner : STOPGAP_BANNER);
           logger.success("Batch built");
           logger.log(`  ${chalk.bold("Namespace:")}    ${options.namespace}`);
           logger.log(`  ${chalk.bold("Tree size:")}    ${rawLeaves.length}`);
@@ -253,7 +581,7 @@ export function registerMtcCommand(program) {
         const landmark = readJsonFile(options.landmark);
 
         const cache = new LandmarkCache({
-          signatureVerifier: ed25519.makeVerifierFromLandmark(landmark),
+          signatureVerifier: makeMultiAlgVerifier(landmark),
         });
         cache.ingest(landmark);
 
@@ -266,7 +594,7 @@ export function registerMtcCommand(program) {
           return;
         }
         if (result.ok) {
-          logger.log(STOPGAP_BANNER);
+          logger.log(signerInfo ? signerInfo.banner : STOPGAP_BANNER);
           logger.success(`Envelope verified`);
           logger.log(
             `  ${chalk.bold("Subject:")}   ${result.leaf.subject || "(no subject)"}`,
@@ -375,7 +703,21 @@ export function registerMtcCommand(program) {
     .option("--expires-at <iso>", "Override expires_at timestamp")
     .option(
       "--secret-key-file <path>",
-      "Reuse Ed25519 secret key from this hex file (creates one if missing)",
+      "Reuse secret key from hex file (creates one if missing); 32 B for ed25519, 64 B for slh-dsa-128f",
+    )
+    .option(
+      "--alg <name>",
+      "Signing algorithm: ed25519 (default, classical) | slh-dsa-128f (FIPS 205 post-quantum)",
+      "ed25519",
+    )
+    .option(
+      "--federation <id>",
+      "Use federation M-of-N multi-sig (overrides --alg / --secret-key-file; signers come from `cc mtc federation join` registry)",
+    )
+    .option(
+      "--threshold <n>",
+      "Federation threshold M (default: N = all members)",
+      (v) => parseInt(v, 10),
     )
     .option("--json", "Print JSON summary instead of human output")
     .action(async (options) => {
@@ -417,16 +759,17 @@ export function registerMtcCommand(program) {
           };
         });
 
-        const { landmark, envelopes, treeHeadId, keys } = buildBatch(
-          rawLeaves,
-          {
+        const { landmark, envelopes, treeHeadId, keys, signerInfo } =
+          buildBatch(rawLeaves, {
             namespace: options.namespace,
             issuer: options.issuer,
             issuedAt: options.issuedAt,
             expiresAt: options.expiresAt,
             secretKeyFile: options.secretKeyFile,
-          },
-        );
+            alg: options.alg,
+            federation: options.federation,
+            threshold: options.threshold,
+          });
 
         const outDir = path.resolve(options.out);
         const landmarkPath = path.join(outDir, "landmark.json");
@@ -472,7 +815,7 @@ export function registerMtcCommand(program) {
             ),
           );
         } else {
-          logger.log(STOPGAP_BANNER);
+          logger.log(signerInfo ? signerInfo.banner : STOPGAP_BANNER);
           logger.success(`Batched ${rawLeaves.length} DID(s)`);
           logger.log(`  ${chalk.bold("Namespace:")}    ${options.namespace}`);
           logger.log(`  ${chalk.bold("Tree size:")}    ${rawLeaves.length}`);
@@ -514,7 +857,21 @@ export function registerMtcCommand(program) {
     .option("--expires-at <iso>", "Override expires_at timestamp")
     .option(
       "--secret-key-file <path>",
-      "Reuse Ed25519 secret key from this hex file (creates one if missing)",
+      "Reuse secret key from hex file (creates one if missing); 32 B for ed25519, 64 B for slh-dsa-128f",
+    )
+    .option(
+      "--alg <name>",
+      "Signing algorithm: ed25519 (default, classical) | slh-dsa-128f (FIPS 205 post-quantum)",
+      "ed25519",
+    )
+    .option(
+      "--federation <id>",
+      "Use federation M-of-N multi-sig (overrides --alg / --secret-key-file; signers come from `cc mtc federation join` registry)",
+    )
+    .option(
+      "--threshold <n>",
+      "Federation threshold M (default: N = all members)",
+      (v) => parseInt(v, 10),
     )
     .option("--json", "Print JSON summary instead of human output")
     .action(async (options) => {
@@ -563,16 +920,17 @@ export function registerMtcCommand(program) {
           };
         });
 
-        const { landmark, envelopes, treeHeadId, keys } = buildBatch(
-          rawLeaves,
-          {
+        const { landmark, envelopes, treeHeadId, keys, signerInfo } =
+          buildBatch(rawLeaves, {
             namespace: options.namespace,
             issuer: options.issuer,
             issuedAt: options.issuedAt,
             expiresAt: options.expiresAt,
             secretKeyFile: options.secretKeyFile,
-          },
-        );
+            alg: options.alg,
+            federation: options.federation,
+            threshold: options.threshold,
+          });
 
         const outDir = path.resolve(options.out);
         const landmarkPath = path.join(outDir, "landmark.json");
@@ -618,7 +976,7 @@ export function registerMtcCommand(program) {
             ),
           );
         } else {
-          logger.log(STOPGAP_BANNER);
+          logger.log(signerInfo ? signerInfo.banner : STOPGAP_BANNER);
           logger.success(`Batched ${rawLeaves.length} skill(s)`);
           logger.log(`  ${chalk.bold("Namespace:")}    ${options.namespace}`);
           logger.log(`  ${chalk.bold("Tree size:")}    ${rawLeaves.length}`);
@@ -641,6 +999,154 @@ export function registerMtcCommand(program) {
       }
     });
 
+  // mtc publish-skills — marketplace publisher daemon
+  // Periodically scans CLISkillLoader, detects deltas via a fingerprint, and
+  // when the skill set changes auto-closes a new batch (assembleBatch) into
+  // <out>/<seq>/. Stateful via a JSON state file so re-runs skip unchanged sets.
+  //
+  // Phase 2 marketplace path — does NOT depend on the audit Q-COMP blockers.
+  mtc
+    .command("publish-skills")
+    .description(
+      "Marketplace publisher daemon: detect skill deltas + auto-close batches",
+    )
+    .requiredOption(
+      "--namespace-prefix <prefix>",
+      "Namespace prefix; seq is auto-appended (e.g. mtc/v1/skill)",
+    )
+    .requiredOption("--issuer <issuer>", "MTCA issuer string")
+    .requiredOption(
+      "--out <dir>",
+      "Output root directory (each batch lands in <out>/<seq>/)",
+    )
+    .requiredOption(
+      "--state-file <path>",
+      "State JSON file tracking last_seq + fingerprint",
+    )
+    .option(
+      "--secret-key-file <path>",
+      "Reuse secret key from hex file (creates one if missing); 32 B for ed25519, 64 B for slh-dsa-128f",
+    )
+    .option(
+      "--alg <name>",
+      "Signing algorithm: ed25519 (default, classical) | slh-dsa-128f (FIPS 205 post-quantum)",
+      "ed25519",
+    )
+    .option(
+      "--federation <id>",
+      "Use federation M-of-N multi-sig (overrides --alg / --secret-key-file; signers come from `cc mtc federation join` registry)",
+    )
+    .option(
+      "--threshold <n>",
+      "Federation threshold M (default: N = all members)",
+      (v) => parseInt(v, 10),
+    )
+    .option(
+      "--interval <seconds>",
+      "Loop interval (default: 600 = 10min, ignored if --once)",
+      (v) => parseInt(v, 10),
+      600,
+    )
+    .option("--once", "Run a single iteration and exit (test/CI use)")
+    .option(
+      "--skill <id>",
+      "Restrict to specific skill ids (repeatable)",
+      (v, prev) => [...(prev || []), v],
+    )
+    .option("--json", "Print JSON summary on each iteration")
+    .action(async (options) => {
+      try {
+        await publishSkillsLoop(options);
+      } catch (err) {
+        logger.error(`mtc publish-skills failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mtc publish-status — read-only inspector for publish-skills state file.
+  // Used by web-panel (browser can't read the filesystem directly; this gives
+  // it a CLI-bridge-friendly query path without exposing the daemon machinery).
+  mtc
+    .command("publish-status <state-file>")
+    .description(
+      "Read a publish-skills state file and print its current state + recent history",
+    )
+    .option(
+      "--limit <n>",
+      "Limit history entries (default: 20, latest first)",
+      (v) => parseInt(v, 10),
+      20,
+    )
+    .option("--json", "Output JSON (default: human)")
+    .action((stateFile, options) => {
+      try {
+        if (!fs.existsSync(stateFile)) {
+          if (options.json) {
+            console.log(
+              JSON.stringify(
+                { ok: true, exists: false, state_file: stateFile },
+                null,
+                2,
+              ),
+            );
+          } else {
+            logger.warn(`state file not found: ${stateFile}`);
+          }
+          return;
+        }
+        const state = loadPublishState(stateFile);
+        const history = Array.isArray(state.history) ? state.history : [];
+        const limited = history.slice().reverse().slice(0, options.limit);
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                ok: true,
+                exists: true,
+                state_file: stateFile,
+                last_seq: state.last_seq,
+                last_fingerprint: state.last_fingerprint,
+                last_published_at: state.last_published_at,
+                history_count: history.length,
+                history: limited,
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+        logger.log(chalk.bold(`Publish state: ${stateFile}`));
+        logger.log(`  ${chalk.bold("Last seq:")}         ${state.last_seq}`);
+        logger.log(
+          `  ${chalk.bold("Last published:")}   ${state.last_published_at || "(never)"}`,
+        );
+        logger.log(`  ${chalk.bold("History entries:")}  ${history.length}`);
+        if (limited.length > 0) {
+          logger.log("");
+          logger.log(chalk.bold(`Recent history (latest ${limited.length}):`));
+          for (const h of limited) {
+            logger.log(
+              `  ${chalk.cyan(h.seq)}  ${h.namespace}  size=${h.tree_size}  ${chalk.gray(h.published_at)}`,
+            );
+          }
+        }
+      } catch (err) {
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { ok: false, error: err.message, state_file: stateFile },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.error(`mtc publish-status failed: ${err.message}`);
+        }
+        process.exit(1);
+      }
+    });
+
   // mtc serve — verifier daemon: subscribe to a transport, persist + verify
   mtc
     .command("serve")
@@ -734,7 +1240,7 @@ export function registerMtcCommand(program) {
               // Lazy-init cache from first landmark's trust_anchors
               if (!cache) {
                 cache = new LandmarkCache({
-                  signatureVerifier: ed25519.makeVerifierFromLandmark(landmark),
+                  signatureVerifier: makeMultiAlgVerifier(landmark),
                   persistDir: options.cacheDir,
                 });
                 if (options.cacheDir) {
@@ -783,4 +1289,813 @@ export function registerMtcCommand(program) {
         process.exit(1);
       }
     });
+
+  // ─────────────────────────────────────────────────────────────────────
+  // Phase 3 federation MTCA commands
+  // M-of-N multi-sig is implemented in core-mtc/lib/batch.js;
+  // federation member tracking lives in ~/.chainlesschain/federation/
+  // members.json (one entry per joined federation, keyed by federation id).
+  // ─────────────────────────────────────────────────────────────────────
+  registerFederationCommands(mtc);
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Federation member registry helpers (Phase 3.1)
+// ─────────────────────────────────────────────────────────────────────────
+
+const FEDERATION_REGISTRY_SCHEMA = "mtc-federation-registry/v1";
+
+function getFederationDir() {
+  const home = getHomeDir();
+  return path.join(home, "federation");
 }
+
+function getFederationRegistryPath() {
+  return path.join(getFederationDir(), "members.json");
+}
+
+function loadFederationRegistry() {
+  const file = getFederationRegistryPath();
+  if (!fs.existsSync(file)) {
+    return { schema: FEDERATION_REGISTRY_SCHEMA, federations: {} };
+  }
+  const obj = readJsonFile(file);
+  if (obj.schema !== FEDERATION_REGISTRY_SCHEMA) {
+    throw new Error(
+      `federation registry has unknown schema: ${obj.schema} (expected ${FEDERATION_REGISTRY_SCHEMA})`,
+    );
+  }
+  if (!obj.federations || typeof obj.federations !== "object") {
+    obj.federations = {};
+  }
+  return obj;
+}
+
+function saveFederationRegistry(registry) {
+  const file = getFederationRegistryPath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  // Atomic write to survive crash mid-write
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf-8");
+  fs.renameSync(tmp, file);
+}
+
+function registerFederationCommands(mtc) {
+  const fed = mtc
+    .command("federation")
+    .description("Phase 3 federation MTCA — manage M-of-N member registry");
+
+  // mtc federation join <federation-id>
+  fed
+    .command("join <federation-id>")
+    .description(
+      "Join a federation: generate a member keypair (or reuse existing) and register it locally",
+    )
+    .requiredOption(
+      "--member-id <id>",
+      "Local member identifier within the federation",
+    )
+    .option(
+      "--alg <name>",
+      "Signing algorithm: ed25519 (default) | slh-dsa-128f",
+      "ed25519",
+    )
+    .option(
+      "--issuer <issuer>",
+      "Member-level issuer string (default: mtca:cc:<federation-id>:<member-id>)",
+    )
+    .option("--key-file <path>", "Reuse existing secret key from hex file")
+    .option("--json", "Print JSON summary")
+    .action((federationId, options) => {
+      try {
+        const sig = resolveSigner(options.alg);
+        const issuer =
+          options.issuer || `mtca:cc:${federationId}:${options.memberId}`;
+        const registry = loadFederationRegistry();
+        const fedEntry = registry.federations[federationId] || {
+          federation_id: federationId,
+          members: {},
+          joined_at: new Date().toISOString(),
+        };
+        if (fedEntry.members[options.memberId]) {
+          throw new Error(
+            `member "${options.memberId}" already registered in federation "${federationId}" — leave first to rejoin`,
+          );
+        }
+
+        // Generate or load the keypair
+        let keys;
+        if (options.keyFile && fs.existsSync(options.keyFile)) {
+          keys = loadOrGenerateKeyPair(options.keyFile, sig);
+        } else {
+          keys = sig.signer.generateKeyPair();
+        }
+
+        // Persist the member's secret key under federation/keys/.
+        // Race-safe: 'wx' fails if another concurrent join already won, in
+        // which case we stick with that file rather than overwrite. Member
+        // re-join is blocked at the registry level above, so this only
+        // guards against simultaneous-join racing the same path.
+        const keysDir = path.join(getFederationDir(), "keys");
+        fs.mkdirSync(keysDir, { recursive: true });
+        const keyPath = path.join(
+          keysDir,
+          `${federationId}.${options.memberId}.hex`,
+        );
+        try {
+          fs.writeFileSync(keyPath, keys.secretKey.toString("hex"), {
+            mode: 0o600,
+            flag: "wx",
+          });
+        } catch (err) {
+          if (err.code !== "EEXIST") throw err;
+          // Concurrent join wrote the file first — re-load from disk and
+          // align our keys so registry + key file match.
+          keys = loadOrGenerateKeyPair(keyPath, sig);
+        }
+
+        const trustAnchor = sig.signer.trustAnchorEntry(keys.publicKey, issuer);
+        fedEntry.members[options.memberId] = {
+          member_id: options.memberId,
+          issuer,
+          alg: sig.signer.ALG,
+          pubkey_id: trustAnchor.pubkey_id,
+          pubkey_jwk: trustAnchor.pubkey_jwk,
+          key_file: keyPath,
+          joined_at: new Date().toISOString(),
+        };
+        registry.federations[federationId] = fedEntry;
+        saveFederationRegistry(registry);
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                ok: true,
+                federation_id: federationId,
+                member_id: options.memberId,
+                issuer,
+                alg: sig.signer.ALG,
+                pubkey_id: trustAnchor.pubkey_id,
+                key_file: keyPath,
+              },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.success(
+            `joined federation "${federationId}" as "${options.memberId}"`,
+          );
+          logger.log(`  ${chalk.bold("Issuer:")}     ${issuer}`);
+          logger.log(`  ${chalk.bold("Algorithm:")}  ${sig.signer.ALG}`);
+          logger.log(`  ${chalk.bold("Pubkey id:")}  ${trustAnchor.pubkey_id}`);
+          logger.log(`  ${chalk.bold("Key file:")}   ${chalk.cyan(keyPath)}`);
+        }
+      } catch (err) {
+        logger.error(`mtc federation join failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mtc federation leave <federation-id> --member-id <id>
+  fed
+    .command("leave <federation-id>")
+    .description(
+      "Leave a federation: remove the member entry from the local registry",
+    )
+    .requiredOption("--member-id <id>", "Member id to remove")
+    .option(
+      "--keep-key",
+      "Keep the secret key file on disk (default: removes the key file as well)",
+    )
+    .option("--json", "Print JSON summary")
+    .action((federationId, options) => {
+      try {
+        const registry = loadFederationRegistry();
+        const fedEntry = registry.federations[federationId];
+        if (!fedEntry || !fedEntry.members[options.memberId]) {
+          throw new Error(
+            `member "${options.memberId}" not found in federation "${federationId}"`,
+          );
+        }
+        const member = fedEntry.members[options.memberId];
+        delete fedEntry.members[options.memberId];
+        if (Object.keys(fedEntry.members).length === 0) {
+          delete registry.federations[federationId];
+        }
+        saveFederationRegistry(registry);
+
+        if (
+          !options.keepKey &&
+          member.key_file &&
+          fs.existsSync(member.key_file)
+        ) {
+          try {
+            fs.unlinkSync(member.key_file);
+          } catch (_err) {
+            /* non-fatal */
+          }
+        }
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                ok: true,
+                federation_id: federationId,
+                member_id: options.memberId,
+                key_file_removed: !options.keepKey,
+              },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.success(
+            `left federation "${federationId}" — member "${options.memberId}" removed${
+              options.keepKey ? "" : " (key file deleted)"
+            }`,
+          );
+        }
+      } catch (err) {
+        logger.error(`mtc federation leave failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // mtc federation status [federation-id]
+  fed
+    .command("status [federation-id]")
+    .description("Show registered federations and their members")
+    .option("--json", "Output JSON")
+    .action((federationId, options) => {
+      try {
+        const registry = loadFederationRegistry();
+        const data = federationId
+          ? { [federationId]: registry.federations[federationId] || null }
+          : registry.federations;
+
+        if (options.json) {
+          console.log(JSON.stringify({ ok: true, federations: data }, null, 2));
+          return;
+        }
+
+        const ids = Object.keys(data).filter((k) => data[k]);
+        if (ids.length === 0) {
+          logger.info(
+            "no federations registered (run `cc mtc federation join <id> --member-id <m>`)",
+          );
+          return;
+        }
+
+        for (const id of ids) {
+          const f = data[id];
+          const memberCount = Object.keys(f.members || {}).length;
+          logger.log(chalk.bold(`Federation: ${chalk.cyan(id)}`));
+          logger.log(`  ${chalk.bold("Joined at:")} ${f.joined_at || "—"}`);
+          logger.log(`  ${chalk.bold("Members:")}   ${memberCount}`);
+          for (const m of Object.values(f.members || {})) {
+            logger.log(
+              `    · ${chalk.green(m.member_id)} (${m.alg})  ${chalk.gray(m.pubkey_id.slice(0, 18) + "…")}`,
+            );
+            logger.log(`        issuer: ${m.issuer}`);
+            logger.log(`        key:    ${chalk.gray(m.key_file)}`);
+          }
+        }
+      } catch (err) {
+        logger.error(`mtc federation status failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ─────────────────────────────────────────────────────────────────────
+  // Phase 3.3 — federation discovery via filesystem drop-zone.
+  // Each member periodically writes a self-signed announce to a shared
+  // directory (NFS / SMB / Syncthing / USB stick). Other nodes scan the
+  // dir + ingest valid announces into a TTL-evicting roster cache.
+  //
+  // Production note: real libp2p gossipsub-based discovery (auto-announce
+  // on a pubsub topic) is the natural next layer — the announce schema +
+  // verify + cache are transport-agnostic, so wiring gossipsub is purely
+  // a delivery question. Filesystem mode covers LAN / shared-fs / offline
+  // use cases without any p2p network code.
+  // ─────────────────────────────────────────────────────────────────────
+  fed
+    .command("discover <federation-id>")
+    .description(
+      "Subscribe to federation announces via filesystem drop-zone or libp2p gossipsub",
+    )
+    .option(
+      "--transport <kind>",
+      "Transport: filesystem (default, --drop-zone required) | libp2p (--listen + --connect)",
+      "filesystem",
+    )
+    .option(
+      "--drop-zone <dir>",
+      "[filesystem] Shared directory all federation members read+write to (NFS / Syncthing / SMB)",
+    )
+    .option(
+      "--listen <multiaddr>",
+      "[libp2p] Listen address (default: /ip4/127.0.0.1/tcp/0)",
+    )
+    .option(
+      "--connect <multiaddr>",
+      "[libp2p] Dial this peer on startup (repeatable)",
+      (v, prev) => [...(prev || []), v],
+    )
+    .option(
+      "--member-id <id>",
+      "If joined as this member, also publish a self-announce (omit = listen-only mode)",
+    )
+    .option(
+      "--ttl <seconds>",
+      "Announce TTL (default 600 = 10 min); a re-announce fires at TTL/3",
+      (v) => parseInt(v, 10),
+      600,
+    )
+    .option("--once", "Announce once + scan once + exit (test/CI use)")
+    .option(
+      "--cache-dir <dir>",
+      "Persist accepted announces to this dir for restart resume",
+    )
+    .option(
+      "--scan-interval <seconds>",
+      "[filesystem] Drop-zone poll interval (default 30)",
+      (v) => parseInt(v, 10),
+      30,
+    )
+    .option(
+      "--mesh-wait-ms <n>",
+      "[libp2p] Mesh formation wait before announce (default 1500)",
+      (v) => parseInt(v, 10),
+      1500,
+    )
+    .option("--json", "Print JSON status snapshot (used with --once)")
+    .action(async (federationId, options) => {
+      try {
+        await runFederationDiscover(federationId, options);
+      } catch (err) {
+        logger.error(`mtc federation discover failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Federation discover daemon (Phase 3.3)
+// ─────────────────────────────────────────────────────────────────────────
+
+function getDiscoverAnnouncesDir(dropZone, federationId) {
+  return path.join(dropZone, "federation-announces", federationId);
+}
+
+function getDiscoverFilename(announce) {
+  // pubkey_id is "sha256:base64url" — replace : for cross-platform safety
+  const safe = announce.pubkey_id.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `${safe}.json`;
+}
+
+function publishAnnounce(dropZone, announce) {
+  const dir = getDiscoverAnnouncesDir(dropZone, announce.federation_id);
+  fs.mkdirSync(dir, { recursive: true });
+  const filename = getDiscoverFilename(announce);
+  const target = path.join(dir, filename);
+  // Atomic write: tmp + rename
+  const tmp = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(announce, null, 2), "utf-8");
+  fs.renameSync(tmp, target);
+  return target;
+}
+
+function scanDropZone(dropZone, federationId) {
+  const dir = getDiscoverAnnouncesDir(dropZone, federationId);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((n) => n.endsWith(".json"))
+    .map((n) => {
+      const file = path.join(dir, n);
+      try {
+        return { file, announce: JSON.parse(fs.readFileSync(file, "utf-8")) };
+      } catch (err) {
+        return { file, error: err.message };
+      }
+    });
+}
+
+/**
+ * Helper: load member key + return {announceBuilder, member} for self-announce.
+ * Used by both filesystem and libp2p paths.
+ */
+function loadFederationMemberForAnnounce(federationId, memberId, ttlSeconds) {
+  const registry = loadFederationRegistry();
+  const fedEntry = registry.federations[federationId];
+  if (!fedEntry || !fedEntry.members[memberId]) {
+    throw new Error(
+      `not joined as "${memberId}" in federation "${federationId}" — run \`cc mtc federation join ${federationId} --member-id ${memberId}\` first`,
+    );
+  }
+  const member = fedEntry.members[memberId];
+  if (!member.key_file || !fs.existsSync(member.key_file)) {
+    throw new Error(`member key file missing: ${member.key_file}`);
+  }
+  let signerInfo;
+  if (member.alg === "Ed25519") signerInfo = resolveSigner("ed25519");
+  else if (member.alg === "SLH-DSA-SHA2-128F")
+    signerInfo = resolveSigner("slh-dsa-128f");
+  else throw new Error(`unknown member alg: ${member.alg}`);
+  const keys = loadOrGenerateKeyPair(member.key_file, signerInfo);
+
+  return {
+    member,
+    buildAnnounce: () =>
+      mtcLib.createMemberAnnounce({
+        federationId,
+        memberId,
+        issuer: member.issuer,
+        secretKey: keys.secretKey,
+        publicKey: keys.publicKey,
+        signer: signerInfo.signer,
+        ttlSeconds,
+      }),
+  };
+}
+
+async function runFederationDiscover(federationId, options) {
+  const transport = (options.transport || "filesystem").toLowerCase();
+  if (transport === "libp2p") {
+    return runFederationDiscoverLibp2p(federationId, options);
+  }
+  if (transport !== "filesystem") {
+    throw new Error(
+      `Unknown --transport: ${options.transport} (supported: filesystem, libp2p)`,
+    );
+  }
+  if (!options.dropZone) {
+    throw new Error("--drop-zone is required when --transport=filesystem");
+  }
+  return runFederationDiscoverFilesystem(federationId, options);
+}
+
+async function runFederationDiscoverFilesystem(federationId, options) {
+  const FederationAnnounceCache = mtcLib.FederationAnnounceCache;
+
+  const cache = new FederationAnnounceCache({
+    persistDir: options.cacheDir,
+  });
+
+  // Build self-announce iff --member-id provided
+  let selfAnnounceFn = null;
+  if (options.memberId) {
+    const { buildAnnounce } = loadFederationMemberForAnnounce(
+      federationId,
+      options.memberId,
+      options.ttl,
+    );
+
+    selfAnnounceFn = () => {
+      const ann = buildAnnounce();
+      const written = publishAnnounce(options.dropZone, ann);
+      return { announce: ann, file: written };
+    };
+  }
+
+  function scanAndIngest() {
+    const entries = scanDropZone(options.dropZone, federationId);
+    let accepted = 0;
+    let rejected = 0;
+    const failures = [];
+    for (const e of entries) {
+      if (e.error) {
+        rejected++;
+        failures.push({ file: e.file, code: "PARSE_ERROR" });
+        continue;
+      }
+      const r = cache.ingest(e.announce);
+      if (r.accepted) accepted++;
+      else {
+        rejected++;
+        failures.push({ file: e.file, code: r.reason });
+      }
+    }
+    return { scanned: entries.length, accepted, rejected, failures };
+  }
+
+  function snapshot() {
+    return {
+      federation_id: federationId,
+      drop_zone: options.dropZone,
+      members: cache.listMembers(federationId).map((m) => ({
+        member_id: m.member_id,
+        issuer: m.issuer,
+        alg: m.alg,
+        pubkey_id: m.pubkey_id,
+        announced_at: m.announced_at,
+        ttl_seconds: m.ttl_seconds,
+      })),
+    };
+  }
+
+  // First pass: announce self + scan
+  let selfFile = null;
+  if (selfAnnounceFn) {
+    const r = selfAnnounceFn();
+    selfFile = r.file;
+  }
+  const firstScan = scanAndIngest();
+
+  if (options.once) {
+    const out = {
+      ok: true,
+      federation_id: federationId,
+      self_announce_file: selfFile,
+      scan: firstScan,
+      ...snapshot(),
+    };
+    if (options.json) {
+      console.log(JSON.stringify(out, null, 2));
+    } else {
+      logger.success(
+        `discovered ${out.members.length} member(s) in federation ${federationId}`,
+      );
+      for (const m of out.members) {
+        logger.log(
+          `  · ${chalk.green(m.member_id)} (${m.alg})  ${chalk.gray(m.pubkey_id.slice(0, 18) + "…")}`,
+        );
+      }
+    }
+    return;
+  }
+
+  // Daemon: re-announce + re-scan on intervals
+  const reannounceMs = Math.max(60, Math.floor(options.ttl / 3)) * 1000;
+  const scanMs = Math.max(1, options.scanInterval) * 1000;
+
+  let scanTimer = null;
+  let announceTimer = null;
+  function cleanup() {
+    if (scanTimer) clearInterval(scanTimer);
+    if (announceTimer) clearInterval(announceTimer);
+    process.exit(0);
+  }
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+
+  // Re-entrancy guard: if a scan tick takes longer than scanInterval (large
+  // drop-zone, slow disk), don't let setInterval stack up overlapping ticks.
+  let scanInProgress = false;
+  scanTimer = setInterval(() => {
+    if (scanInProgress) return;
+    scanInProgress = true;
+    try {
+      const r = scanAndIngest();
+      if (options.json) {
+        console.log(
+          JSON.stringify({ tick: "scan", ...r, ...snapshot() }, null, 2),
+        );
+      } else {
+        logger.log(
+          `[${new Date().toISOString()}] scan: ${r.accepted}+/${r.scanned} accepted, ${cache.listMembers(federationId).length} live`,
+        );
+      }
+    } catch (err) {
+      logger.error(`scan failed: ${err.message}`);
+    } finally {
+      scanInProgress = false;
+    }
+  }, scanMs);
+
+  if (selfAnnounceFn) {
+    announceTimer = setInterval(() => {
+      try {
+        selfAnnounceFn();
+        if (!options.json) {
+          logger.log(
+            `[${new Date().toISOString()}] re-announced self in federation ${federationId}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`self-announce failed: ${err.message}`);
+      }
+    }, reannounceMs);
+  }
+
+  logger.success(
+    `federation discover daemon running (drop-zone: ${options.dropZone}, scan: ${options.scanInterval}s, ttl: ${options.ttl}s)${
+      selfAnnounceFn ? `, announcing as ${options.memberId}` : ", listen-only"
+    }`,
+  );
+  await new Promise(() => {});
+}
+
+const FEDERATION_TOPIC_PREFIX = "mtc-federation/v1";
+
+function federationTopic(federationId) {
+  return `${FEDERATION_TOPIC_PREFIX}/${federationId}`;
+}
+
+async function runFederationDiscoverLibp2p(federationId, options) {
+  const FederationAnnounceCache = mtcLib.FederationAnnounceCache;
+  const { Libp2pTransport } =
+    await import("@chainlesschain/core-mtc/transports/libp2p");
+
+  const cache = new FederationAnnounceCache({
+    persistDir: options.cacheDir,
+  });
+
+  let selfBuildAnnounce = null;
+  let selfMember = null;
+  if (options.memberId) {
+    const { member, buildAnnounce } = loadFederationMemberForAnnounce(
+      federationId,
+      options.memberId,
+      options.ttl,
+    );
+    selfBuildAnnounce = buildAnnounce;
+    selfMember = member;
+  }
+
+  // Spin up gossipsub libp2p node
+  const node = await Libp2pTransport.create({
+    listen: options.listen,
+    mode: "gossipsub",
+  });
+
+  // Helper: tear down the node on any error path so we don't leak the
+  // libp2p host when initialization throws after node creation.
+  const closeNodeOnError = async (err) => {
+    try {
+      await node.close();
+    } catch (_e) {
+      /* ignore close errors during error cleanup */
+    }
+    throw err;
+  };
+
+  try {
+    return await runFederationDiscoverLibp2pInner(
+      federationId,
+      options,
+      node,
+      cache,
+      selfBuildAnnounce,
+      selfMember,
+    );
+  } catch (err) {
+    return closeNodeOnError(err);
+  }
+}
+
+async function runFederationDiscoverLibp2pInner(
+  federationId,
+  options,
+  node,
+  cache,
+  selfBuildAnnounce,
+  selfMember,
+) {
+  const topic = federationTopic(federationId);
+
+  // Subscribe + dispatch into cache
+  let bytesReceived = 0;
+  node.subscribeRaw(topic, (bytes) => {
+    bytesReceived++;
+    try {
+      cache.ingest(JSON.parse(new TextDecoder().decode(bytes)));
+    } catch (_err) {
+      /* malformed announce — drop */
+    }
+  });
+
+  // Dial seed peers
+  for (const peer of options.connect || []) {
+    try {
+      await node.connect(peer);
+    } catch (err) {
+      logger.warn(`connect to ${peer} failed: ${err.message}`);
+    }
+  }
+
+  // Mesh formation wait
+  const meshWaitMs = Math.max(0, options.meshWaitMs ?? 1500);
+  if (meshWaitMs > 0) await new Promise((r) => setTimeout(r, meshWaitMs));
+
+  async function publishSelf() {
+    if (!selfBuildAnnounce) return null;
+    const ann = selfBuildAnnounce();
+    const result = await node.publishRaw(topic, JSON.stringify(ann));
+    return { announce: ann, recipients: result.recipients };
+  }
+
+  function snapshot() {
+    return {
+      federation_id: federationId,
+      transport: "libp2p",
+      multiaddrs: node.multiaddrs(),
+      peer_id: node.peerIdString(),
+      members: cache.listMembers(federationId).map((m) => ({
+        member_id: m.member_id,
+        issuer: m.issuer,
+        alg: m.alg,
+        pubkey_id: m.pubkey_id,
+        announced_at: m.announced_at,
+        ttl_seconds: m.ttl_seconds,
+      })),
+    };
+  }
+
+  // First pass: announce self
+  let firstPublish = null;
+  if (selfBuildAnnounce) {
+    firstPublish = await publishSelf();
+  }
+
+  if (options.once) {
+    // Wait briefly for any incoming announces from peers we just dialed
+    if ((options.connect || []).length > 0) {
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+    const out = {
+      ok: true,
+      ...snapshot(),
+      self_announce: firstPublish
+        ? {
+            member_id: options.memberId,
+            issuer: selfMember?.issuer,
+            recipients: firstPublish.recipients,
+          }
+        : null,
+      bytes_received: bytesReceived,
+    };
+    if (options.json) {
+      console.log(JSON.stringify(out, null, 2));
+    } else {
+      logger.success(
+        `libp2p discover: peer_id=${out.peer_id}, ${out.members.length} member(s) cached`,
+      );
+      for (const a of out.multiaddrs) logger.log(`  listen: ${a}`);
+      for (const m of out.members) {
+        logger.log(
+          `  · ${chalk.green(m.member_id)} (${m.alg})  ${chalk.gray(m.pubkey_id.slice(0, 18) + "…")}`,
+        );
+      }
+    }
+    await node.close();
+    return;
+  }
+
+  // Daemon: re-announce on TTL/3
+  const reannounceMs = Math.max(60, Math.floor(options.ttl / 3)) * 1000;
+  let announceTimer = null;
+  if (selfBuildAnnounce) {
+    announceTimer = setInterval(async () => {
+      try {
+        await publishSelf();
+        if (!options.json) {
+          logger.log(
+            `[${new Date().toISOString()}] re-announced via libp2p in federation ${federationId}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`self-announce failed: ${err.message}`);
+      }
+    }, reannounceMs);
+  }
+
+  const cleanup = async () => {
+    if (announceTimer) clearInterval(announceTimer);
+    try {
+      await node.close();
+    } catch (_err) {
+      /* ignore */
+    }
+    process.exit(0);
+  };
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+
+  logger.success(
+    `federation discover daemon running (libp2p, peer_id: ${node.peerIdString()})${
+      selfBuildAnnounce
+        ? `, announcing as ${options.memberId} (TTL ${options.ttl}s)`
+        : ", listen-only"
+    }`,
+  );
+  for (const a of node.multiaddrs()) {
+    logger.log(`  listen: ${a}`);
+  }
+  await new Promise(() => {});
+}
+
+// Internals exported for tests
+export const _federationInternals = {
+  FEDERATION_REGISTRY_SCHEMA,
+  loadFederationRegistry,
+  saveFederationRegistry,
+  getFederationDir,
+  getFederationRegistryPath,
+  publishAnnounce,
+  scanDropZone,
+  getDiscoverAnnouncesDir,
+};