@aikdna/kdna-cli 0.16.10 → 0.18.0

package/src/cli.js

@@ -10,9 +10,7 @@ const { error, EXIT, setQuiet, setExitCodeOnly } = require('./cmds/_common');
 const {
   cmdValidate,
   cmdPack,
-  cmdPackEncrypt,
   cmdUnpack,
-  cmdUnpackEncrypt,
   cmdInspect,
   cmdCard,
 } = require('./cmds/domain');
@@ -26,6 +24,7 @@ const {
   cmdSelect,
   cmdLoad,
   cmdPostvalidate,
+  cmdRoute,
 } = require('./cmds/quality');
 const { cmdCluster } = require('./cmds/cluster');
 const { cmdIdentity } = require('./cmds/identity');
@@ -38,6 +37,9 @@ const {
   cmdLicenseBind,
   cmdLicenseShow,
   cmdLicenseInstall,
+  cmdLicenseStatus,
+  cmdLicenseActivate,
+  cmdLicenseSync,
 } = require('./cmds/license');
 const { cmdPreview, cmdProject, cmdEval, cmdExport, cmdDemo } = require('./cmds/legacy');
 const {
@@ -57,7 +59,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 ─────────────────────────────────────────────────────────────
 
@@ -79,15 +82,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
@@ -101,21 +103,22 @@ Studio Integration (Phase 1):
   studio readiness <project.json>  Generate domain readiness card
 
 Agent Runtime:
+  route "<task>" [--json] [--discover]  5-Gate 7-State routing decision
   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
@@ -146,6 +149,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
@@ -170,9 +174,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)
@@ -188,41 +195,69 @@ 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': {
@@ -240,7 +275,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) {
@@ -283,7 +318,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);
@@ -291,10 +326,10 @@ 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, locale);
+    cmdCard(target, args.includes('--json'), locale);
     break;
   }
   case 'verify': {
@@ -303,10 +338,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);
@@ -340,6 +375,10 @@ switch (cmd) {
     cmdSelect(args);
     break;
   }
+  case 'route': {
+    cmdRoute(args);
+    break;
+  }
   case 'postvalidate': {
     cmdPostvalidate(args);
     break;
@@ -424,9 +463,7 @@ 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
@@ -446,6 +483,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;
@@ -485,14 +526,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,
       );
     }
@@ -513,7 +563,7 @@ switch (cmd) {
       const idx = args.indexOf('--check');
       const target = args[idx + 1] || args.filter((a) => !a.startsWith('--'))[1] || '.';
       if (!target || target.startsWith('--')) error('Usage: kdna publish --check <path>');
-      cmdPublishCheck(target);
+      cmdPublishCheck(target, args);
     } else {
       const { cmdPublish } = require('./publish');
       const target = args.filter((a) => !a.startsWith('--'))[1];

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 ──────────────────────────────────────────────────────
 
@@ -54,14 +51,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 +68,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 +78,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 +139,25 @@ 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 +176,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,12 @@ 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,7 +183,7 @@ 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');
+    if (!d.has_asset_url) flags.push('no-package');
     console.log(`    ${d.name.padEnd(36)} v${d.version || '?'}  ${flags.length ? `[${flags.join(', ')}]` : '✓'}`);
   }
 }
@@ -205,7 +205,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`);

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',
     });

package/src/cmds/cluster.js

@@ -8,6 +8,16 @@ const {
   detectDomainConflicts,
   generateClusterTrace,
 } = require('@aikdna/kdna-core');
+const { getInstalled, readContainer } = require('../package-store');
+
+function loadInstalledDomain(domainId) {
+  const full = domainId.startsWith('@') ? domainId : `@aikdna/${domainId}`;
+  const installed = getInstalled(full);
+  if (!installed) return null;
+  const { core, patterns } = readContainer(installed.asset_path);
+  if (!core || !patterns) return null;
+  return { core, patterns };
+}
 
 function cmdCluster(args) {
   const { cmdClusterLint } = require('../cluster');
@@ -101,7 +111,7 @@ function cmdClusterInfo(target, _format = 'human') {
 }
 
 /**
- * Load a cluster: resolve domains from installed ~/.kdna/domains/,
+ * Load a cluster: resolve domains from installed .kdna assets,
  * classify input signals, compose context with attribution, detect
  * conflicts, and emit the composed context.
  */
@@ -116,23 +126,7 @@ function cmdClusterLoad(target, args = []) {
   const manifest = readJson(abs);
   if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
 
-  const INSTALL_DIR = path.join(
-    process.env.HOME || process.env.USERPROFILE || '.',
-    '.kdna',
-    'domains',
-  );
-
-  // Domain loader: resolve from installed ~/.kdna/domains/
-  const domainLoader = (domainId) => {
-    const [scope, ident] = domainId.startsWith('@')
-      ? [domainId.slice(0, domainId.indexOf('/')), domainId.slice(domainId.indexOf('/') + 1)]
-      : ['@aikdna', domainId];
-    const dir = path.join(INSTALL_DIR, scope, ident);
-    const core = readJson(path.join(dir, 'KDNA_Core.json'));
-    const pat = readJson(path.join(dir, 'KDNA_Patterns.json'));
-    if (!core || !pat) return null;
-    return { core, patterns: pat };
-  };
+  const domainLoader = loadInstalledDomain;
 
   const result = loadCluster(abs, domainLoader);
   if (result.errors.length) {
@@ -208,22 +202,7 @@ function cmdClusterMatch(target, args = []) {
   const manifest = readJson(abs);
   if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
 
-  const INSTALL_DIR = path.join(
-    process.env.HOME || process.env.USERPROFILE || '.',
-    '.kdna',
-    'domains',
-  );
-
-  const domainLoader = (domainId) => {
-    const [scope, ident] = domainId.startsWith('@')
-      ? [domainId.slice(0, domainId.indexOf('/')), domainId.slice(domainId.indexOf('/') + 1)]
-      : ['@aikdna', domainId];
-    const dir = path.join(INSTALL_DIR, scope, ident);
-    const core = readJson(path.join(dir, 'KDNA_Core.json'));
-    const pat = readJson(path.join(dir, 'KDNA_Patterns.json'));
-    if (!core || !pat) return null;
-    return { core, patterns: pat };
-  };
+  const domainLoader = loadInstalledDomain;
 
   const result = loadCluster(abs, domainLoader);
   const classification = classifySignalsAcrossDomains(input, result.domains);
@@ -423,23 +402,12 @@ function cmdClusterGraph(target, args = []) {
  * Shared domain loader for cluster commands.
  */
 function loadClusterDomains(manifest) {
-  const INSTALL_DIR = path.join(
-    process.env.HOME || process.env.USERPROFILE || '.',
-    '.kdna',
-    'domains',
-  );
-
   return (manifest.domains || []).map((d) => {
     const domainId = d.id;
     if (!domainId) return null;
-    const [scope, ident] = domainId.startsWith('@')
-      ? [domainId.slice(0, domainId.indexOf('/')), domainId.slice(domainId.indexOf('/') + 1)]
-      : ['@aikdna', domainId];
-    const dir = path.join(INSTALL_DIR, scope, ident);
-    const core = readJson(path.join(dir, 'KDNA_Core.json'));
-    const pat = readJson(path.join(dir, 'KDNA_Patterns.json'));
-    if (!core || !pat) return null;
-    return { id: domainId, role: d.role, required: d.required !== false, core, patterns: pat };
+    const loaded = loadInstalledDomain(domainId);
+    if (!loaded) return null;
+    return { id: domainId, role: d.role, required: d.required !== false, ...loaded };
   }).filter(Boolean);
 }
 

package/src/cmds/doctor.js

@@ -1,8 +1,9 @@
 const fs = require('fs');
 const path = require('path');
-const { EXIT, error } = require('./_common');
+const { EXIT } = require('./_common');
 const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
-const INSTALL_DIR = path.join(USER_KDNA_DIR, 'domains');
+const PATHS = require('../paths');
+const { listInstalled } = require('../package-store');
 
 const AGENTS = [
   { name: 'OpenCode', dir: path.join(process.env.HOME || '', '.agents'), skillsDir: 'skills' },
@@ -17,11 +18,6 @@ const AGENTS = [
 ];
 
 const V2_1_MARKER = 'kdna available';
-
-function detectAgents() {
-  return AGENTS.filter((a) => fs.existsSync(a.dir));
-}
-
 function checkAgentSkill(agent) {
   const skillPath = path.join(agent.dir, agent.skillsDir, 'kdna-loader', 'SKILL.md');
   if (!fs.existsSync(skillPath)) return { installed: false, version: null, path: skillPath };
@@ -74,38 +70,25 @@ function cmdDoctor(args) {
       checks.push({ name: 'KDNA data directory', status: 'warn', detail: '~/.kdna/ not found' });
     }
 
-    // 4. ~/.kdna/domains/ exists and has domains
-    if (fs.existsSync(INSTALL_DIR)) {
-      const domains = fs
-        .readdirSync(INSTALL_DIR, { withFileTypes: true })
-        .filter((d) => d.isDirectory())
-        .reduce((acc, scopeDir) => {
-          if (scopeDir.name.startsWith('@')) {
-            try {
-              return acc + fs.readdirSync(path.join(INSTALL_DIR, scopeDir.name)).length;
-            } catch {
-              return acc;
-            }
-          }
-          return acc + 1;
-        }, 0);
+    // 4. ~/.kdna/packages/ exists and has .kdna assets
+    if (fs.existsSync(PATHS.packages)) {
+      const domains = listInstalled().length;
       checks.push({
-        name: 'Installed domains',
+        name: 'Installed assets',
         status: domains > 0 ? 'ok' : 'warn',
-        detail: `${domains} domain${domains !== 1 ? 's' : ''} installed`,
+        detail: `${domains} .kdna asset${domains !== 1 ? 's' : ''} installed`,
       });
     } else {
       checks.push({
-        name: 'Domains directory',
+        name: 'Package asset store',
         status: 'warn',
-        detail: '~/.kdna/domains/ not found',
+        detail: '~/.kdna/packages/ not found',
       });
     }
   }
 
   if (!domainsOnly) {
     // 5. Agent integration check
-    const detected = detectAgents();
     for (const agent of AGENTS) {
       const agentDirExists = fs.existsSync(agent.dir);
       const skill = agentDirExists