@aikdna/kdna-cli 0.9.0 → 0.11.0

package/src/cmds/cluster.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { error, readJson } = require('./_common');
+const { error, readJson, EXIT } = require('./_common');
 const {
   loadCluster,
   classifySignalsAcrossDomains,
@@ -29,6 +29,15 @@ function cmdCluster(args) {
   } else if (sub === 'match') {
     if (!target) error('Usage: kdna cluster match <cluster.json> --input "<task>"');
     cmdClusterMatch(target, args);
+  } else if (sub === 'compose') {
+    if (!target) error('Usage: kdna cluster compose <cluster.json> --input "<task>" [--profile=compact] [--json]');
+    cmdClusterCompose(target, args);
+  } else if (sub === 'conflicts') {
+    if (!target) error('Usage: kdna cluster conflicts <cluster.json> --input "<task>" [--json]');
+    cmdClusterConflicts(target, args);
+  } else if (sub === 'graph') {
+    if (!target) error('Usage: kdna cluster graph <cluster.json> [--format=dot|json]');
+    cmdClusterGraph(target, args);
   } else if (sub === 'apply') {
     error(
       'kdna cluster apply was removed in v0.9.\n' +
@@ -42,12 +51,15 @@ function cmdCluster(args) {
         '       kdna cluster init <name>\n' +
         '       kdna cluster info <cluster.json>\n' +
         '       kdna cluster match <cluster.json> --input "<task>"\n' +
-        '       kdna cluster load <cluster.json> --input "<task>"',
+        '       kdna cluster load <cluster.json> --input "<task>"\n' +
+        '       kdna cluster compose <cluster.json> --input "<task>"\n' +
+        '       kdna cluster conflicts <cluster.json> --input "<task>"\n' +
+        '       kdna cluster graph <cluster.json>',
     );
   }
 }
 
-function cmdClusterInfo(target, format = 'human') {
+function cmdClusterInfo(target, _format = 'human') {
   const abs = path.resolve(target);
   if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
 
@@ -232,4 +244,203 @@ function cmdClusterMatch(target, args = []) {
   });
 }
 
+/**
+ * Compose: classify input signals, then compose context with source attribution.
+ * Unlike load (which includes trace), compose focuses on the composed context.
+ */
+function cmdClusterCompose(target, args = []) {
+  const jsonMode = args.includes('--json');
+  const abs = path.resolve(target);
+  if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
+
+  const profileIdx = args.indexOf('--profile');
+  let profile = 'compact';
+  if (profileIdx >= 0) {
+    const val = args[profileIdx + 1];
+    if (val && !val.startsWith('--')) profile = val;
+  }
+
+  const inputIdx = args.indexOf('--input');
+  const input = inputIdx >= 0 ? args[inputIdx + 1] : '';
+  if (!input) error('Usage: kdna cluster compose <cluster.json> --input "<task>"');
+
+  const manifest = readJson(abs);
+  if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
+
+  const domains = loadClusterDomains(manifest);
+
+  const classification = classifySignalsAcrossDomains(input, domains);
+  const { context } = composeContextWithAttribution(classification.selected);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      cluster: manifest.cluster_id,
+      input: input.slice(0, 200),
+      selected: classification.selected.map((d) => ({
+        id: d.id,
+        role: d.role,
+        reason: d.reason,
+      })),
+      excluded: classification.excluded.map((d) => ({
+        id: d.id,
+        reason: d.reason,
+      })),
+      context,
+    }, null, 2));
+    return;
+  }
+
+  console.log(`Cluster: ${manifest.cluster_id}`);
+  console.log(`Profile: ${profile}`);
+  console.log(`Input:   ${input.slice(0, 100)}${input.length > 100 ? '...' : ''}`);
+  console.log('');
+  console.log(`Selected: ${classification.selected.length} | Excluded: ${classification.excluded.length}`);
+  console.log('');
+  console.log('─'.repeat(64));
+  console.log(context);
+  console.log('─'.repeat(64));
+}
+
+/**
+ * Conflicts: detect conflicts between selected domains for given input.
+ */
+function cmdClusterConflicts(target, args = []) {
+  const jsonMode = args.includes('--json');
+  const abs = path.resolve(target);
+  if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
+
+  const inputIdx = args.indexOf('--input');
+  const input = inputIdx >= 0 ? args[inputIdx + 1] : '';
+  if (!input) error('Usage: kdna cluster conflicts <cluster.json> --input "<task>"');
+
+  const manifest = readJson(abs);
+  if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
+
+  const domains = loadClusterDomains(manifest);
+  const classification = classifySignalsAcrossDomains(input, domains);
+  const conflicts = detectDomainConflicts(classification.selected);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      cluster: manifest.cluster_id,
+      input: input.slice(0, 200),
+      selected: classification.selected.map((d) => ({ id: d.id, role: d.role })),
+      conflicts: conflicts.map((c) => ({
+        type: c.type,
+        domains: c.domains,
+        description: c.description,
+        severity: c.severity || 'warn',
+      })),
+      conflict_count: conflicts.length,
+      safe: conflicts.length === 0,
+    }, null, 2));
+    process.exit(conflicts.length ? EXIT.HUMAN_LOCK_REQUIRED : EXIT.OK);
+  }
+
+  console.log(`Cluster: ${manifest.cluster_id}`);
+  console.log(`Input:   ${input.slice(0, 100)}${input.length > 100 ? '...' : ''}`);
+  console.log(`Selected: ${classification.selected.length} domains | Conflicts: ${conflicts.length}`);
+  console.log('');
+
+  if (!conflicts.length) {
+    console.log('✓ No conflicts detected.');
+    return;
+  }
+
+  for (const c of conflicts) {
+    const severity = c.severity === 'error' ? '✗' : '⚠';
+    console.log(`${severity} [${c.type}] ${c.domains.join(' vs ')}`);
+    console.log(`  ${c.description}`);
+    console.log('');
+  }
+}
+
+/**
+ * Graph: output the domain relationship graph from a cluster manifest.
+ */
+function cmdClusterGraph(target, args = []) {
+  const abs = path.resolve(target);
+  if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
+
+  const manifest = readJson(abs);
+  if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
+
+  const formatIdx = args.indexOf('--format');
+  let format = 'dot';
+  if (formatIdx >= 0) {
+    const val = args[formatIdx + 1];
+    if (val && ['dot', 'json'].includes(val)) format = val;
+  }
+
+  if (format === 'json') {
+    const graph = {
+      cluster: manifest.cluster_id,
+      version: manifest.version || '?',
+      type: manifest.type || 'horizontal',
+      nodes: (manifest.domains || []).map((d) => ({
+        id: d.id || d.role,
+        role: d.role,
+        required: d.required !== false,
+      })),
+      edges: (manifest.relationships || []).map((r) => ({
+        from: r.from,
+        to: r.to,
+        type: r.type,
+      })),
+    };
+    console.log(JSON.stringify(graph, null, 2));
+    return;
+  }
+
+  // DOT format output
+  console.log(`digraph "${manifest.cluster_id}" {`);
+  console.log('  rankdir=LR;');
+  console.log(`  label="${manifest.cluster_id} v${manifest.version || '?'}";`);
+  console.log('  fontsize=14;');
+  console.log('');
+
+  // Nodes
+  for (const d of manifest.domains || []) {
+    const shape = d.role === 'primary' ? 'box' : d.role === 'critic' ? 'diamond' : 'ellipse';
+    const required = d.required !== false ? ',style=filled,fillcolor="#e8f0fe"' : ',style=dashed';
+    console.log(`  "${d.id || d.role}" [label="${d.id || d.role}\\n[${d.role}]",shape=${shape}${required}];`);
+  }
+
+  // Edges
+  if (manifest.relationships) {
+    console.log('');
+    for (const r of manifest.relationships) {
+      const style = r.type === 'conflicts' ? ',style=dashed,color=red' :
+                    r.type === 'extends' ? ',style=bold' : '';
+      console.log(`  "${r.from}" -> "${r.to}" [label="${r.type}"${style}];`);
+    }
+  }
+
+  console.log('}');
+}
+
+/**
+ * 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 };
+  }).filter(Boolean);
+}
+
 module.exports = { cmdCluster };

package/src/cmds/doctor.js

@@ -0,0 +1,160 @@
+const fs = require('fs');
+const path = require('path');
+const { EXIT, error } = require('./_common');
+const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
+const INSTALL_DIR = path.join(USER_KDNA_DIR, 'domains');
+
+function cmdDoctor(args) {
+  const json = args.includes('--json');
+  const quiet = args.includes('--quiet');
+
+  const checks = [];
+
+  // 1. Node.js version
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+  checks.push({
+    name: 'Node.js',
+    status: major >= 18 ? 'ok' : 'fail',
+    detail: `${nodeVersion} (${major >= 18 ? '>=18 required' : 'requires >=18'})`,
+  });
+
+  // 2. @aikdna/kdna-core available
+  let coreVersion = null;
+  try {
+    const corePkg = require.resolve('@aikdna/kdna-core/package.json');
+    coreVersion = JSON.parse(fs.readFileSync(corePkg, 'utf8')).version;
+    checks.push({ name: '@aikdna/kdna-core', status: 'ok', detail: `v${coreVersion}` });
+  } catch {
+    checks.push({ name: '@aikdna/kdna-core', status: 'fail', detail: 'not installed' });
+  }
+
+  // 3. ~/.kdna/ exists
+  if (fs.existsSync(USER_KDNA_DIR)) {
+    checks.push({ name: 'KDNA data directory', status: 'ok', detail: USER_KDNA_DIR });
+  } else {
+    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);
+    checks.push({
+      name: 'Installed domains',
+      status: domains > 0 ? 'ok' : 'warn',
+      detail: `${domains} domain${domains !== 1 ? 's' : ''} installed`,
+    });
+  } else {
+    checks.push({ name: 'Domains directory', status: 'warn', detail: '~/.kdna/domains/ not found' });
+  }
+
+  // 5. Identity key available
+  const identityDir = path.join(USER_KDNA_DIR, 'identity');
+  const identityDirOfficial = path.join(USER_KDNA_DIR, 'identity-official');
+  const hasIdentity =
+    (fs.existsSync(identityDir) && fs.readdirSync(identityDir).length > 0) ||
+    (fs.existsSync(identityDirOfficial) && fs.readdirSync(identityDirOfficial).length > 0);
+  checks.push({
+    name: 'Signing identity',
+    status: hasIdentity ? 'ok' : 'warn',
+    detail: hasIdentity ? 'key available' : 'no identity (run: kdna identity init)',
+  });
+
+  // 6. Registry cache
+  const registryCache = path.join(USER_KDNA_DIR, 'registry-cache.json');
+  if (fs.existsSync(registryCache)) {
+    try {
+      const stat = fs.statSync(registryCache);
+      const ageMs = Date.now() - stat.mtimeMs;
+      const ageH = Math.round(ageMs / 3600000);
+      const fresh = ageH < 24;
+      checks.push({
+        name: 'Registry cache',
+        status: fresh ? 'ok' : 'warn',
+        detail: `updated ${ageH < 1 ? '<1h' : ageH + 'h'} ago`,
+      });
+    } catch {
+      checks.push({ name: 'Registry cache', status: 'warn', detail: 'cannot read cache' });
+    }
+  } else {
+    checks.push({ name: 'Registry cache', status: 'warn', detail: 'not cached (run: kdna registry refresh)' });
+  }
+
+  // 7. Schema files available
+  let schemaCount = 0;
+  try {
+    const schemaDir = path.join(
+      path.dirname(require.resolve('@aikdna/kdna-core/package.json')),
+      'schema',
+    );
+    schemaCount = fs.readdirSync(schemaDir).filter((f) => f.endsWith('.schema.json')).length;
+    checks.push({
+      name: 'Schema files',
+      status: schemaCount >= 6 ? 'ok' : 'warn',
+      detail: `${schemaCount} schemas`,
+    });
+  } catch {
+    checks.push({ name: 'Schema files', status: 'fail', detail: 'not found' });
+  }
+
+  // 8. Project .kdna/config.json
+  const projectConfig = path.join(process.cwd(), '.kdna', 'config.json');
+  if (fs.existsSync(projectConfig)) {
+    checks.push({ name: 'Project config', status: 'ok', detail: projectConfig });
+  } else {
+    checks.push({ name: 'Project config', status: 'warn', detail: 'No .kdna/config.json in current project' });
+  }
+
+  // Output
+  if (json) {
+    const result = {
+      checks: checks.map((c) => ({
+        name: c.name,
+        status: c.status,
+        detail: c.detail,
+      })),
+      ok: checks.filter((c) => c.status === 'ok').length,
+      warnings: checks.filter((c) => c.status === 'warn').length,
+      failures: checks.filter((c) => c.status === 'fail').length,
+      healthy: checks.every((c) => c.status !== 'fail'),
+    };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.healthy ? 0 : EXIT.VALIDATION_FAILED);
+  }
+
+  if (!quiet) {
+    for (const c of checks) {
+      const mark = c.status === 'ok' ? '✓' : c.status === 'warn' ? '⚠' : '✗';
+      console.log(`${mark} ${c.name}: ${c.detail}`);
+    }
+
+    const ok = checks.filter((c) => c.status === 'ok').length;
+    const warns = checks.filter((c) => c.status === 'warn').length;
+    const fails = checks.filter((c) => c.status === 'fail').length;
+    console.log('');
+    if (fails > 0) {
+      console.log(`${ok}/${checks.length} checks passed (${fails} failure${fails !== 1 ? 's' : ''}, ${warns} warning${warns !== 1 ? 's' : ''})`);
+    } else if (warns > 0) {
+      console.log(`${ok}/${checks.length} checks passed (${warns} warning${warns !== 1 ? 's' : ''})`);
+    } else {
+      console.log(`${ok}/${checks.length} checks passed`);
+    }
+  }
+
+  const hasFail = checks.some((c) => c.status === 'fail');
+  process.exit(hasFail ? EXIT.VALIDATION_FAILED : EXIT.OK);
+}
+
+module.exports = { cmdDoctor };

package/src/cmds/domain.js

@@ -1,14 +1,14 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
-const { error, readJson, writeJson } = require('./_common');
+const { error, readJson, writeJson, EXIT } = require('./_common');
 
 // ─── Validate ────────────────────────────────────────────────────────
 
-function cmdValidate(dir, schemaOnly) {
+function cmdValidate(dir, schemaOnly, jsonMode = false) {
   const abs = path.resolve(dir);
   if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
-    error(`Not a directory: ${abs}`);
+    error(`Not a directory: ${abs}`, EXIT.INPUT_ERROR);
   }
 
   const { lintDomain, validateDomainSchema, validateCrossFile } = require('@aikdna/kdna-core');
@@ -87,6 +87,25 @@ function cmdValidate(dir, schemaOnly) {
   errors.push(...crossResult.errors);
   warnings.push(...crossResult.warnings);
 
+  const validCount = Object.keys(dataMap).filter((k) => dataMap[k]).length;
+  const schemaInfo = schemaOnly
+    ? ` (schema-only mode, ${loadedSchemas.length} schemas loaded)`
+    : '';
+
+  if (jsonMode) {
+    const result = {
+      path: abs,
+      valid: errors.length === 0,
+      files: validCount,
+      schemas_loaded: loadedSchemas.length,
+      schema_only: schemaOnly,
+      errors,
+      warnings,
+    };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(errors.length ? EXIT.VALIDATION_FAILED : EXIT.OK);
+  }
+
   if (warnings.length) {
     console.log('Warnings:');
     warnings.forEach((w) => console.log(`  - ${w}`));
@@ -94,13 +113,9 @@ function cmdValidate(dir, schemaOnly) {
   if (errors.length) {
     console.error('Errors:');
     errors.forEach((e) => console.error(`  - ${e}`));
-    process.exit(1);
+    process.exit(EXIT.VALIDATION_FAILED);
   }
 
-  const validCount = Object.keys(dataMap).filter((k) => dataMap[k]).length;
-  const schemaInfo = schemaOnly
-    ? ` (schema-only mode, ${loadedSchemas.length} schemas loaded)`
-    : '';
   console.log(`✓ KDNA domain valid: ${abs} (${validCount} files, schema OK${schemaInfo})`);
 }
 
@@ -109,7 +124,7 @@ function cmdValidate(dir, schemaOnly) {
 function cmdPack(dir, outputDir) {
   const abs = path.resolve(dir);
   if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
-    error(`Not a directory: ${abs}`);
+    error(`Not a directory: ${abs}`, EXIT.INPUT_ERROR);
   }
 
   const core = readJson(path.join(abs, 'KDNA_Core.json'));
@@ -126,7 +141,7 @@ function cmdPack(dir, outputDir) {
       .readdirSync(abs)
       .filter((f) => f.endsWith('.json') && f !== 'kdna.json').length;
     manifest = {
-      kdna_spec: '0.4',
+      kdna_spec: '1.0-rc',
       name: domainName,
       version: core.meta?.version || '0.1.0',
       status: 'experimental',
@@ -300,17 +315,17 @@ function crc32(buf) {
 function cmdUnpack(filePath, force) {
   const abs = path.resolve(filePath);
   if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
-    error(`Not a file: ${abs}`);
+    error(`Not a file: ${abs}`, EXIT.INPUT_ERROR);
   }
   if (!abs.endsWith('.kdna')) {
-    error(`Not a .kdna file: ${abs}`);
+    error(`Not a .kdna file: ${abs}`, EXIT.INPUT_ERROR);
   }
 
   const domainName = path.basename(abs, '.kdna');
   const outDir = path.join(path.dirname(abs), domainName);
 
   if (fs.existsSync(outDir)) {
-    if (!force) error(`Directory already exists: ${outDir}\nUse --force to overwrite.`);
+    if (!force) error(`Directory already exists: ${outDir}\nUse --force to overwrite.`, EXIT.INPUT_ERROR);
     fs.rmSync(outDir, { recursive: true, force: true });
   }
 
@@ -352,7 +367,7 @@ zf.close()
 
 // ─── Inspect .kdna file (ZIP container or legacy merged JSON) ────────────
 
-function inspectKdnaFile(filePath) {
+function inspectKdnaFile(filePath, jsonMode = false) {
   const abs = path.resolve(filePath);
   fs.statSync(abs); // verify file exists
 
@@ -458,6 +473,33 @@ zf.close()
   const c = core;
   const p = patterns || {};
 
+  if (jsonMode) {
+    const result = {
+      name: m.name || c.meta?.domain || path.basename(abs, '.kdna'),
+      format: isZip ? 'kdna-zip' : 'legacy-merged',
+      spec: m.spec_version || m.kdna_spec || null,
+      version: m.version || null,
+      status: m.status || 'experimental',
+      access: m.access || 'open',
+      author: m.author?.name || null,
+      license: m.license?.type || null,
+      created: m.created || c.meta?.created || null,
+      description: m.description || c.meta?.purpose || null,
+      content: {
+        axioms: (c.axioms || []).length,
+        ontology: (c.ontology || []).length,
+        frameworks: (c.frameworks || []).length,
+        stances: (c.stances || []).length,
+        banned_terms: (p.terminology?.banned_terms || []).length,
+        misunderstandings: (p.misunderstandings || []).length,
+        self_checks: (p.self_check || []).length,
+      },
+      files: presentFiles,
+    };
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
   console.log('═'.repeat(50));
   console.log(`  ${m.name || c.meta?.domain || path.basename(abs, '.kdna')} — KDNA Domain`);
   console.log('═'.repeat(50));
@@ -537,29 +579,78 @@ function parseSimpleYaml(raw) {
 
 // ─── Inspect ───────────────────────────────────────────────────────────
 
-function cmdInspect(dir) {
+function cmdInspect(dir, jsonMode = false) {
   const abs = path.resolve(dir);
   const stat = fs.existsSync(abs) ? fs.statSync(abs) : null;
-  if (!stat) error(`Path not found: ${abs}`);
+  if (!stat) error(`Path not found: ${abs}`, EXIT.INPUT_ERROR);
 
   // Single .kdna file
   if (stat.isFile() && abs.endsWith('.kdna')) {
-    inspectKdnaFile(abs);
+    inspectKdnaFile(abs, jsonMode);
     return;
   }
 
   // Directory — existing logic
-  if (!stat.isDirectory()) error(`Not a KDNA domain: ${abs}`);
+  if (!stat.isDirectory()) error(`Not a KDNA domain: ${abs}`, EXIT.INPUT_ERROR);
 
   const core = readJson(path.join(abs, 'KDNA_Core.json'));
   const manifest = readJson(path.join(abs, 'kdna.json'));
 
   if (!core) {
-    error(`Not a KDNA domain (KDNA_Core.json not found in ${abs})`);
+    error(`Not a KDNA domain (KDNA_Core.json not found in ${abs})`, EXIT.INPUT_ERROR);
   }
 
   const m = manifest || {};
   const c = core;
+  const pat = readJson(path.join(abs, 'KDNA_Patterns.json'));
+  const sce = readJson(path.join(abs, 'KDNA_Scenarios.json'));
+  const cas = readJson(path.join(abs, 'KDNA_Cases.json'));
+  const rea = readJson(path.join(abs, 'KDNA_Reasoning.json'));
+  const evo = readJson(path.join(abs, 'KDNA_Evolution.json'));
+
+  const expected = [
+    'KDNA_Core.json',
+    'KDNA_Patterns.json',
+    'KDNA_Scenarios.json',
+    'KDNA_Cases.json',
+    'KDNA_Reasoning.json',
+    'KDNA_Evolution.json',
+  ];
+  const filesPresent = expected.filter((f) => fs.existsSync(path.join(abs, f)));
+
+  if (jsonMode) {
+    const result = {
+      name: m.name || c.meta?.domain || path.basename(abs),
+      version: m.version || c.meta?.version || null,
+      status: m.status || 'experimental',
+      access: m.access || 'open',
+      language: m.language || c.meta?.language || null,
+      author: m.author?.name || null,
+      author_id: m.author?.id || null,
+      license: m.license?.type || null,
+      created: c.meta?.created || null,
+      description: m.description || c.meta?.purpose || null,
+      files: filesPresent,
+      content: {
+        axioms: (c.axioms || []).length,
+        ontology: (c.ontology || []).length,
+        frameworks: (c.frameworks || []).length,
+        core_structures: (c.core_structure || []).length,
+        stances: (c.stances || []).length,
+        preferred_terms: (pat?.terminology?.preferred_terms || pat?.terminology?.standard_terms || []).length,
+        banned_terms: (pat?.terminology?.banned_terms || []).length,
+        misunderstandings: (pat?.misunderstandings || []).length,
+        self_checks: (pat?.self_check || []).length,
+        scenarios: sce ? (sce.scenes || []).length : 0,
+        cases: cas ? (cas.cases || []).length : 0,
+        reasoning_chains: rea ? (rea.reasoning_chains || []).length : 0,
+        evolution_stages: evo ? (evo.stages || []).length : 0,
+      },
+      axioms: (c.axioms || []).map((a) => a.one_sentence || null).filter(Boolean),
+    };
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
 
   console.log('═'.repeat(50));
   console.log(`  ${m.name || c.meta?.domain || path.basename(abs)} — KDNA Domain`);
@@ -576,15 +667,6 @@ function cmdInspect(dir) {
   console.log(`  Description: ${m.description || c.meta?.purpose || '?'}`);
   console.log('');
 
-  const expected = [
-    'KDNA_Core.json',
-    'KDNA_Patterns.json',
-    'KDNA_Scenarios.json',
-    'KDNA_Cases.json',
-    'KDNA_Reasoning.json',
-    'KDNA_Evolution.json',
-  ];
-
   console.log('  ── File Set ──');
   for (const f of expected) {
     const exists = fs.existsSync(path.join(abs, f));
@@ -599,7 +681,6 @@ function cmdInspect(dir) {
   console.log(`  Core structures:    ${(c.core_structure || []).length}`);
   console.log(`  Stances:            ${(c.stances || []).length}`);
 
-  const pat = readJson(path.join(abs, 'KDNA_Patterns.json'));
   if (pat) {
     const preferred = pat.terminology?.preferred_terms || pat.terminology?.standard_terms || [];
     console.log(`  Preferred terms:    ${preferred.length}`);
@@ -608,16 +689,12 @@ function cmdInspect(dir) {
     console.log(`  Self-checks:        ${(pat.self_check || []).length}`);
   }
 
-  const sce = readJson(path.join(abs, 'KDNA_Scenarios.json'));
   if (sce) console.log(`  Scenarios:          ${(sce.scenes || []).length}`);
 
-  const cas = readJson(path.join(abs, 'KDNA_Cases.json'));
   if (cas) console.log(`  Cases:              ${(cas.cases || []).length}`);
 
-  const rea = readJson(path.join(abs, 'KDNA_Reasoning.json'));
   if (rea) console.log(`  Reasoning chains:   ${(rea.reasoning_chains || []).length}`);
 
-  const evo = readJson(path.join(abs, 'KDNA_Evolution.json'));
   if (evo) console.log(`  Evolution stages:   ${(evo.stages || []).length}`);
 
   console.log('');