@aikdna/kdna-cli 0.26.3 → 0.26.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aikdna/kdna-cli",
-  "version": "0.26.3",
-  "description": "KDNA CLI — runtime control plane for verifying, installing, loading, comparing, publishing, and auditing existing .kdna assets.",
+  "version": "0.26.5",
+  "description": "KDNA CLI — runtime control plane for inspecting, validating, planning, packing, unpacking, and loading local .kdna assets.",
   "type": "commonjs",
   "bin": {
     "kdna": "src/cli.js",

package/src/cli.js

@@ -873,10 +873,10 @@ switch (cmd) {
   case 'studio': {
     error(
       'kdna studio has been removed from the runtime CLI.\n' +
-        'Trusted KDNA authoring belongs to the standalone Studio CLI:\n' +
+        'Studio project authoring belongs to the standalone Studio CLI:\n' +
         '  npm install -g @aikdna/kdna-studio-cli\n' +
         '  kdna-studio create <project>\n' +
-        '  kdna-studio export <project> --out <file.kdna> --sign',
+        '  kdna-studio export <project> --out <file.kdna>',
       EXIT.INPUT_ERROR,
     );
     break;

package/src/cmds/_common.js

@@ -49,69 +49,42 @@ function warn(...args) {
 }
 
 function usage() {
-  console.log(`kdna — KDNA domain cognition asset tool
+  console.log(`kdna — KDNA .kdna file tool
 
 Usage:
 
-  --- Dev source utilities (non-canonical) ---
+  --- Current Core v1 path ---
+  kdna inspect <file.kdna>      Inspect a local .kdna asset
+  kdna validate <file.kdna>     Validate a local .kdna asset
+  kdna plan-load <file.kdna>    Produce the required LoadPlan
+  kdna load <file.kdna> [--as=prompt|json|raw]   Load only when LoadPlan allows it
+
+  --- Dev source utilities (creator/debug path) ---
   kdna init <name>              Deprecated alias for kdna dev scaffold <name>
   kdna dev scaffold <name>      Scaffold a non-canonical dev source workspace
   kdna dev validate <path>      Validate a dev source directory
-  kdna dev pack <path>          Build a dev-only non-trusted .kdna bundle
+  kdna dev pack <path>          Build a dev-only diagnostic .kdna bundle
   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 <file.kdna>      Publish an existing Studio-compiled .kdna asset
-  kdna publish <file.kdna> --release-tag <tag> --repo <o/r>   ...also upload to GitHub
-  kdna publish --check <path>   Run dev source readiness checks only
   kdna version bump <patch|minor|major> [path]   Bump domain version
   kdna cluster lint <path>      Validate a cluster manifest
 
-  --- Domain consumers ---
-  kdna install <name>           Install official domain: @aikdna/<name>
-  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 remove <name>            Uninstall a domain
-  kdna update <name>            Update an installed domain
-  kdna update --all             Update all installed domains
-  kdna info <name>              Show version, signature, governance, risks
-  kdna list                     List installed domains
-  kdna list --available         List available domains from registry
-  kdna search <keyword>         Search registry by name/keywords/insight
-  kdna registry refresh         Refresh the canonical registry cache
-
-  --- Quality + judgment ---
-  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|file.kdna> [--as=prompt|json|raw]   Emit asset in agent-ready format
-
-  --- Identity ---
-  kdna identity init            Generate Ed25519 identity key pair
-  kdna identity show            Display public key and buyer ID
-  kdna identity export [--out]  Backup private key (passphrase-encrypted)
-  kdna identity import <file>   Restore identity from backup
+  kdna available [--json]       List locally available assets
+  kdna match "<task>" [--json]  Hint signals for local assets
 
   --- Other ---
   kdna setup                    One-command setup: CLI + skill + data root
   kdna doctor [--agents] [--domains] [--json]   System health check
-  kdna trace [--json] [--since 7d] [--export <file>]  Agent judgment trace
-  kdna history [--stats] [--domain <name>] [--agent <name>]  Recent usage
   kdna version                  Show kdna CLI version
   kdna help                     Show this help
+  kdna help legacy              Show legacy / experimental commands
 
 Examples:
-  kdna install writing
-  kdna verify @aikdna/writing
-  kdna available
-  kdna dev scaffold my_domain
-  kdna publish ./dist/my_domain.kdna --release-tag v0.1.0 --repo yourname/kdna-my_domain`);
+  kdna validate example.kdna
+  kdna plan-load example.kdna
+  kdna load example.kdna --profile=compact --as=prompt`);
 }
 
 // Exit codes — semantic exit codes for all KDNA CLI commands

package/src/cmds/demo.js

@@ -52,6 +52,9 @@ function cmdDemo(args) {
   process.stdout.write(`  kdna inspect  ${dest}\n`);
   process.stdout.write(`  kdna validate ${dest}\n`);
   process.stdout.write(`  kdna pack     ${dest} ${dest}.kdna\n`);
+  process.stdout.write(`  kdna validate ${dest}.kdna\n`);
+  process.stdout.write(`  kdna plan-load ${dest}.kdna\n`);
+  process.stdout.write(`  kdna load     ${dest}.kdna --profile=compact --as=prompt\n`);
 }
 
 module.exports = { cmdDemo };

package/src/cmds/studio.js

@@ -366,13 +366,13 @@ function cmdLockVerify(projectPath, args = []) {
           }
         }
       } else {
-        unlocked.push(label);
-        blocking.push(`${label} requires human lock`);
+            unlocked.push(label);
+            blocking.push(`${label} requires Studio review approval`);
       }
     }
   }
 
-  const publishable = blocking.length === 0 && locked.length > 0;
+  const exportReady = blocking.length === 0 && locked.length > 0;
 
   if (jsonMode) {
     console.log(
@@ -381,7 +381,7 @@ function cmdLockVerify(projectPath, args = []) {
           project: path.basename(abs),
           locked_cards: locked.length,
           unlocked_cards: unlocked.length,
-          publishable,
+          export_ready: exportReady,
           blocking,
           locked: locked.sort(),
           unlocked: unlocked.sort(),
@@ -390,14 +390,14 @@ function cmdLockVerify(projectPath, args = []) {
         2,
       ),
     );
-    process.exit(publishable ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
+    process.exit(exportReady ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
   }
 
-  console.log(`Lock status for: ${path.basename(abs)}`);
+  console.log(`Studio review status for: ${path.basename(abs)}`);
   console.log('');
-  console.log(`  Locked:   ${locked.length}`);
-  console.log(`  Unlocked: ${unlocked.length}`);
-  console.log(`  Publishable: ${publishable ? '✓ yes' : '✗ no'}`);
+  console.log(`  Approved: ${locked.length}`);
+  console.log(`  Pending:  ${unlocked.length}`);
+  console.log(`  Export ready: ${exportReady ? '✓ yes' : '✗ no'}`);
   console.log('');
 
   if (blocking.length) {
@@ -407,11 +407,11 @@ function cmdLockVerify(projectPath, args = []) {
   }
 
   if (locked.length) {
-    console.log('Locked cards:');
+    console.log('Approved cards:');
     locked.forEach((l) => console.log(`  ✓ ${l}`));
   }
 
-  process.exit(publishable ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
+  process.exit(exportReady ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
 }
 
 // ─── Studio Compile ───────────────────────────────────────────────────
@@ -577,20 +577,20 @@ function cmdStudioReadiness(projectPath, args = []) {
     self_checks: loadCardStats(project, path.dirname(abs), 'self_checks'),
     test_cases: 0,
     human_pass: '0/0',
-    publishable: false,
+    export_ready: false,
   };
 
-  // Determine publishability
+  // Determine Studio export readiness.
   const allTypes = Object.values(readiness).filter(
     (v) => v && typeof v === 'object' && 'total' in v,
   );
   let allLocked = allTypes.every((t) => t.total > 0 && t.total === t.locked);
   if (allTypes.length === 0) allLocked = false;
-  readiness.publishable = allLocked;
+  readiness.export_ready = allLocked;
 
   if (jsonMode) {
     console.log(JSON.stringify(readiness, null, 2));
-    process.exit(readiness.publishable ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
+    process.exit(readiness.export_ready ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
   }
 
   console.log(`Domain Readiness: ${project.name}`);
@@ -605,8 +605,8 @@ function cmdStudioReadiness(projectPath, args = []) {
   }
 
   console.log('');
-  console.log(`  Publishable: ${readiness.publishable ? '✓ yes' : '✗ no'}`);
-  process.exit(readiness.publishable ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
+  console.log(`  Export ready: ${readiness.export_ready ? '✓ yes' : '✗ no'}`);
+  process.exit(readiness.export_ready ? EXIT.OK : EXIT.HUMAN_LOCK_REQUIRED);
 }
 
 function loadCardStats(project, projectDir, cardType) {

package/src/init.js

@@ -64,11 +64,11 @@ function cmdInit(name, options = {}) {
   }
   console.log(`✓ Created non-canonical KDNA dev source workspace: ${targetDir}/`);
   console.log(`  Files: KDNA_Core.json, KDNA_Patterns.json, kdna.json, tests/before-after.json`);
-  console.log('  This workspace is not a trusted KDNA asset.');
-  console.log('  To create a trusted .kdna asset, use KDNA Studio compile/export.');
+  console.log('  This workspace is an authoring/editing view, not a public KDNA asset.');
+  console.log('  To create a runtime .kdna file, export through KDNA Studio or kdna dev pack.');
 
   // Run structural validation (lint + schema only). Content quality checks
-  // are for publish time, not scaffold time — the template contains placeholders
+  // are for release-evidence time, not scaffold time — the template contains placeholders
   // marked [TODO] that the author is expected to replace.
   try {
     const { execSync } = require('child_process');
@@ -100,8 +100,8 @@ function cmdInit(name, options = {}) {
   );
   console.log(`  3. Edit ${targetDir}/kdna.json — set author, description, repo`);
   console.log(`  4. Run: kdna dev validate ${name}           (structural check)`);
-  console.log(`  5. Run: kdna publish --check ${name}         (dev readiness check only)`);
-  console.log(`  6. Use KDNA Studio to Human Lock, compile, and export a trusted .kdna asset`);
+  console.log(`  5. Run: kdna dev pack ${name} --out dist/${name}.kdna`);
+  console.log(`  6. Run: kdna validate dist/${name}.kdna && kdna plan-load dist/${name}.kdna`);
 }
 
 /**

package/src/publish.js

@@ -175,17 +175,17 @@ function checkHumanLock(domainPath) {
   if (cards.length === 0) return { passed: true, issues: [] };
 
   for (const card of cards) {
-    // Rule 1: Must be locked
+    // Rule 1: Legacy publish evidence requires Studio approval.
     if (!card.status || !['locked', 'tested', 'published'].includes(card.status)) {
-      issues.push(`${card.type} "${card.id}" is not locked. Human Lock required before publish.`);
+      issues.push(`${card.type} "${card.id}" is not approved for legacy publish evidence.`);
       continue;
     }
-    // Rule 2: Must have human_lock record
+    // Rule 2: Legacy publish evidence requires a human_lock record.
     if (!card.human_lock || !card.human_lock.by || !card.human_lock.statement) {
       issues.push(`${card.type} "${card.id}" is locked but has no valid Human Lock record.`);
       continue;
     }
-    // Rule 3: Lock must confirm judgment fields were reviewed
+    // Rule 3: Legacy Human Lock evidence must confirm judgment fields were reviewed.
     const checked = card.human_lock.checked || {};
     if (!checked.applies_when) {
       issues.push(
@@ -218,32 +218,35 @@ function cmdPublishCheck(domainPath, args = []) {
   console.log('═'.repeat(60));
   console.log('');
 
-  // ─── Human Lock Gate (must pass before any other checks) ──────────
+  // ─── Legacy Human Lock evidence gate ──────────────────────────────
   const hl = checkHumanLock(abs);
   if (!hl.passed) {
     if (args.includes('--force')) {
-      console.warn('  ⚠  Human Lock Gate: OVERRIDDEN (--force). Proceeding with checks.');
-      console.warn(`     ${hl.issues.length} unresolved Human Lock issue(s):`);
+      console.warn('  ⚠  Legacy publish evidence gate: OVERRIDDEN (--force). Proceeding with checks.');
+      console.warn(`     ${hl.issues.length} unresolved publish-evidence issue(s):`);
       for (const issue of hl.issues) {
         console.warn(`       ${issue}`);
       }
       console.warn('');
     } else {
-      console.error('  Human Lock Gate: BLOCKED');
+      console.error('  Legacy publish evidence gate: BLOCKED');
       console.error(`  ${hl.issues.length} issue(s) found:`);
       for (const issue of hl.issues) {
         console.error(`    ✗ ${issue}`);
       }
       console.error('');
-      console.error('  Judgment-class cards (axiom, boundary, risk, aesthetic)');
-      console.error('  must be locked with a valid Human Lock record before publishing.');
-      console.error('  Use kdna-studio or manually add human_lock to each card.');
+      console.error('  This legacy publish check expects reviewed judgment-class cards');
+      console.error('  with Human Lock records as release evidence. This is not a');
+      console.error('  KDNA Core v1 format-validity requirement.');
+      console.error('  For current public consumption, export a .kdna file and run:');
+      console.error('    kdna validate <file.kdna>');
+      console.error('    kdna plan-load <file.kdna>');
       console.error('  Use --force for emergency override (audited).');
       console.error('');
       process.exit(EXIT.HUMAN_LOCK_REQUIRED);
     }
   } else {
-    console.log('  ✓ Human Lock Gate: passed');
+    console.log('  ✓ Legacy publish evidence gate: passed');
     console.log('');
   }
 
@@ -607,15 +610,15 @@ function publicKeyToScopeFormat(publicKeyPem) {
  * kdna publish <file.kdna> — Publish an existing Studio-compiled asset.
  *
  * Publishing no longer packs arbitrary source directories. Source directories
- * are non-canonical dev workspaces; trusted assets come from Studio-compatible
- * compile/export pipelines.
+ * are non-canonical dev workspaces; release-evidence assets come from
+ * Studio-compatible compile/export pipelines.
  */
 function cmdPublish(assetPath, args = []) {
   const abs = path.resolve(assetPath);
   if (!fs.existsSync(abs)) error(`Path not found: ${abs}`, EXIT.INPUT_ERROR);
   if (fs.statSync(abs).isDirectory()) {
     error(
-      'kdna publish only accepts existing .kdna assets. Source directories are non-canonical; use KDNA Studio compile/export, then run kdna publish <file.kdna>.',
+      'kdna publish only accepts existing .kdna assets. Source directories are non-canonical; use KDNA Studio compile/export, then run kdna publish <file.kdna> for legacy publish compatibility.',
       EXIT.INPUT_ERROR,
     );
   }
@@ -728,28 +731,28 @@ function validateAuthoringProvenance(manifest) {
       );
     }
     if (!conformance || !conformance.spec_version) {
-      issues.push('trusted assets require authoring.conformance.spec_version');
+      issues.push('release-evidence assets require authoring.conformance.spec_version');
     }
   }
-  if (highTrust && !authoring.compiler) issues.push('trusted assets require authoring.compiler');
+  if (highTrust && !authoring.compiler) issues.push('release-evidence assets require authoring.compiler');
   if (highTrust && !authoring.compiler_version) {
-    issues.push('trusted assets require authoring.compiler_version');
+    issues.push('release-evidence assets require authoring.compiler_version');
   }
   if (highTrust && !authoring.compiled_at)
-    issues.push('trusted assets require authoring.compiled_at');
+    issues.push('release-evidence assets require authoring.compiled_at');
   for (const field of ['asset_uid', 'project_uid', 'build_id', 'domain_id', 'content_digest']) {
     if (highTrust && !authoring[field] && !manifest[field]) {
-      issues.push(`trusted assets require ${field} in authoring provenance or manifest`);
+      issues.push(`release-evidence assets require ${field} in authoring provenance or manifest`);
     }
   }
   if (highTrust && authoring.human_confirmed !== true) {
-    issues.push('trusted assets require authoring.human_confirmed = true');
+    issues.push('release-evidence assets require authoring.human_confirmed = true');
   }
   if (highTrust && !Number.isInteger(authoring.human_lock_count)) {
-    issues.push('trusted assets require authoring.human_lock_count');
+    issues.push('release-evidence assets require authoring.human_lock_count');
   }
   if (highTrust && Number.isInteger(authoring.human_lock_count) && authoring.human_lock_count < 1) {
-    issues.push('trusted assets require at least one Human Lock');
+    issues.push('release-evidence assets require at least one Human Lock when that claim is made');
   }
   return issues;
 }