@aikdna/kdna-cli 0.17.0 → 0.19.0

package/src/cli.js

@@ -7,15 +7,7 @@
  */
 
 const { error, EXIT, setQuiet, setExitCodeOnly } = require('./cmds/_common');
-const {
-  cmdValidate,
-  cmdPack,
-  cmdPackEncrypt,
-  cmdUnpack,
-  cmdUnpackEncrypt,
-  cmdInspect,
-  cmdCard,
-} = require('./cmds/domain');
+const { cmdValidate, cmdPack, cmdUnpack, cmdInspect, cmdCard } = require('./cmds/domain');
 const { cmdList, cmdRegistry } = require('./cmds/registry');
 const {
   cmdCompare,
@@ -39,6 +31,9 @@ const {
   cmdLicenseBind,
   cmdLicenseShow,
   cmdLicenseInstall,
+  cmdLicenseStatus,
+  cmdLicenseActivate,
+  cmdLicenseSync,
 } = require('./cmds/license');
 const { cmdPreview, cmdProject, cmdEval, cmdExport, cmdDemo } = require('./cmds/legacy');
 const {
@@ -58,7 +53,8 @@ const {
   cmdEvolution,
   cmdRegression,
 } = require('./cmds/governance');
-const { cmdBadgeCompute, cmdRegistryAudit, cmdPackage } = require('./cmds/badge');
+const { cmdBadgeCompute, cmdRegistryAudit } = require('./cmds/badge');
+const { cmdExplain } = require('./cmds/explain');
 
 // ─── Main ─────────────────────────────────────────────────────────────
 
@@ -80,15 +76,14 @@ Usage: kdna <command> [options]
 
 Domain Authoring:
   init <name>                      Scaffold a new domain from template
-  validate <path>                  Validate domain structure
-  validate --schema <path>         Schema-only validation
-  pack <path>                      Pack into .kdna container
-  pack <path> --encrypt --license <file>   Pack encrypted .kdnae container
-  unpack <file>                    Unpack .kdna container
-  unpack <file> --license <file>   Unpack encrypted .kdnae container
-  inspect <path>                   Inspect domain or .kdna file
-  inspect <path> --locale zh-CN     Inspect with localized governance data
-  card <path> [--locale zh-CN]      Display KDNA Card (governance metadata)
+  dev validate <path>              Validate a dev source directory
+  dev pack <path>                  Build a dev source directory into .kdna
+  dev unpack <file>                Unpack .kdna into a dev source directory
+  dev inspect <path>               Inspect a dev source directory
+  dev card <path>                  Display KDNA Card from a dev source directory
+  inspect <file.kdna>              Inspect a .kdna asset
+  card <file.kdna> [--locale zh-CN] Display KDNA Card from a .kdna asset
+  explain <name>                   Natural language summary: axioms, terms, scenarios
   publish <path>                   Pack + sign + publish
   publish --check <path>           Quality gate check only
   version bump <level> [path]      Bump domain version
@@ -106,18 +101,18 @@ Agent Runtime:
   available [--json]               List installed domains with v2.1 fields
   match "<task>" [--json]          Signal matching — find relevant domains
   select --input "..." [--json]    Selection policy — decide which domains to load
-  load <name> [--as=prompt|json|raw]  Emit domain in agent-ready format
-  load <name> --profile=index|compact|scenario|full  Load profiles (Phase 2)
+  load <name|file.kdna> [--as=prompt|json|raw]  Emit asset in agent-ready format
+  load <name|file.kdna> --profile=index|compact|scenario|full  Load profiles (Phase 2)
   postvalidate <name> --output <file>  Post-generation judgment check
 
 Testing & Verification:
-  verify <name>                    3-layer: structure + trust + judgment
-  verify <name> --i18n               I18N verification: locales, overlays, card completeness
-  verify <name> --governance         Governance verification: risk_level, KDNA_CARD, provenance
-  verify <name> --judgment --run-tests  Judgment validation with eval cases
-  compare <name> --input "..."     With/without KDNA reasoning diff
-  compare <name> --input "..." --report-md     Markdown report format
-  compare <name> --input "..." --report-json   JSON report with scoring
+  verify <name|file.kdna>          3-layer: structure + trust + judgment
+  verify <name|file.kdna> --i18n     I18N verification: locales, overlays, card completeness
+  verify <name|file.kdna> --governance  Governance verification: risk_level, KDNA_CARD, provenance
+  verify <name|file.kdna> --judgment --run-tests  Judgment validation with eval cases
+  compare <name|file.kdna> --input "..."     With/without KDNA reasoning diff
+  compare <name|file.kdna> --input "..." --report-md     Markdown report format
+  compare <name|file.kdna> --input "..." --report-json   JSON report with scoring
   diff <name>@<v1> <name>@<v2>     Judgment-level diff between versions
   test run <name> --input <file>   Record test result against domain
   test import <run> --as-eval      Convert test result to eval card
@@ -148,6 +143,7 @@ Quality & Distribution (Phase 7):
 
 Registry & Distribution:
   install <name>                   Install domain from registry
+  install <file.kdna>              Install a local .kdna asset
   remove <name>                    Uninstall a domain
   update <name>                    Update installed domain
   info <name>                      Show domain metadata and trust status
@@ -172,9 +168,12 @@ Trace & Diagnostics:
 License & Authorization:
   license generate <domain> --to <email>   Generate signed license
   license install <license.json>           Register license for auto-decrypt
+  license activate <domain> --key --server Activate license from entitlement source
+  license sync [domain] [--server]         Refresh entitlement / revocation status
   license verify <license.json>            Verify license signature
   license bind <license.json>              Bind license to this machine
   license show <license.json>              Display license details
+  license status [domain] [--json]         Show installed license activation status
 
 Flags:
   --json                           Structured JSON output (machine-readable)
@@ -190,41 +189,78 @@ Exit Codes:
 const cmd = args[0];
 
 switch (cmd) {
+  case 'dev': {
+    const sub = args[1];
+    if (sub === 'validate') {
+      const schemaFlag = args.includes('--schema');
+      const jsonFlag = args.includes('--json');
+      const target = args.filter((a, i) => i > 1 && a !== '--schema' && a !== '--json')[0];
+      if (!target) error('Usage: kdna dev validate <source-dir>');
+      cmdValidate(target, schemaFlag, jsonFlag);
+      break;
+    }
+    if (sub === 'pack') {
+      let output = null;
+      let target = null;
+      for (let i = 2; i < args.length; i++) {
+        if (args[i] === '--output' || args[i] === '-o') {
+          output = args[i + 1];
+          i++;
+        } else if (args[i].startsWith('-')) {
+          error(`Unknown option for kdna dev pack: ${args[i]}`, EXIT.INPUT_ERROR);
+        } else if (!target) {
+          target = args[i];
+        }
+      }
+      if (!target) error('Usage: kdna dev pack <source-dir>');
+      cmdPack(target, output);
+      break;
+    }
+    if (sub === 'unpack') {
+      const target = args[2];
+      if (!target) error('Usage: kdna dev unpack <file.kdna>');
+      if (!target.endsWith('.kdna')) error('Not a .kdna asset.', EXIT.INPUT_ERROR);
+      cmdUnpack(target, args.includes('--force'));
+      break;
+    }
+    if (sub === 'inspect') {
+      const target = args.filter((a, i) => i > 1 && !a.startsWith('--'))[0];
+      if (!target) error('Usage: kdna dev inspect <source-dir> [--json] [--locale zh-CN]');
+      const localeIdx = args.indexOf('--locale');
+      const locale = localeIdx >= 0 ? args[localeIdx + 1] : null;
+      cmdInspect(target, args.includes('--json'), locale, { allowDirectory: true });
+      break;
+    }
+    if (sub === 'card') {
+      const target = args.filter((a, i) => i > 1 && !a.startsWith('--'))[0];
+      if (!target) error('Usage: kdna dev card <source-dir> [--json] [--locale zh-CN]');
+      const localeIdx = args.indexOf('--locale');
+      const locale = localeIdx >= 0 ? args[localeIdx + 1] : null;
+      cmdCard(target, args.includes('--json'), locale, { allowDirectory: true });
+      break;
+    }
+    error('Usage: kdna dev <validate|pack|unpack|inspect|card> ...', EXIT.INPUT_ERROR);
+    break;
+  }
   case 'validate': {
-    const schemaFlag = args.includes('--schema');
-    const jsonFlag = args.includes('--json');
-    const target = args.filter((a, i) => i > 0 && a !== '--schema' && a !== '--json')[0];
-    if (!target) error('Usage: kdna validate <path>');
-    cmdValidate(target, schemaFlag, jsonFlag);
+    error(
+      'Directory validation is a dev-only operation. Use: kdna dev validate <source-dir>',
+      EXIT.INPUT_ERROR,
+    );
     break;
   }
   case 'pack': {
-    let output = null;
-    let target = null;
-    for (let i = 1; i < args.length; i++) {
-      if (args[i] === '--output' || args[i] === '-o') {
-        output = args[i + 1];
-        i++;
-      } else if (!target) {
-        target = args[i];
-      }
-    }
-    if (!target) error('Usage: kdna pack <path>');
-    if (args.includes('--encrypt')) {
-      cmdPackEncrypt(target, args);
-    } else {
-      cmdPack(target, output);
-    }
+    error(
+      'Directory packaging is a dev-only operation. Use: kdna dev pack <source-dir>',
+      EXIT.INPUT_ERROR,
+    );
     break;
   }
   case 'unpack': {
-    const target = args[1];
-    if (!target) error('Usage: kdna unpack <file.kdna|file.kdnae>');
-    if (target.endsWith('.kdnae')) {
-      cmdUnpackEncrypt(target, args);
-    } else {
-      cmdUnpack(target, args.includes('--force'));
-    }
+    error(
+      'Unpacking exposes internal files and is dev-only. Use: kdna dev unpack <file.kdna>',
+      EXIT.INPUT_ERROR,
+    );
     break;
   }
   case 'preview': {
@@ -242,7 +278,7 @@ switch (cmd) {
         domainId = args[i];
       }
     }
-    if (!domainId) error('Usage: kdna install <domain-id|github:user/repo|./folder>');
+    if (!domainId) error('Usage: kdna install <domain-id|file.kdna>');
 
     const { cmdInstallExtended } = require('./install');
     if (fromGit) {
@@ -285,7 +321,7 @@ switch (cmd) {
   }
   case 'inspect': {
     const target = args.filter((a) => !a.startsWith('--'))[1];
-    if (!target) error('Usage: kdna inspect <path> [--json] [--locale zh-CN]');
+    if (!target) error('Usage: kdna inspect <file.kdna> [--json] [--locale zh-CN]');
     const localeIdx = args.indexOf('--locale');
     const locale = localeIdx >= 0 ? args[localeIdx + 1] : null;
     cmdInspect(target, args.includes('--json'), locale);
@@ -293,7 +329,7 @@ switch (cmd) {
   }
   case 'card': {
     const target = args.filter((a) => !a.startsWith('--'))[1];
-    if (!target) error('Usage: kdna card <path> [--json] [--locale zh-CN]');
+    if (!target) error('Usage: kdna card <file.kdna> [--json] [--locale zh-CN]');
     const localeIdx = args.indexOf('--locale');
     const locale = localeIdx >= 0 ? args[localeIdx + 1] : null;
     cmdCard(target, args.includes('--json'), locale);
@@ -305,10 +341,10 @@ switch (cmd) {
     if (!target) {
       error(
         'Usage:\n' +
-          '  kdna verify <name>             Run all three layers (structure / trust / judgment)\n' +
-          '  kdna verify <name> --structure  Files + schema only\n' +
-          '  kdna verify <name> --trust      Signature + scope + Ed25519 only\n' +
-          '  kdna verify <name> --judgment   v2.1 governance fields + eval cases only',
+          '  kdna verify <name|file.kdna>             Run all three layers (structure / trust / judgment)\n' +
+          '  kdna verify <name|file.kdna> --structure  Files + schema only\n' +
+          '  kdna verify <name|file.kdna> --trust      Signature + scope + Ed25519 only\n' +
+          '  kdna verify <name|file.kdna> --judgment   v2.1 governance fields + eval cases only',
       );
     }
     cmdVerify(target, args);
@@ -430,9 +466,10 @@ switch (cmd) {
     break;
   }
   case 'package': {
-    const target = args.filter((a) => !a.startsWith('--'))[1];
-    if (!target) error('Usage: kdna package <domain> --format=kdna');
-    cmdPackage(target, args);
+    error(
+      'Directory packaging is a dev-only operation. Use: kdna dev pack <source-dir>',
+      EXIT.INPUT_ERROR,
+    );
     break;
   }
   // Legacy (removed) commands
@@ -452,6 +489,10 @@ switch (cmd) {
     cmdDemo();
     break;
   }
+  case 'explain': {
+    cmdExplain(args);
+    break;
+  }
   case 'list': {
     const localeIdx = args.indexOf('--locale');
     const locale = localeIdx >= 0 ? args[localeIdx + 1] : null;
@@ -491,14 +532,23 @@ switch (cmd) {
       cmdLicenseShow(rest);
     } else if (sub === 'install') {
       cmdLicenseInstall(rest);
+    } else if (sub === 'status') {
+      cmdLicenseStatus(rest);
+    } else if (sub === 'activate') {
+      cmdLicenseActivate(rest).catch((e) => error(e.message, EXIT.TRUST_FAILED));
+    } else if (sub === 'sync') {
+      cmdLicenseSync(rest).catch((e) => error(e.message, EXIT.TRUST_FAILED));
     } else {
       error(
         'Usage:\n' +
           '  kdna license generate <domain> --to <email> [--expires <date>]\n' +
           '  kdna license install <license.json>\n' +
+          '  kdna license activate <domain> --key <license-key> --server <url>\n' +
+          '  kdna license sync [domain] [--server <url>]\n' +
           '  kdna license verify <license.json>\n' +
           '  kdna license bind <license.json>\n' +
-          '  kdna license show <license.json>',
+          '  kdna license show <license.json>\n' +
+          '  kdna license status [domain] [--json]',
         EXIT.INPUT_ERROR,
       );
     }

package/src/cmds/_common.js

@@ -1,9 +1,6 @@
 const fs = require('fs');
-const path = require('path');
 const { loadRegistry: loadCanonicalRegistry } = require('../registry');
-
-const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
-const INSTALL_DIR = path.join(USER_KDNA_DIR, 'domains');
+const { USER_KDNA_DIR, INSTALL_DIR } = require('../paths');
 
 // ─── Global flags ──────────────────────────────────────────────────────
 
@@ -22,7 +19,9 @@ function setQuiet(val) {
   }
 }
 
-function isQuiet() { return _quiet; }
+function isQuiet() {
+  return _quiet;
+}
 
 function setExitCodeOnly(val) {
   _exitCodeOnly = val;
@@ -37,7 +36,9 @@ function setExitCodeOnly(val) {
   }
 }
 
-function isExitCodeOnly() { return _exitCodeOnly; }
+function isExitCodeOnly() {
+  return _exitCodeOnly;
+}
 
 function log(...args) {
   if (!_quiet && !_exitCodeOnly) _originalLog(...args);
@@ -54,14 +55,13 @@ Usage:
 
   --- Domain authors ---
   kdna init <name>              Scaffold a new KDNA domain from template
-  kdna validate <path>          Validate a domain directory
-  kdna validate --schema <path>   ...with JSON Schema
-  kdna pack <path>              Pack a domain folder into a .kdna container
-  kdna pack <path> --encrypt --license <file>   Pack encrypted .kdnae container
-  kdna pack --output <dir> <path>   Output .kdna to specific directory
-  kdna unpack <path>            Unpack a .kdna or .kdnae container to a folder
-  kdna inspect <path>           Inspect a domain directory or .kdna file
-  kdna publish <path>           Pack + sign + output registry patch
+  kdna dev validate <path>      Validate a dev source directory
+  kdna dev pack <path>          Build a dev source directory into .kdna
+  kdna dev unpack <path>        Unpack .kdna into a dev source directory
+  kdna dev inspect <path>       Inspect a dev source directory
+  kdna dev card <path>          Display KDNA Card from a dev source directory
+  kdna inspect <file.kdna>      Inspect a .kdna asset
+  kdna publish <path>           Pack + sign a dev source directory
   kdna publish <path> --release-tag <tag> --repo <o/r>   ...also upload to GitHub
   kdna publish --check <path>   Run quality gate only (no pack/upload)
   kdna version bump <patch|minor|major> [path]   Bump domain version
@@ -72,7 +72,6 @@ Usage:
   kdna install @scope/name      Install any scoped domain
   kdna install @aikdna/animation    Install a cluster (installs all sub-domains)
   kdna install ./file.kdna      Install from a local .kdna file
-  kdna install ./folder         Install from a local directory (dev)
   kdna remove <name>            Uninstall a domain
   kdna update <name>            Update an installed domain
   kdna update --all             Update all installed domains
@@ -83,14 +82,14 @@ Usage:
   kdna registry refresh         Refresh the canonical registry cache
 
   --- Quality + judgment ---
-  kdna verify <name>            Quality check: structure + trust + judgment
-  kdna compare <name> --input "<text>"   With/without KDNA reasoning diff
+  kdna verify <name|file.kdna>  Quality check: structure + trust + judgment
+  kdna compare <name|file.kdna> --input "<text>"   With/without KDNA reasoning diff
   kdna diff <name>@<v1> <name>@<v2>      Judgment-level diff between versions
 
   --- Agent-facing (called by the kdna-loader skill) ---
   kdna available [--json]                List installed domains + v2.1 fields
   kdna match "<task>" [--json]           Hint signals (dropped + weak overlap)
-  kdna load <name> [--as=prompt|json|raw]   Emit domain in agent-ready format
+  kdna load <name|file.kdna> [--as=prompt|json|raw]   Emit asset in agent-ready format
 
   --- Identity ---
   kdna identity init            Generate Ed25519 identity key pair
@@ -144,6 +143,27 @@ function writeJson(file, data) {
   fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
 }
 
+function selfCheckText(item) {
+  if (typeof item === 'string') return item;
+  if (item && typeof item === 'object' && typeof item.question === 'string') return item.question;
+  return '';
+}
+
+function isYesNoSelfCheck(item) {
+  const raw = selfCheckText(item).trim();
+  if (!raw) return false;
+  const lower = raw.toLowerCase();
+  return (
+    lower.endsWith('?') ||
+    raw.endsWith('？') ||
+    raw.endsWith('吗') ||
+    raw.includes('是否') ||
+    /^(have|has|can|does|do|is|are|did|was|were|should|will|would|could|might|can not|cannot|能不能|会不会|有没有|要不要|是不是)/.test(
+      lower,
+    )
+  );
+}
+
 function loadRegistry() {
   return loadCanonicalRegistry({ allowNetwork: true });
 }
@@ -162,5 +182,7 @@ module.exports = {
   isExitCodeOnly,
   readJson,
   writeJson,
+  selfCheckText,
+  isYesNoSelfCheck,
   loadRegistry,
 };

package/src/cmds/badge.js

@@ -3,7 +3,7 @@
  *
  *   kdna badge compute <domain> [--json]
  *   kdna registry audit --scope <scope> [--json]
- *   kdna package <domain> --format=kdna
+ *   kdna dev pack <domain>
  */
 
 const fs = require('fs');
@@ -142,9 +142,9 @@ function cmdRegistryAudit(args = []) {
       status: d.status || 'experimental',
       yanked: d.yanked || false,
       deprecated: d.deprecated || false,
-      has_kdna_url: !!d.kdna_url,
+      has_asset_url: !!d.asset_url,
       has_signature: !!d.signature,
-      has_sha256: !!d.sha256,
+      has_asset_digest: !!d.asset_digest,
     })),
     issues: [],
   };
@@ -152,12 +152,13 @@ function cmdRegistryAudit(args = []) {
   // Detect issues
   const yanked = scopeDomains.filter((d) => d.yanked);
   const deprecated = scopeDomains.filter((d) => d.deprecated);
-  const noPackage = scopeDomains.filter((d) => !d.kdna_url);
+  const noPackage = scopeDomains.filter((d) => !d.asset_url);
   const noSignature = scopeDomains.filter((d) => !d.signature);
 
   if (yanked.length) audit.issues.push(`${yanked.length} yanked domain(s)`);
   if (deprecated.length) audit.issues.push(`${deprecated.length} deprecated domain(s)`);
-  if (noPackage.length) audit.issues.push(`${noPackage.length} domain(s) without .kdna package`);
+  if (noPackage.length)
+    audit.issues.push(`${noPackage.length} domain(s) without .kdna dev package`);
   if (noSignature.length) audit.issues.push(`${noSignature.length} domain(s) without signature`);
 
   audit.healthy = audit.issues.length === 0;
@@ -183,8 +184,10 @@ function cmdRegistryAudit(args = []) {
     const flags = [];
     if (d.yanked) flags.push('yanked');
     if (d.deprecated) flags.push('deprecated');
-    if (!d.has_kdna_url) flags.push('no-package');
-    console.log(`    ${d.name.padEnd(36)} v${d.version || '?'}  ${flags.length ? `[${flags.join(', ')}]` : '✓'}`);
+    if (!d.has_asset_url) flags.push('no-package');
+    console.log(
+      `    ${d.name.padEnd(36)} v${d.version || '?'}  ${flags.length ? `[${flags.join(', ')}]` : '✓'}`,
+    );
   }
 }
 
@@ -205,7 +208,7 @@ function cmdPackage(domainPath, args = []) {
   }
 
   const manifest = readJson(path.join(abs, 'kdna.json'));
-  if (!manifest) error(`No kdna.json found in ${abs}. Run: kdna pack`, EXIT.INPUT_ERROR);
+  if (!manifest) error(`No kdna.json found in ${abs}. Run: kdna dev pack`, EXIT.INPUT_ERROR);
 
   const domainName = manifest.name?.split('/')?.[1] || path.basename(abs);
   const outFile = path.join(abs, 'dist', `${domainName}-${manifest.version || '0.1.0'}.kdna`);
@@ -230,7 +233,9 @@ function cmdPackage(domainPath, args = []) {
       scenarios: readJson(path.join(abs, 'KDNA_Scenarios.json'))?.scenes?.length || 0,
       cases: readJson(path.join(abs, 'KDNA_Cases.json'))?.cases?.length || 0,
     },
-    files: fs.readdirSync(abs).filter((f) => f.endsWith('.json') || f === 'README.md' || f === 'LICENSE'),
+    files: fs
+      .readdirSync(abs)
+      .filter((f) => f.endsWith('.json') || f === 'README.md' || f === 'LICENSE'),
   };
 
   // Actually pack

package/src/cmds/changelog.js

@@ -18,7 +18,7 @@ function downloadVersion(entry, version, destDir) {
   const { execSync, execFileSync } = require('child_process');
   const tmpFile = `${destDir}.kdna.tmp`;
   try {
-    execFileSync('curl', ['-fsSL', '--retry', '2', '-o', tmpFile, entry.kdna_url], {
+    execFileSync('curl', ['-fsSL', '--retry', '2', '-o', tmpFile, entry.asset_url], {
       timeout: 60000,
       stdio: 'pipe',
     });
@@ -90,25 +90,43 @@ function cmdChangelog(args = []) {
   // Diff maps
   const axioms = diffSummary(oldJ.axioms || {}, newJ.axioms || {}, 'one_sentence');
   const ontology = diffSummary(oldJ.ontology || {}, newJ.ontology || {}, 'concept');
-  const misunderstandings = diffSummary(oldJ.misunderstandings || {}, newJ.misunderstandings || {}, 'wrong');
-  const bannedTerms = diffList(Object.keys(oldJ.banned_terms || {}), Object.keys(newJ.banned_terms || {}));
+  const misunderstandings = diffSummary(
+    oldJ.misunderstandings || {},
+    newJ.misunderstandings || {},
+    'wrong',
+  );
+  const bannedTerms = diffList(
+    Object.keys(oldJ.banned_terms || {}),
+    Object.keys(newJ.banned_terms || {}),
+  );
   const stances = diffList(oldJ.stances || [], newJ.stances || []);
 
   // Version bump suggestion
-  const hasRemoved = Object.values(axioms).some((a) => a.status === 'removed') ||
-                     Object.values(misunderstandings).some((m) => m.status === 'removed');
-  const hasAdded = Object.values(axioms).some((a) => a.status === 'added') ||
-                   Object.values(misunderstandings).some((m) => m.status === 'added');
-  const hasChanged = Object.values(axioms).some((a) => a.status === 'changed') ||
-                     Object.values(misunderstandings).some((m) => m.status === 'changed');
+  const hasRemoved =
+    Object.values(axioms).some((a) => a.status === 'removed') ||
+    Object.values(misunderstandings).some((m) => m.status === 'removed');
+  const hasAdded =
+    Object.values(axioms).some((a) => a.status === 'added') ||
+    Object.values(misunderstandings).some((m) => m.status === 'added');
+  const hasChanged =
+    Object.values(axioms).some((a) => a.status === 'changed') ||
+    Object.values(misunderstandings).some((m) => m.status === 'changed');
   let recommendedBump = 'none';
   if (hasRemoved) recommendedBump = 'major';
   else if (hasAdded || hasChanged) recommendedBump = 'minor';
   else if (stances.added.length || stances.removed.length) recommendedBump = 'patch';
 
   // Cleanup
-  try { fs.rmSync(tmpOld, { recursive: true, force: true }); } catch { /* cleanup */ }
-  try { fs.rmSync(tmpNew, { recursive: true, force: true }); } catch { /* cleanup */ }
+  try {
+    fs.rmSync(tmpOld, { recursive: true, force: true });
+  } catch {
+    /* cleanup */
+  }
+  try {
+    fs.rmSync(tmpNew, { recursive: true, force: true });
+  } catch {
+    /* cleanup */
+  }
 
   // Output
   const changelog = {
@@ -139,7 +157,9 @@ function cmdChangelog(args = []) {
   console.log(`## ${fromVersion} → ${toVersion}`);
   console.log('');
   if (oldJ.judgment_version || newJ.judgment_version) {
-    console.log(`Judgment version: ${oldJ.judgment_version || '(none)'} → ${newJ.judgment_version || '(none)'}`);
+    console.log(
+      `Judgment version: ${oldJ.judgment_version || '(none)'} → ${newJ.judgment_version || '(none)'}`,
+    );
     console.log('');
   }