champollion 0.3.4 → 0.4.0

package/lib/commands/register-corpus.js

@@ -13,16 +13,19 @@
  *      text is never hosted by us. Gated by cli/lib/license-gate.mjs so NC /
  *      no-redistribute / unconfirmed licenses cannot enter the public lane.
  *
- * We NEVER read, upload, or host corpus content in ANY tier — only metadata and
- * (for public) a pointer to where the data is fetched from. This command writes
- * a metadata card; it never touches your sentences.
+ * We NEVER upload or host corpus content in ANY tier — only metadata and (for
+ * public) a pointer to where the data is fetched from. This command writes a
+ * metadata card. A file it is given is read on this machine only: --data to
+ * count its entries and compute its sha256, --seal-input (sealed tier) to
+ * encrypt it. Nothing it reads is copied, uploaded or sent anywhere.
  *
  * Interactive wizard when stdin is a TTY; fully scriptable via flags otherwise
- * (or with --yes). See `champollion register-corpus --help`.
+ * (or with --yes). See `champollion network register-corpus --help`.
  *
  * Exit codes: 0 = registered/saved (or cancelled); 1 = invalid request / gate block.
  */
 
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline';
@@ -37,6 +40,10 @@ import {
   gatePublicRegistration,
   buildCorpusCard,
   deriveCardId,
+  deriveIdSlug,
+  normalizeRole,
+  CORPUS_ROLES,
+  CARD_ID_PATTERN,
   slugify,
   resolveDestination,
   validateRegistration,
@@ -49,11 +56,280 @@ import {
   buildAad,
 } from '../seal.mjs';
 import { DEFAULT_QUALIFIER_THRESHOLD } from '../sealed-qualifier.mjs';
+import { getLanguageCard } from '../registers.js';
+import { findPublicCorporaBySha } from '../public-catalogue.js';
+import { parseLanguagePair, formatLanguagePair } from '../language-pair.js';
+import { showCommandHelp } from '../command-help.js';
+
+/** A word as a POSIX shell reads it back exactly (quoted only when it must be). */
+function shellQuote(word) {
+  const w = String(word);
+  return /^[A-Za-z0-9_.:/@%+=,-]+$/.test(w) ? w : `'${w.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * The language flags of the `mt-eval run` hint, filled from the card's pair
+ * (Round 7, hospital persona: the hint printed <src>/<tgt> although the card
+ * it had just written holds the pair). mt-eval's --source-lang/--target-lang
+ * are the NAMES the model is told (from the language card, else the
+ * project's own "name" for the code in champollion.config.json — a
+ * private-use code such as qaa has no card); --source-code/--target-lang-code
+ * are the codes the run is recorded under (--target-lang-code is mt-eval's
+ * documented spelling — --target-code is its alias, Round 12).
+ *
+ * @returns {{ flags: string, unnamed: string[], cardless: string[], names: Object<string, string|null> }}
+ *   unnamed: codes with no name anywhere (the hint says to put the language's
+ *   name in their flag); cardless: codes with no language card (nmt-forge init
+ *   needs --no-card for them); names: the name found for each code, or null
+ */
+function languageFlags(pair, cwd) {
+  let projectNames = {};
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(cwd, 'champollion.config.json'), 'utf-8'));
+    if (cfg && cfg.languages && typeof cfg.languages === 'object' && !Array.isArray(cfg.languages)) {
+      for (const [code, v] of Object.entries(cfg.languages)) if (v && typeof v.name === 'string') projectNames[code] = v.name;
+    }
+  } catch { projectNames = {}; }
+  const unnamed = [];
+  const cardless = [];
+  const names = {};
+  const nameOf = (code) => {
+    let card = null;
+    try { card = getLanguageCard(code); } catch { card = null; }
+    if (!card) cardless.push(code);
+    const name = (card && typeof card.name === 'string' && card.name) || projectNames[code] || null;
+    if (!name) unnamed.push(code);
+    names[code] = name;
+    return name || code;
+  };
+  const flags = `--source-lang ${shellQuote(nameOf(pair.source))} --target-lang ${shellQuote(nameOf(pair.target))} `
+    + `--source-code ${shellQuote(pair.source)} --target-lang-code ${shellQuote(pair.target)}`;
+  return { flags, unnamed, cardless, names };
+}
+
+/**
+ * Would someone train a model against this set? Then its first score must come
+ * AFTER nmt-forge has registered it and the predictions are written down.
+ * A test set — stated with --role test, or a local-only / private set whose
+ * role was not stated (the tiers a community's own held-out set uses) — may be
+ * trained against; a dev or train set is not what forge's predictions are
+ * judged on.
+ */
+function mayBeTrainedAgainst(req) {
+  if (req.role === 'test') return true;
+  if (req.role) return false;
+  return req.tier.key === 'local-only' || req.tier.key === 'private';
+}
+
+/**
+ * The nmt-forge project already set up for this pair: this directory, or one
+ * folder below it, that holds a forge workspace (.forge/) and a config.json
+ * for the same source and target. Exactly one such folder, or null — with
+ * none (or several) the hint starts a new one with `nmt-forge init`.
+ */
+function findForgeProject(cwd, pair) {
+  const candidates = [cwd];
+  let entries = [];
+  try { entries = fs.readdirSync(cwd, { withFileTypes: true }); } catch { entries = []; }
+  for (const e of entries) {
+    if (e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules') candidates.push(path.join(cwd, e.name));
+  }
+  const matches = candidates.filter((dir) => {
+    if (!fs.existsSync(path.join(dir, '.forge'))) return false;
+    let lang;
+    try { lang = JSON.parse(fs.readFileSync(path.join(dir, 'config.json'), 'utf-8'))?.language; } catch { return false; }
+    return !!lang && lang.source === pair.source && lang.target === pair.target;
+  });
+  return matches.length === 1 ? matches[0] : null;
+}
+
+/**
+ * What an existing forge project already knows about this file: the name it
+ * is registered under (matched by sha256 — forge hashes the file's bytes, as
+ * describeDataFile does), the preregistrations bound to it, and the set names
+ * taken by other files.
+ */
+function forgeKnows(projectDir, sha256) {
+  let sets = {};
+  try {
+    sets = JSON.parse(fs.readFileSync(path.join(projectDir, '.forge', 'eval-registry.json'), 'utf-8'))?.sets || {};
+  } catch { sets = {}; } // no registry yet: nothing is registered
+  const name = sha256 ? (Object.entries(sets).find(([, e]) => e && e.sha256 === sha256) || [null])[0] : null;
+  const preregs = [];
+  const preregIds = new Set();
+  const dir = path.join(projectDir, '.forge', 'preregistrations');
+  let files = [];
+  try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.json')); } catch { files = []; } // none written yet
+  for (const f of files) {
+    const id = f.replace(/\.json$/, '');
+    preregIds.add(id);
+    try {
+      const pr = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+      if (sha256 && pr?.eval_set?.sha256 === sha256) preregs.push(pr.id || id);
+    } catch { /* not a preregistration forge wrote: its id is still taken */ }
+  }
+  return { name, preregs, preregIds, taken: new Set(Object.keys(sets)) };
+}
+
+/**
+ * The nmt-forge steps that must come before ANY score of a test set a model
+ * may be trained against — the build-MT guide's "register, screen, predict"
+ * (Round 10, Cree-school persona: the "Next:" line went straight to
+ * `mt-eval run`, a scoring read, and forge then refuses the predictions).
+ * Paths are written from inside the forge project, where forge runs. An
+ * existing project is read first, so no printed step is one forge refuses:
+ * a file it already holds keeps its name, and `project-test` is not reused
+ * for a different file.
+ *
+ * @returns {{lines: string[], done: boolean}} done: the file is registered
+ *   and has predictions bound to it — the baseline can run now
+ */
+function forgeFirstLines({ pair, dataFile, sha256, cardId, cwd, lang }) {
+  const existing = findForgeProject(cwd, pair);
+  const projectDir = existing || path.join(cwd, `${pair.target}-model`);
+  const rel = path.relative(cwd, projectDir);
+  const where = rel || '.';
+  const known = existing ? forgeKnows(projectDir, sha256) : { name: null, preregs: [], preregIds: new Set(), taken: new Set() };
+  if (known.name && known.preregs.length > 0) {
+    return {
+      done: true,
+      lines: [
+        `  nmt-forge already holds this file (as ${known.name}, in ${where}) with predictions written`,
+        `  down before any score (${known.preregs.join(', ')}). \`nmt-forge status\` there names the next step.`,
+      ],
+    };
+  }
+  const setName = known.name || (known.taken.has('project-test') ? cardId : 'project-test');
+  // forge refuses a prereg id that exists ("the old one stands as history").
+  let preregId = 'all-data';
+  for (let n = 2; known.preregIds.has(preregId); n += 1) preregId = `all-data-${n}`;
+  // …and `prereg template --out` will not overwrite a predictions file.
+  let predictions = preregId === 'all-data' ? 'predictions.json' : `predictions-${preregId}.json`;
+  for (let n = 2; existing && fs.existsSync(path.join(projectDir, predictions)); n += 1) predictions = `predictions-${preregId}-${n}.json`;
+  const testFile = dataFile ? shellQuote(path.relative(projectDir, dataFile)) : '<your test file>';
+  const lines = [
+    `  Training a model for ${formatLanguagePair(pair)}? Do this first, before anything scores this file.`,
+    '  A benchmark is a scoring read, and nmt-forge refuses predictions written after one:',
+  ];
+  if (!existing) {
+    const noCard = lang.cardless.includes(pair.target)
+      ? ` --no-card --name ${lang.names[pair.target] ? shellQuote(lang.names[pair.target]) : "'<the language name>'"}`
+      : '';
+    lines.push(`    nmt-forge init ${shellQuote(pair.target)} --dir ${shellQuote(rel)}${noCard}   # once: the training project (any folder name)`);
+  }
+  if (rel) lines.push(`    cd ${shellQuote(rel)}`);
+  if (known.name) {
+    lines.push(`    # already registered with nmt-forge as ${known.name}`);
+  } else {
+    lines.push(`    nmt-forge registry add ${shellQuote(setName)} ${testFile} --role test`);
+  }
+  lines.push('    nmt-forge leak-audit <training corpus> --clean-to corpus.clean.jsonl');
+  lines.push(`    nmt-forge prereg template --out ${predictions}   # then edit it: what you expect, and why`);
+  lines.push(`    nmt-forge prereg new ${preregId} --eval-set ${shellQuote(setName)} --predictions ${predictions}`);
+  if (rel) lines.push('    cd ..');
+  lines.push('    (One prediction file per model you plan to train, each named after it — leak-audit\'s');
+  lines.push('    verdict may call for a second, twin-free model.)');
+  return { lines, done: false };
+}
+
+/** The model for a local run: the project's own when it runs `local`, else a placeholder. */
+function localModelFor(cwd) {
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(cwd, 'champollion.config.json'), 'utf-8'));
+    if (cfg?.defaultMethod === 'local' && typeof cfg.model === 'string' && cfg.model) return cfg.model;
+  } catch { /* no project config here */ }
+  return null;
+}
 
 // Tracked corpora-cards SSOT, resolved relative to this module.
 const DEFAULT_CARDS_DIR = fileURLToPath(new URL('../../shared/corpora-cards/', import.meta.url));
 
 const CONTAMINATION_LEVELS = ['NONE', 'LOW', 'MEDIUM', 'HIGH'];
+// Written (never typed): the file could not be compared with the public
+// corpora and no grade was stated — see the contamination block in run().
+const CONTAMINATION_UNCHECKED = 'UNCHECKED';
+
+// The steward sidecar the harness reads next to a corpus file
+// (mt_eval_harness.corpus_loader.SIDECAR_SUFFIX — keep the two in step).
+const SIDECAR_SUFFIX = '.champollion.json';
+
+/**
+ * Read the local data file a registration describes: its sha256 and how many
+ * sentence pairs it holds (TSV/text: non-empty lines that are not '# '
+ * comments; JSONL: non-empty lines; JSON: entries). The text itself is read
+ * only to hash and count it — it is never copied, uploaded or stored.
+ */
+function describeDataFile(file) {
+  const bytes = fs.readFileSync(file);
+  const sha256 = crypto.createHash('sha256').update(bytes).digest('hex');
+  const text = bytes.toString('utf-8').replace(/^\uFEFF/, '');
+  let rows;
+  if (file.endsWith('.json')) {
+    const data = JSON.parse(text);
+    rows = Array.isArray(data) ? data.length
+      : Array.isArray(data?.entries) ? data.entries.length : 0;
+  } else {
+    rows = text.split('\n')
+      .map((l) => l.replace(/\r$/, ''))
+      .filter((l) => l.trim() && !/^#(\s|$)/.test(l)).length;
+  }
+  return { sha256, rows };
+}
+
+/**
+ * The public corpus a file is a byte-identical copy of, from the corpora
+ * cards this CLI can see (each pins its built corpus's sha256, and the
+ * upstream archive's) — or null. A private, local-only or sealed card claims
+ * text no model has seen; a file the cards show is public cannot claim that
+ * (Round 8, researcher persona: a copy of the public Tatoeba eng→sme set was
+ * graded "Contamination: NONE", caught only later by `contest prepare`).
+ *
+ * @param {string} sha256
+ * @param {string} cardsDir
+ * @returns {{ id: string, name: string, license: string|null, risk: string|null }|null}
+ */
+function findPublicCopy(sha256, cardsDir) {
+  let files;
+  try { files = fs.readdirSync(cardsDir).filter((f) => f.endsWith('.json')); } catch { return null; }
+  for (const f of files) {
+    let card;
+    try { card = JSON.parse(fs.readFileSync(path.join(cardsDir, f), 'utf-8')); } catch { continue; }
+    const src = card?.source || {};
+    const tier = card?.exposureTier || (src.repo_url || src.url ? 'public' : null);
+    if (tier && tier !== 'public') continue;
+    if (src.sha256 === sha256 || src.archive_sha256 === sha256) {
+      return { id: card.id || f.replace(/\.json$/, ''), name: card.name || card.id, license: card.license?.spdx || src.license || null, risk: card.contamination?.risk || null };
+    }
+  }
+  return null;
+}
+
+/**
+ * Write (or update) the sidecar next to the data file so `mt-eval run
+ * --corpus <file>` knows what this registration said: its id, licence and
+ * checksum — and, for local-only, that no outside service may see it. The
+ * harness lets a sidecar only TIGHTEN what it does, and this never loosens an
+ * existing one: a file already marked local-only stays local-only.
+ */
+function readSidecar(file) {
+  const sidecar = file + SIDECAR_SUFFIX;
+  if (!fs.existsSync(sidecar)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(sidecar, 'utf-8'));
+  } catch (e) {
+    throw new Error(`${sidecar} exists but is not valid JSON (${e.message}). `
+      + 'Fix or remove it — it states how this corpus may be used.');
+  }
+}
+
+function writeSidecar(file, fields) {
+  const sidecar = file + SIDECAR_SUFFIX;
+  const existing = readSidecar(file);
+  const merged = { ...existing, ...fields };
+  if (existing.transmission === 'local-only') merged.transmission = 'local-only';
+  fs.writeFileSync(sidecar, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+  return { path: sidecar, transmission: merged.transmission || null };
+}
 
 /**
  * Resolve a path to its REAL location, following symlinks. The destination
@@ -91,21 +367,30 @@ function isInteractive() {
   return process.stdin.isTTY === true;
 }
 
-function ask(rl, question, defaultValue) {
+function ask(rl, question, defaultValue, shownDefault = defaultValue) {
   return new Promise((resolve) => {
-    const suffix = defaultValue ? ` (${defaultValue})` : '';
+    // shownDefault: what Enter means, shown in the prompt — the caller may
+    // want to tell Enter apart from a typed value (defaultValue '').
+    const suffix = shownDefault ? ` (${shownDefault})` : '';
     rl.question(`  ${question}${suffix}: `, (answer) => {
       resolve(answer.trim() || defaultValue || '');
     });
   });
 }
 
-/** Parse "src>tgt" / "src-tgt" / "src,tgt" into {source, target}, else null. */
-function parsePair(value) {
-  if (!value) return null;
-  const m = String(value).trim().split(/[>\-,\s]+/).filter(Boolean);
-  if (m.length >= 2) return { source: m[0].toLowerCase(), target: m[1].toLowerCase() };
-  return null;
+/**
+ * Read --pair (any spelling lib/language-pair.js accepts: eng>crk, eng-crk,
+ * eng:crk, …). Codes are lower-cased: they name the card id, which is
+ * lower-case. The old reader split on every - and > and kept the first two
+ * pieces, so "eng>pt-BR" was registered as eng→pt without a word.
+ *
+ * @returns {{pair: {source: string, target: string}|null, pairError: string|null}}
+ */
+function readPair(value) {
+  if (value === undefined || value === null || value === '') return { pair: null, pairError: null };
+  const p = parseLanguagePair(value, { label: '--pair' });
+  if (!p.ok) return { pair: null, pairError: p.error };
+  return { pair: { source: p.source.toLowerCase(), target: p.target.toLowerCase() }, pairError: null };
 }
 
 // ── Catalog printing (plain language for humans, machine-readable for agents) ──
@@ -119,24 +404,29 @@ function printCatalogs(asJson) {
     }, null, 2));
     return;
   }
+  // The id beside each label is what --license / --tier take (Round 8,
+  // school + hospital personas: the list showed numbered labels only).
   console.log('');
-  console.log('  LICENSES — pick the terms others may use your corpus under:');
+  console.log('  LICENSES — pick the terms others may use your corpus under (pass the id to --license):');
   console.log('');
   LICENSE_OPTIONS.forEach((o, i) => {
-    console.log(`    ${i + 1}. ${o.label}`);
+    console.log(`    ${i + 1}. ${o.key.padEnd(24)} ${o.label}`);
     console.log(`       ${o.explanation}`);
     console.log(`       commercial: ${o.commercial} · redistribution: ${o.redistribution} · public-lane: ${o.publicEligible ? 'eligible' : 'blocked'}`);
   });
   console.log('');
-  console.log('  EXPOSURE TIERS — how far your corpus travels (default: most private):');
+  console.log('    --license also takes the list number, or an SPDX id (e.g. --license CC-BY-4.0).');
+  console.log('');
+  console.log('  EXPOSURE TIERS — how far your corpus travels (default: most private; pass the id to --tier):');
   console.log('');
   EXPOSURE_TIERS.forEach((t, i) => {
     const def = t.key === DEFAULT_TIER ? '  ★ default' : '';
-    console.log(`    ${i + 1}. ${t.label}${def}`);
+    console.log(`    ${i + 1}. ${t.key.padEnd(11)} ${t.label}${def}`);
     console.log(`       ${t.explanation}`);
   });
   console.log('');
-  console.log('  Champollion never reads, uploads, or hosts your corpus text — in ANY tier.');
+  console.log('  Champollion never uploads or hosts your corpus text — in ANY tier. With --data, the');
+  console.log('  file is read on this machine only to count and checksum it; none of it leaves.');
   console.log('');
 }
 
@@ -148,18 +438,32 @@ async function runInteractive(rl, args) {
   console.log('  ════════════════════════════════════════════════');
   console.log('');
   console.log('  You choose the license and how far this corpus travels.');
-  console.log('  We never read, upload, or host your text — only metadata,');
-  console.log('  and (for public sets) a pointer to where the data is fetched from.');
+  console.log('  We never upload or host your text — only metadata, and (for public');
+  console.log('  sets) a pointer to where the data is fetched from. A file you name');
+  console.log('  is read on this machine only: --data to count and checksum it, and');
+  console.log('  a sealed set\'s file to encrypt it.');
 
   // Step 1 — basics
   console.log('');
   console.log('  Step 1/4 — Basics');
   console.log('  ────────────────────────────────────────────────');
   const name = await ask(rl, 'Corpus name', args.name || '');
-  const pairStr = await ask(rl, 'Language pair (e.g. eng-crk, or "eng>crk")', args.pair || '');
-  const pair = parsePair(pairStr);
+  // Asked again until it reads as a pair (or is left blank — validation then
+  // says a pair is required): an unreadable pair is said here, not at the end.
+  let pair = null;
+  let pairError = null;
+  for (let pairIn = args.pair || ''; ;) {
+    const pairStr = await ask(rl, 'Language pair, source>target (e.g. eng>crk — eng-crk works too)', pairIn);
+    ({ pair, pairError } = readPair(pairStr));
+    if (!pairError) break;
+    console.log(`  ⚠  ${pairError}`);
+    pairIn = '';
+  }
   const publisher = await ask(rl, 'Publisher / your name or org', args.publisher || '');
   const description = await ask(rl, 'One-line description', args.description || `${name} evaluation corpus`);
+  const role = normalizeRole(await ask(rl,
+    `What is it for — ${CORPUS_ROLES.join(', ')}? (blank: don't say; the id then names no role)`,
+    normalizeRole(args.role) || ''));
 
   // Step 2 — license
   console.log('');
@@ -253,14 +557,17 @@ async function runInteractive(rl, args) {
   console.log('');
   console.log('  Contamination risk — is this text in known LLM training sets?');
   console.log('    NONE = private/unpublished · LOW = niche/recent · MEDIUM = public · HIGH = in major training sets');
-  const riskIn = await ask(rl, 'Contamination risk', defaultRisk);
-  const contaminationRisk = CONTAMINATION_LEVELS.includes(riskIn.toUpperCase()) ? riskIn.toUpperCase() : defaultRisk;
+  // Typed, or the default accepted? A typed grade is a statement; the default
+  // is not, and gives way to UNCHECKED when the file cannot be compared.
+  const riskTyped = (await ask(rl, 'Contamination risk', '', defaultRisk)).toUpperCase();
+  const contaminationStated = CONTAMINATION_LEVELS.includes(riskTyped);
+  const contaminationRisk = contaminationStated ? riskTyped : defaultRisk;
 
   return {
-    name, pair, publisher, description,
+    name, pair, publisher, description, role,
     licenseOption, tier,
     repoUrl, builder, sourceUrl,
-    size: Number(sizeStr), domain, contaminationRisk,
+    size: Number(sizeStr), domain, contaminationRisk, contaminationStated,
     custodianGroupId, thresholdPubkey, sealInput, sealOut,
     qualifierId, qualifierThreshold, keyScheme,
   };
@@ -269,8 +576,10 @@ async function runInteractive(rl, args) {
 // ── Non-interactive (flags) ─────────────────────────────────────────────────
 
 function fromFlags(args) {
-  const pair = parsePair(args.pair) ||
-    (args['source-lang'] && args['target-lang']
+  const read = args.pair !== undefined ? readPair(args.pair) : { pair: null, pairError: null };
+  const pairError = read.pairError;
+  const pair = read.pair ||
+    (!pairError && args['source-lang'] && args['target-lang']
       ? { source: String(args['source-lang']).toLowerCase(), target: String(args['target-lang']).toLowerCase() }
       : null);
   const licenseOption = resolveLicense(args.license);
@@ -279,8 +588,10 @@ function fromFlags(args) {
   return {
     name: args.name || '',
     pair,
-    publisher: args.publisher || (args.name ? '' : ''),
+    pairError,
+    publisher: args.publisher || '',
     description: args.description || (args.name ? `${args.name} evaluation corpus` : ''),
+    role: args.role === true ? true : normalizeRole(args.role), // bare --role: validation says it needs a value
     licenseOption,
     tier,
     repoUrl: args['repo-url'] || null,
@@ -289,6 +600,9 @@ function fromFlags(args) {
     size: args.size != null ? Number(args.size) : NaN,
     domain: args.domain || '',
     contaminationRisk: riskIn && CONTAMINATION_LEVELS.includes(riskIn) ? riskIn : null,
+    // A grade you passed is your statement; it stands even when the file
+    // could not be compared with the public corpora.
+    contaminationStated: !!(riskIn && CONTAMINATION_LEVELS.includes(riskIn)),
     // sealed tier
     custodianGroupId: args['custodian-group'] || null,
     thresholdPubkey: args['threshold-pubkey'] || null,
@@ -421,16 +735,111 @@ async function run(args, cwd) {
     req = fromFlags(args);
   }
 
+  // --data: the local file this registration describes. Hashed and counted
+  // here (never copied or uploaded) so the card carries its checksum and the
+  // harness can find what was registered, through the sidecar written below.
+  let dataFile = null;
+  let dataInfo = null;
+  if (args.data) {
+    dataFile = path.resolve(cwd, String(args.data));
+    if (!fs.existsSync(dataFile) || !fs.statSync(dataFile).isFile()) {
+      console.error(`[ERR] --data: no such file: ${dataFile}`);
+      return 1;
+    }
+    if (req.tier && (req.tier.key === 'public' || req.tier.key === 'sealed')) {
+      console.error(`[ERR] --data is for local-only and private corpora. A ${req.tier.key} corpus is `
+        + (req.tier.key === 'public' ? 'fetched from its source (--repo-url / --builder).'
+          : 'encrypted from --seal-input.'));
+      return 1;
+    }
+    try {
+      dataInfo = describeDataFile(dataFile);
+    } catch (e) {
+      console.error(`[ERR] --data: could not read ${dataFile}: ${e.message}`);
+      return 1;
+    }
+    if (!Number.isFinite(req.size) || req.size <= 0) req.size = dataInfo.rows;
+  }
+
+  // A private / local-only / sealed registration of text that is public: never
+  // graded "Contamination: NONE". Compared with the corpora cards this CLI can
+  // see (a repo checkout), else — an npm install ships none — with the public
+  // corpus catalogue (lib/public-catalogue.js; only the public ids and
+  // checksums are downloaded, the file's own sha256 stays here). When neither
+  // can be read, the comparison was not made, and the grade says so
+  // (UNCHECKED) unless you state one with --contamination (Round 9,
+  // researcher persona: an npm install graded a byte-identical copy of a
+  // public benchmark NONE because it had nothing to compare with).
+  {
+    const cardsDir = args['cards-dir'] ? path.resolve(cwd, args['cards-dir']) : DEFAULT_CARDS_DIR;
+    const checked = [];
+    if (dataInfo) checked.push({ flag: '--data', file: dataFile, sha256: dataInfo.sha256 });
+    if (req.tier && req.tier.key === 'sealed' && req.sealInput) {
+      try {
+        const plain = path.resolve(cwd, String(req.sealInput));
+        checked.push({ flag: '--seal-input', file: plain, sha256: crypto.createHash('sha256').update(fs.readFileSync(plain)).digest('hex') });
+      } catch { /* the sealing step names an unreadable file */ }
+    }
+    if (checked.length > 0 && req.tier && req.tier.key !== 'public') {
+      let lookup;
+      if (fs.existsSync(cardsDir)) {
+        lookup = { ok: true, where: 'the corpora cards', find: (sha) => findPublicCopy(sha, cardsDir) };
+      } else {
+        const cat = await findPublicCorporaBySha(checked.map(c => c.sha256));
+        lookup = cat.ok
+          ? { ok: true, where: `the public corpus catalogue (${cat.compared} checksums)`, find: (sha) => (cat.hits.has(sha) ? { ...cat.hits.get(sha), risk: null } : null) }
+          : { ok: false, why: `this install ships no corpora cards, and ${cat.why}` };
+      }
+      if (!lookup.ok) {
+        // Not compared. NONE claims text no model has seen — it is never the
+        // default for a comparison that was not made.
+        const shown = checked.map(c => path.relative(cwd, c.file) || c.file).join(', ');
+        req.contaminationNote = `not compared with the public corpora — ${lookup.why}`;
+        if (req.contaminationStated) {
+          req.contaminationReasoning = `Stated at registration (${req.contaminationRisk}); ${shown} was not compared with the public corpora (${lookup.why}).`;
+        } else {
+          req.contaminationRisk = CONTAMINATION_UNCHECKED;
+          req.contaminationReasoning = `Not graded: ${shown} could not be compared with the public corpora at registration (${lookup.why}). `
+            + 'Re-register online to compare it, or state a grade with --contamination none|low|medium|high.';
+        }
+      } else {
+        req.contaminationCompared = lookup.where;
+        for (const c of checked) {
+          const hit = lookup.find(c.sha256);
+          if (!hit) continue;
+          const shown = path.relative(cwd, c.file) || c.file;
+          const why = `${shown} is a byte-identical copy of the public corpus ${hit.id} (${hit.name}${hit.license ? `, ${hit.license}` : ''}; same sha256 ${c.sha256.slice(0, 12)}…, found in ${lookup.where}).`;
+          if (req.tier.key === 'sealed') {
+            console.error(`[ERR] ${why}`);
+            console.error('      A sealed test set is text no model has seen; this text is public, so sealing it tests nothing.');
+            console.error(`      Register it as public instead (--tier public, fetched from its source — ${hit.id} already is), or seal sentences that are genuinely private.`);
+            return 1;
+          }
+          if (!req.contaminationRisk || req.contaminationRisk === 'NONE') {
+            console.error(`[ERR] ${why}`);
+            console.error(`      A ${req.tier.key} card would say "Contamination: NONE" (text no model has seen); this text is public${hit.risk ? ` — the public card rates it ${hit.risk}` : ''}.`);
+            console.error(`      Register it as public (--tier public — ${hit.id} already describes it), use sentences that are genuinely private,`);
+            console.error(`      or keep it ${req.tier.key} and state its exposure: --contamination ${hit.risk && hit.risk !== 'NONE' ? hit.risk : 'MEDIUM'}.`);
+            return 1;
+          }
+          req.contaminationReasoning = `${why} Registered ${req.tier.key} with the stated risk ${req.contaminationRisk}; the text itself is public.`;
+        }
+      }
+    }
+  }
+
   // Validate (collects every problem, fails loud).
   const v = validateRegistration({
     tier: req.tier,
     licenseOption: req.licenseOption,
     pair: req.pair || {},
+    pairError: req.pairError || null,
     name: req.name,
     repoUrl: req.repoUrl,
     builder: req.builder,
     size: req.size,
     domain: req.domain,
+    role: req.role,
     custodianGroupId: req.custodianGroupId,
     thresholdPublicKey: req.thresholdPubkey,
     sealInput: req.sealInput,
@@ -440,17 +849,58 @@ async function run(args, cwd) {
     console.error('[ERR] Cannot register this corpus:');
     for (const e of v.errors) console.error(`      • ${e}`);
     console.error('');
-    console.error('      Run "champollion register-corpus --list" to see licenses + tiers,');
-    console.error('      or "champollion register-corpus --help" for all flags.');
+    console.error('      Run "champollion network register-corpus --list" to see licenses + tiers,');
+    console.error('      or "champollion network register-corpus --help" for all flags.');
     return 1;
   }
 
   // Build the (content-free) card.
+  // The id: a full --id (eval-…/ref-…) is used exactly as given; otherwise it
+  // is derived from --name (publisher only as a fallback), with a role segment
+  // only when --role states one. See deriveCardId.
   const version = args.version || '1';
-  const slug = slugify(args.id || req.publisher || req.name || 'custom');
-  const id = args.id && /^(ref|eval)-/.test(args.id)
-    ? args.id
-    : deriveCardId({ source: req.pair.source, target: req.pair.target, slug, version });
+  let id;
+  if (args.id && /^(ref|eval)-/.test(args.id)) {
+    id = String(args.id);
+    if (!CARD_ID_PATTERN.test(id)) {
+      console.error(`[ERR] --id '${id}' is not a valid card id: after eval- or ref-, use only`);
+      console.error('      lower-case letters, digits and hyphens (it is also the card filename).');
+      return 1;
+    }
+    if (req.role && !new RegExp(`-${req.role}(-|$)`).test(id)) {
+      console.error(`[ERR] --role ${req.role} shapes a generated id, but --id is used exactly as given`);
+      console.error(`      and '${id}' does not name that role. Put the role in --id, or drop --role.`);
+      return 1;
+    }
+  } else {
+    const slug = (args.id && slugify(args.id)) || deriveIdSlug({ name: req.name, publisher: req.publisher });
+    id = deriveCardId({ source: req.pair.source, target: req.pair.target, slug, role: req.role, version });
+  }
+
+  // A data file that is already registered keeps its id. Its sidecar records
+  // the id it was registered under; deriving a fresh one on a re-run would
+  // silently relink the file to a second card. Ids are never re-derived.
+  // A file already marked local-only stays local-only (writeSidecar never
+  // loosens a mark), and its card says so too.
+  let priorTransmission = null;
+  if (dataFile) {
+    let priorSidecar;
+    try {
+      priorSidecar = readSidecar(dataFile);
+    } catch (e) {
+      console.error(`[ERR] ${e.message}`);
+      return 1;
+    }
+    if (priorSidecar.transmission === 'local-only') priorTransmission = 'local-only';
+    if (priorSidecar.id && priorSidecar.id !== id && !args.id) {
+      const shown = path.relative(cwd, dataFile) || dataFile;
+      console.error(`[ERR] ${shown} is already registered as ${priorSidecar.id}`);
+      console.error(`      (recorded in ${path.basename(dataFile)}${SIDECAR_SUFFIX}). A registered id is never re-derived.`);
+      console.error(`      To keep it, add:                       --id ${priorSidecar.id}`);
+      console.error(`      To register the file under a new id:   --id ${id}`);
+      return 1;
+    }
+  }
 
   const addedAt = new Date().toISOString().slice(0, 10);
 
@@ -487,17 +937,28 @@ async function run(args, cwd) {
     licenseOption: req.licenseOption,
     tier: req.tier,
     contaminationRisk: req.contaminationRisk,
+    ...(req.contaminationReasoning && { contaminationReasoning: req.contaminationReasoning }),
+    role: req.role || null,
+    dataRead: !!dataInfo,
     size: req.size,
     domain: req.domain,
     doNotTrain: args['do-not-train'] !== false,
+    transmission: priorTransmission,
     addedAt,
     sealed: sealedBlock,
   });
 
   // Resolve destination — local-only NEVER lands in the tracked SSOT.
   const corporaCardsDir = args['cards-dir'] ? path.resolve(cwd, args['cards-dir']) : DEFAULT_CARDS_DIR;
-  const localDir = args.out ? path.resolve(cwd, args.out) : cwd;
-  const dest = resolveDestination({ tier: req.tier, id, corporaCardsDir, localDir });
+  const localDir = args.out ? path.resolve(cwd, args.out) : (dataFile ? path.dirname(dataFile) : cwd);
+  // An npm install ships no corpora-cards directory (it is the monorepo's
+  // tracked SSOT). Writing a "registered" card into node_modules put it where
+  // nothing reads it and the next reinstall deletes it. From an install, the
+  // card stays with you, and listing it is a review-gated submission.
+  const installMode = !args['cards-dir'] && !fs.existsSync(DEFAULT_CARDS_DIR);
+  const dest = installMode && req.tier.key !== 'local-only'
+    ? { registered: false, tracked: false, dir: localDir, filename: `${id}.json` }
+    : resolveDestination({ tier: req.tier, id, corporaCardsDir, localDir });
 
   // Guard: a local-only card must never land in the tracked corpora-cards SSOT.
   // path.resolve does NOT follow symlinks and only the exact dir was checked —
@@ -522,11 +983,32 @@ async function run(args, cwd) {
   fs.mkdirSync(dest.dir, { recursive: true });
   fs.writeFileSync(filePath, JSON.stringify(card, null, 2) + '\n', 'utf-8');
 
+  let sidecar = null;
+  if (dataFile) {
+    try {
+      sidecar = writeSidecar(dataFile, {
+        id,
+        name: req.name,
+        license: card.license.spdx,
+        tier: req.tier.key,
+        sha256: dataInfo.sha256,
+        rows: dataInfo.rows,
+        card: path.relative(path.dirname(dataFile), filePath) || path.basename(filePath),
+        registeredAt: addedAt,
+        ...(req.tier.key === 'local-only' ? { transmission: 'local-only' } : {}),
+      });
+    } catch (e) {
+      console.error(`[ERR] ${e.message}`);
+      return 1;
+    }
+  }
+
   // ── Report ──
   if (args.json) {
     console.log(JSON.stringify({
       ok: true,
       id,
+      role: req.role || null,
       exposureTier: req.tier.key,
       registered: dest.registered,
       tracked: dest.tracked,
@@ -542,7 +1024,24 @@ async function run(args, cwd) {
         qualifierThreshold: sealedBlock.qualifierThreshold,
       } : {}),
       license: card.license,
+      contamination: {
+        risk: card.contamination.risk,
+        // Where the file was compared with the public corpora (null: it could not be).
+        comparedWith: req.contaminationCompared || null,
+        ...(req.contaminationNote && { note: req.contaminationNote }),
+      },
       path: filePath,
+      ...(sidecar ? {
+        data: dataFile,
+        dataSha256: dataInfo.sha256,
+        rows: dataInfo.rows,
+        sidecar: sidecar.path,
+        transmission: sidecar.transmission,
+      } : {}),
+      ...(installMode && req.tier.key !== 'local-only' ? {
+        listed: false,
+        toList: 'champollion network submit --type dataset',
+      } : {}),
     }, null, 2));
     return 0;
   }
@@ -551,12 +1050,50 @@ async function run(args, cwd) {
   output.ok(`${req.tier.key === 'local-only' ? 'Saved' : 'Registered'} corpus card: ${id}`);
   console.log('');
   console.log(`    Exposure:     ${req.tier.label}`);
-  console.log(`    License:      ${card.license.spdx}  (commercial: ${card.license.commercial}, redistribution: ${card.license.redistribution})`);
-  console.log(`    Pair:         ${req.pair.source}→${req.pair.target}`);
-  console.log(`    Size/domain:  ${req.size} ${card.dev.sizeUnit} · ${card.dev.domain}`);
-  console.log(`    Contamination: ${card.contamination.risk}`);
+  console.log(`    Role:         ${req.role || 'not stated (add --role test|dev|train to say what it is for)'}`);
+  // Each term once, as the card states it (Round 14, researcher persona:
+  // the card and this summary disagreed). The licence's terms; training
+  // (doNotTrain); the transmission mark — a separate field, not a licence term.
+  const yesNo = (b) => (b ? 'yes' : 'no');
+  const custom = card.license.notes ? ' (custom/unconfirmed — verify its terms)' : '';
+  const redistributed = { permitted: 'yes', 'same-terms': 'yes, under the same terms', prohibited: 'no' }[card.usageRestrictions.redistribution];
+  console.log(`    License:      ${card.license.spdx}${custom} — commercial use ${yesNo(card.license.commercial)}, redistribution ${redistributed}`);
+  console.log(`    Training:     ${card.doNotTrain
+    ? `not permitted — doNotTrain: true (${card.usageRestrictions.training === 'prohibited-by-license' ? 'the licence refuses training' : 'set at registration: a test set is not trained on'})`
+    : 'permitted — doNotTrain: false'}`);
+  if (card.transmission === 'local-only') {
+    console.log('    Transmission: local-only — only a model on this machine may see it (a mark, not a licence term)');
+  }
+  console.log(`    Pair:         ${formatLanguagePair(req.pair)}`);
+  const splitBlock = card.test || card.dev;
+  console.log(`    Size/domain:  ${req.size} ${splitBlock.sizeUnit} · ${splitBlock.domain}${card.test ? ' (test split)' : ''}`);
+  let contaminationAside = '';
+  if (card.contamination.risk === CONTAMINATION_UNCHECKED) {
+    contaminationAside = `  (${req.contaminationNote}. Not graded NONE: that would claim the text is unpublished. `
+      + 'Re-run online to compare it, or state a grade: --contamination none|low|medium|high)';
+  } else if (req.contaminationNote) {
+    contaminationAside = `  (${req.contaminationNote} — the grade is your statement)`;
+  } else if (req.contaminationCompared && !req.contaminationReasoning) {
+    contaminationAside = `  (compared with ${req.contaminationCompared}: no public copy of this file — the grade is your statement)`;
+  }
+  console.log(`    Contamination: ${card.contamination.risk}${contaminationAside}`);
   console.log(`    Written to:   ${filePath}`);
+  if (sidecar) {
+    console.log(`    Data file:    ${dataFile}  (${dataInfo.rows} rows, sha256 ${dataInfo.sha256.slice(0, 12)}…)`);
+    console.log(`    Sidecar:      ${sidecar.path}`
+      + (sidecar.transmission === 'local-only' ? '  (carries the local-only mark the tools read)' : ''));
+  }
   console.log('');
+  const runTarget = dataFile ? shellQuote(path.relative(cwd, dataFile) || dataFile) : '<your file>';
+  const lang = languageFlags(req.pair, cwd);
+  const unnamedNote = lang.unnamed.length > 0
+    ? `    (${lang.unnamed.join(', ')} has no language card: replace the code after --${lang.unnamed.includes(req.pair.target) ? 'target' : 'source'}-lang with the language's name — it is what the model is told — or give it a "name" in champollion.config.json)`
+    : null;
+  // A set a model may be trained against: the nmt-forge steps come before
+  // the baseline, which is a scoring read (see forgeFirstLines).
+  const forgeFirst = mayBeTrainedAgainst(req)
+    ? forgeFirstLines({ pair: req.pair, dataFile, sha256: dataInfo ? dataInfo.sha256 : null, cardId: id, cwd, lang })
+    : null;
 
   if (req.tier.key === 'sealed') {
     console.log(`    Sealed artifact: ${sealedArtifactPath}`);
@@ -574,16 +1111,56 @@ async function run(args, cwd) {
     console.log('  A method must first clear the paired PUBLIC qualifier before any sealed run');
     console.log('  can even be proposed — and that run still requires custodian approval.');
   } else if (req.tier.key === 'local-only') {
-    console.log('  This card stays on your machine. Nothing was registered or uploaded,');
-    console.log('  and your corpus text was never read. Delete the file to remove it.');
+    console.log('  This card stays on your machine. Nothing was registered or uploaded.');
+    if (dataFile) {
+      console.log('  Your text was read only to count and checksum it. Only a model on this');
+      console.log('  machine can be tested against it; every remote provider is refused.');
+      console.log('');
+      if (forgeFirst && !forgeFirst.done) {
+        for (const line of forgeFirst.lines) console.log(line);
+        console.log('');
+        console.log('  Then measure a local model on it (the baseline) — or now, if no model will');
+        console.log('  be trained against this set:');
+      } else {
+        if (forgeFirst) { for (const line of forgeFirst.lines) console.log(line); console.log(''); }
+        console.log('  Next: measure a local model on it:');
+      }
+      const model = localModelFor(cwd);
+      console.log(`    mt-eval run --corpus ${runTarget} --provider local --model ${model ? shellQuote(model) : '<model>'} ${lang.flags}`);
+      if (!model) console.log('    (<model>: the name your local server serves, e.g. llama3.1)');
+      if (unnamedNote) console.log(unnamedNote);
+    } else {
+      console.log('  Your corpus text was never read. To protect the file itself, re-run with');
+      console.log('  --data <file>: that marks it local-only for mt-eval.');
+    }
   } else if (req.tier.key === 'private') {
-    console.log('  Metadata only is registered — your corpus TEXT was never read, uploaded,');
-    console.log('  or hosted, and never will be. The set is catalogued but quarantined from');
-    console.log('  the public queue/leaderboard (custodian-controlled, WMT-style held-out).');
+    console.log('  Metadata only — your corpus TEXT was never uploaded or hosted, and never');
+    console.log('  will be. A private set is quarantined from the public queue/leaderboard.');
+    if (dataFile) console.log('  Your text was read on this machine only to count and checksum it.');
     console.log('');
-    console.log('  Next: rebuild the registry, then evaluate privately:');
-    for (const line of REGISTRY_REBUILD_HINT) console.log(line);
-    console.log(`    mt-eval run --corpus ${id} --private  # publish scores without exposing text`);
+    if (installMode) {
+      console.log('  The card is kept here with you. To have it listed in the index (metadata');
+      console.log('  only, review-gated), submit it:  champollion network submit --type dataset');
+    } else {
+      console.log('  Rebuild the registry so the card is catalogued:');
+      for (const line of REGISTRY_REBUILD_HINT) console.log(line);
+    }
+    console.log('');
+    if (forgeFirst && !forgeFirst.done) {
+      for (const line of forgeFirst.lines) console.log(line);
+      console.log('');
+      console.log('  Then evaluate on it (the baseline) — or now, if no model will be trained');
+      console.log('  against this set — and publish the scores without the text if you choose:');
+    } else {
+      if (forgeFirst) { for (const line of forgeFirst.lines) console.log(line); console.log(''); }
+      console.log('  Evaluate on it, then publish the scores without the text if you choose:');
+    }
+    console.log(`    mt-eval run --corpus ${runTarget} --provider <provider> --model <model> ${lang.flags} -o results`);
+    if (unnamedNote) console.log(unnamedNote);
+    console.log('    mt-eval publish results/<run-id>_report.json --scores-only --dry-run');
+  } else if (installMode) {
+    console.log('  The card is kept here with you. A public corpus is listed through review:');
+    console.log('    champollion network submit --type dataset');
   } else {
     console.log('  A metadata card + fetch-from-source pointer is registered — your corpus');
     console.log('  TEXT is never hosted by Champollion; it is fetched from source on demand.');
@@ -595,84 +1172,14 @@ async function run(args, cwd) {
   return 0;
 }
 
+/**
+ * `--help` for this command. The text lives in lib/command-help.js — the one
+ * `champollion network register-corpus --help` prints. This module kept a
+ * second copy, and the two drifted: Round 9 corrected what the file reads in
+ * one, while the other still said "never reads" (Round 10, school persona).
+ */
 function showHelp() {
-  console.log(`
-  champollion register-corpus — Register a new evaluation corpus
-
-  USAGE
-    champollion register-corpus [options]
-
-  DESCRIPTION
-    Register a corpus with YOU in control of its license and how far it
-    travels. Three exposure tiers, defaulting to the most private. We never
-    read, upload, or host your corpus text in ANY tier — only metadata (and,
-    for public sets, a pointer to where the data is fetched from).
-
-    Interactive when run in a terminal; fully scriptable with flags (or --yes).
-
-  EXPOSURE TIERS  (--tier, default: local-only)
-    local-only   Never registered, never uploaded; card + text stay on your machine.
-    private      Register METADATA ONLY — a WMT-style sovereign held-out set;
-                 text never uploaded or hosted; you keep custody.
-    public       Publish a metadata card + fetch-from-source pointer; text never
-                 hosted by us. Requires a redistribution-cleared license (gated).
-    sealed       Encrypt the corpus ON YOUR DEVICE to the custodian group's
-                 key; the ciphertext stays with you and we receive only a
-                 content-free card. Catalogued + quarantined; paired with a
-                 public qualifier a method must clear before any sealed run.
-
-  LICENSES  (--license)
-    cc-by-4.0, cc-by-sa-4.0, cc0-1.0, cc-by-nc-4.0, proprietary, other
-    (or pass any SPDX id; it is classified through the license gate)
-
-  OPTIONS
-    --tier <tier>         Exposure tier (default: local-only). Alias: --exposure
-    --license <id>        License key, SPDX id, or list number (see --list)
-    --name <text>         Corpus name (required)
-    --pair <pair>         Language pair: "eng>crk" (quote it — the shell eats a
-                          bare >) or the dash form eng-crk (or --source-lang/--target-lang)
-    --publisher <text>    Publisher / your name or org
-    --description <text>  One-line description
-    --size <n>            Number of sentence pairs (required)
-    --domain <text>       Domain: news, conversational, educational, … (required)
-    --contamination <lvl> NONE | LOW | MEDIUM | HIGH (default: NONE private / LOW public)
-    --repo-url <url>      Public tier: fetch-from-source archive/repo URL
-    --source-url <url>    Public tier: canonical project/dataset URL
-    --builder <id>        Public tier: builder adapter id (rebuilds from source)
-    --seal-input <path>   Sealed tier: local corpus file to encrypt on-device
-    --threshold-pubkey <k> Sealed tier: custodian group threshold public key
-                          (file path, or inline PEM / base64 DER SPKI, X25519)
-    --custodian-group <id> Sealed tier: custodian group id that holds the key
-    --seal-out <path>     Sealed tier: where to write the ciphertext artifact
-    --qualifier-id <id>   Sealed tier: paired public qualifier card id (vYYYY)
-    --qualifier-threshold <n> Sealed tier: score a method must clear on the qualifier
-    --key-scheme <s>      Sealed tier: custody scheme label (default: TSS-3-of-5)
-    --id <id>             Override the generated card id (eval-…)
-    --out <dir>           local-only: where to write the card (default: cwd)
-    --list                Print the license + tier catalog (add --json for JSON)
-    --json                Machine-readable output (for agents)
-    --yes                 Non-interactive; take values from flags
-
-  EXAMPLES
-    champollion register-corpus                                   # interactive wizard
-    champollion register-corpus --list                           # see licenses + tiers
-    # Keep a corpus entirely local (nothing leaves your machine):
-    champollion register-corpus --yes --name "My set" --pair "eng>crk" \\
-      --license cc-by-4.0 --tier local-only --size 200 --domain news
-    # Register a sovereign held-out test set (metadata only, text never uploaded):
-    champollion register-corpus --yes --name "Community holdout" --pair "eng>crk" \\
-      --license cc-by-nc-4.0 --tier private --size 500 --domain educational
-    # Publish a fetch-from-source pointer (gated to redistributable licenses):
-    champollion register-corpus --yes --name "Tatoeba eng-crk" --pair "eng-crk" \\
-      --license cc-by-4.0 --tier public --size 1000 --domain conversational \\
-      --repo-url https://example.org/data.tar --builder tatoeba-challenge
-    # Seal a community-controlled secret test set (encrypted ON YOUR DEVICE):
-    champollion register-corpus --yes --name "Sealed eng-crk" --pair "eng>crk" \\
-      --license proprietary --tier sealed --size 500 --domain educational \\
-      --seal-input ./secret-corpus.json --threshold-pubkey ./group.pub \\
-      --custodian-group nehiyawewin-trust --seal-out ./sealed.json \\
-      --qualifier-id eval-eng-crk-nehiyaw-qualifier-v2026
-  `);
+  showCommandHelp('register-corpus');
 }
 
 /**