@aikdna/kdna-studio-cli 0.5.3 → 0.5.4

package/README.md

@@ -45,12 +45,14 @@ kdna-studio candidate accept my_domain <candidate-id>
 kdna-studio candidate promote my_domain
 kdna-studio card add my_domain axiom \
   --field one_sentence="Prefer specific evidence over broad claims" \
+  --field full_statement="When reviewing content, prefer specific evidence over broad claims because unsupported generalizations make the judgment impossible to verify or improve." \
+  --field why="Broad claims hide the actual reason for a judgment, so reviewers cannot tell whether the conclusion is evidence based, reusable, or merely plausible sounding." \
   --field applies_when='["reviewing content"]' \
   --field does_not_apply_when='["pure formatting"]' \
   --field failure_risk="generic advice"
-kdna-studio card approve my_domain <card-id> --by expert --statement "I confirm this judgment."
+kdna-studio card approve my_domain --all --by expert --statement "I confirm this judgment."
 kdna-studio lock my_domain
-kdna-studio export my_domain --out dist/my_domain.kdna --sign
+kdna-studio export my_domain --format v1 --out dist/my_domain.kdna
 ```
 
 Candidate promotion is scope-gated: only candidates with `status == accepted` and `scope_fit == true` are promoted to cards by default. Use `kdna-studio candidate override <project> <candidate-id>` only when a human intentionally overrides the scope gate.
@@ -58,14 +60,35 @@ Candidate promotion is scope-gated: only candidates with `status == accepted` an
 After export, use the runtime CLI:
 
 ```bash
-kdna validate dist/my_domain.kdna
+kdna validate dist/my_domain.kdna --runtime
+kdna plan-load dist/my_domain.kdna --json
 kdna load dist/my_domain.kdna --profile=compact --as=prompt
 ```
 
 `kdna-studio` is the CLI entry for confirmed KDNA authoring. `kdna` is the
 runtime control plane for inspecting, validating, packing, unpacking, and
-loading existing `.kdna` assets. Signature, encryption, registry publishing,
-and private assets are future/gated phases, not the current Core v1 baseline.
+loading existing `.kdna` assets.
+
+## Runtime Export Contract
+
+`kdna-studio export --format v1` is the canonical runtime export path. It uses
+`@aikdna/kdna-studio-core` to compile the Studio project into a KDNA Core v1
+runtime asset and then packs it with `@aikdna/kdna-core`.
+
+A v1 runtime export contains only these top-level entries:
+
+- `mimetype`
+- `kdna.json`
+- `payload.kdnab`
+- `checksums.json`
+
+Authoring/source entries such as `KDNA_Core.json`, `KDNA_Patterns.json`, and
+`source_cards` are not runtime distribution entries. They may exist in Studio
+compile output or legacy imports, but they must not be emitted by the runtime
+export path.
+
+Signature, encryption, registry publishing, paid distribution, and private
+assets are future/gated phases, not the current Core v1 baseline.
 
 ## Identity
 

package/bin/kdna-studio.js

@@ -6,6 +6,16 @@ const crypto = require('crypto');
 const zlib = require('zlib');
 const cbor = require('cbor-x');
 
+function loadStudioCore() {
+  const publishedCore = require('@aikdna/kdna-studio-core');
+  if (publishedCore.exportRuntime) return publishedCore;
+  try {
+    return require('../../kdna-studio-core/src');
+  } catch (_) {
+    return publishedCore;
+  }
+}
+
 const {
   project: projectApi,
   cards: cardApi,
@@ -14,8 +24,8 @@ const {
   quality,
   creator: creatorApi,
   distillation: distillationApi,
-} = require('@aikdna/kdna-studio-core');
-const { buildChecksumsV1 } = require('@aikdna/kdna-core/v1');
+  exportRuntime,
+} = loadStudioCore();
 
 const llm = require('../src/llm');
 const ai = require('../src/ai');
@@ -152,12 +162,6 @@ function parseFields(args) {
   return fields;
 }
 
-function arrayValue(value) {
-  if (Array.isArray(value)) return value;
-  if (value === undefined || value === null || value === '') return [];
-  return [value];
-}
-
 function semverValue(value, fallback = '1.0.0') {
   const raw = String(value || '').trim();
   if (/^[0-9]+\.[0-9]+\.[0-9]+([+-].+)?$/.test(raw)) return raw;
@@ -208,10 +212,6 @@ function publicManifestMetadata(raw = {}) {
   return copy;
 }
 
-function cardPayload(card) {
-  return { id: card.id, ...(card.fields || {}) };
-}
-
 function cleanFields(fields = {}) {
   const cleaned = {};
   for (const [key, value] of Object.entries(fields || {})) {
@@ -381,116 +381,6 @@ function cardsFromPayload(payload) {
   return [];
 }
 
-function buildV1Payload(project) {
-  const locked = (project.cards || []).filter((c) => c.locked);
-  const byType = (type) => locked.filter((c) => c.type === type);
-  const source = project.source_manifest || {};
-
-  const axioms = byType('axiom').map((c) => ({
-    id: c.id,
-    one_sentence: c.fields?.one_sentence || '',
-    full_statement: c.fields?.full_statement || '',
-    why: c.fields?.why || '',
-    applies_when: arrayValue(c.fields?.applies_when),
-    does_not_apply_when: arrayValue(c.fields?.does_not_apply_when),
-    failure_risk: c.fields?.failure_risk || '',
-    status: c.status || null,
-    human_lock: c.human_lock || null,
-  }));
-
-  const boundaries = [
-    ...byType('boundary').map((c) => ({ type: 'explicit_boundary', ...cardPayload(c) })),
-    ...byType('axiom').map((c) => ({
-      id: `${c.id}_applicability`,
-      type: 'axiom_applicability',
-      axiom_id: c.id,
-      one_sentence: c.fields?.one_sentence || '',
-      applies_when: arrayValue(c.fields?.applies_when),
-      does_not_apply_when: arrayValue(c.fields?.does_not_apply_when),
-      failure_risk: c.fields?.failure_risk || '',
-    })),
-    ...byType('ontology')
-      .filter((c) => c.fields?.boundary || c.fields?.applies_when || c.fields?.does_not_apply_when)
-      .map((c) => ({
-        id: `${c.id}_boundary`,
-        type: 'ontology_boundary',
-        concept_id: c.id,
-        one_sentence: c.fields?.one_sentence || '',
-        boundary: c.fields?.boundary || '',
-        applies_when: arrayValue(c.fields?.applies_when),
-        does_not_apply_when: arrayValue(c.fields?.does_not_apply_when),
-        trigger_signal: c.fields?.trigger_signal || '',
-      })),
-    ...byType('stance')
-      .filter((c) => c.fields?.applies_when || c.fields?.does_not_apply_when)
-      .map((c) => ({
-        id: `${c.id}_boundary`,
-        type: 'stance_boundary',
-        stance_id: c.id,
-        stance: c.fields?.stance || c.fields?.statement || c.fields?.one_sentence || '',
-        applies_when: arrayValue(c.fields?.applies_when),
-        does_not_apply_when: arrayValue(c.fields?.does_not_apply_when),
-      })),
-  ];
-
-  const patterns = [
-    ...byType('ontology').map((c) => ({ type: 'ontology', ...cardPayload(c) })),
-    ...byType('misunderstanding').map((c) => ({ type: 'misunderstanding', ...cardPayload(c) })),
-    ...byType('term').map((c) => ({ type: 'term', ...cardPayload(c) })),
-    ...byType('banned_term').map((c) => ({ type: 'banned_term', ...cardPayload(c) })),
-    ...byType('framework').map((c) => ({ type: 'framework', ...cardPayload(c) })),
-    ...byType('stance').map((c) => ({ type: 'stance', ...cardPayload(c) })),
-  ];
-
-  const failureModes = byType('misunderstanding').map((c) => ({
-    id: c.id,
-    mode: c.fields?.wrong || c.fields?.key_distinction || c.id,
-    correct: c.fields?.correct || '',
-    key_distinction: c.fields?.key_distinction || '',
-    why: c.fields?.why || '',
-  }));
-
-  return {
-    profile: 'judgment-profile-v1',
-    core: {
-      highest_question: source.core_insight || project.release?.description || '',
-      axioms,
-      boundaries,
-      risk_model: {
-        risks: byType('risk').map((c) => cardPayload(c)),
-        source_risk_level: source.risk_level || null,
-        fitness_for_purpose: source.fitness_for_purpose || null,
-      },
-    },
-    patterns,
-    scenarios: byType('scenario').map((c) => cardPayload(c)),
-    cases: byType('case').map((c) => cardPayload(c)),
-    reasoning: {
-      self_checks: byType('self_check').map((c) => c.fields?.question || c.fields?.one_sentence || c.id),
-      failure_modes: failureModes,
-      reasoning_chains: byType('reasoning').map((c) => cardPayload(c)),
-    },
-    evolution: {
-      stages: byType('evolution_stage').map((c) => cardPayload(c)),
-      changelog: locked.map((c) => ({
-        id: `locked_${c.id}`,
-        card_id: c.id,
-        type: c.type,
-        event: 'locked',
-        at: c.human_lock?.at || null,
-      })),
-      version_notes: source.judgment_version ? [`Migrated from source judgment_version ${source.judgment_version}`] : [],
-    },
-    source_cards: locked.map((c) => ({
-      id: c.id,
-      type: c.type,
-      status: c.status,
-      fields: c.fields || {},
-      human_lock: c.human_lock || null,
-    })),
-  };
-}
-
 function buildV1Manifest(project, name) {
   const source = project.source_manifest || {};
   const assetId = assetIdFromName(name || source.name || project.name);
@@ -1044,10 +934,10 @@ function cmdCard(args) {
   }
   if (sub === 'approve') {
     const projectInput = args[1];
-    const cardId = args[2];
     const approveAll = args.includes('--all');
+    const cardId = approveAll ? null : args[2];
     if (!projectInput || (!cardId && !approveAll)) {
-      fail('Usage: kdna-studio card approve <project> <card-id> --by <id> --statement <text> [--sign]');
+      fail('Usage: kdna-studio card approve <project> <card-id|--all> --by <id> --statement <text> [--sign]');
     }
     const by = option(args, '--by');
     const statement = option(args, '--statement');
@@ -1255,6 +1145,9 @@ function exportProjectV1(project, name, outPath) {
   try { core = require('@aikdna/kdna-core'); } catch (e) {
     fail('@aikdna/kdna-core@0.11.0+ is required for v1 export.', 2);
   }
+  if (!exportRuntime || typeof exportRuntime.exportRuntimeAsset !== 'function') {
+    fail('@aikdna/kdna-studio-core with exportRuntime.exportRuntimeAsset is required for v1 export.', 2);
+  }
   const gate = projectApi.checkHumanLockGate(project);
   if (gate.blocked) {
     const reasons = gate.issues.map((i) => `${i.cardId}: ${i.reason}`).join('\n  - ');
@@ -1263,10 +1156,16 @@ function exportProjectV1(project, name, outPath) {
   const lockedCards = (project.cards || []).filter(c => c.locked);
   const v1Dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kdna-v1-'));
   try {
-    fs.writeFileSync(path.join(v1Dir, 'mimetype'), 'application/vnd.kdna.asset');
-    fs.writeFileSync(path.join(v1Dir, 'kdna.json'), JSON.stringify(buildV1Manifest(project, name), null, 2));
-    fs.writeFileSync(path.join(v1Dir, 'payload.kdnab'), JSON.stringify(buildV1Payload(project), null, 2));
-    fs.writeFileSync(path.join(v1Dir, 'checksums.json'), JSON.stringify(buildChecksumsV1(v1Dir), null, 2));
+    const manifestDefaults = buildV1Manifest(project, name);
+    const runtimeAsset = exportRuntime.exportRuntimeAsset(project, {
+      asset_id: manifestDefaults.asset_id,
+      asset_uid: manifestDefaults.asset_uid,
+      title: manifestDefaults.title,
+      created_at: manifestDefaults.created_at,
+      updated_at: manifestDefaults.updated_at,
+      access: project.release?.access || project.source_manifest?.access || 'public',
+    });
+    writeFiles(v1Dir, runtimeAsset.files);
     fs.mkdirSync(path.dirname(outPath), { recursive: true });
     core.pack(v1Dir, outPath);
     const vr = core.validate(outPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/kdna-studio-cli",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Official KDNA Studio command-line authoring entry for creating, locking, compiling, and exporting .kdna judgment assets through the KDNA toolchain.",
   "type": "commonjs",
   "bin": {

package/tests/cli.test.js

@@ -27,6 +27,15 @@ function tmpDir() {
   return fs.mkdtempSync(path.join(os.tmpdir(), 'kdna-studio-cli-'));
 }
 
+function assertCanonicalRuntimeContainer(outFile) {
+  const layout = kdnaCore.readV1Layout(outFile);
+  const names = (layout.entries || []).map((entry) => entry.name).sort();
+  assert.deepEqual(names, ['checksums.json', 'kdna.json', 'mimetype', 'payload.kdnab']);
+  assert.equal(names.includes('KDNA_Core.json'), false);
+  assert.equal(names.includes('KDNA_Patterns.json'), false);
+  return layout;
+}
+
 function createLockedProject(t) {
   const tmp = tmpDir();
   t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
@@ -89,6 +98,53 @@ test('rejects unknown commands with input error', () => {
   assert.match(result.stderr, /Unknown command/);
 });
 
+test('card approve --all locks every unlocked card', (t) => {
+  const tmp = tmpDir();
+  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
+  const projectDir = path.join(tmp, 'project');
+
+  let result = run(['create', projectDir, '--name', '@test/approve-all'], { tmp });
+  assert.equal(result.status, 0, result.stderr);
+
+  result = run([
+    'card',
+    'add',
+    projectDir,
+    'axiom',
+    '--field',
+    'one_sentence=Prefer specific evidence over broad claims',
+    '--field',
+    'full_statement=When evaluating a claim the agent must weigh the specificity of the supporting evidence. A narrow claim backed by concrete data should be preferred over a broad claim supported only by general principles.',
+    '--field',
+    'why=Without this axiom the agent may accept broad plausible-sounding claims as equally credible as narrow evidence-backed ones leading to false balance.',
+    '--field',
+    'applies_when=["reviewing content"]',
+    '--field',
+    'does_not_apply_when=["pure formatting"]',
+    '--field',
+    'failure_risk=generic advice',
+  ], { tmp });
+  assert.equal(result.status, 0, result.stderr);
+
+  result = run([
+    'card',
+    'approve',
+    projectDir,
+    '--all',
+    '--by',
+    'expert',
+    '--statement',
+    'I confirm every unlocked card in this project.',
+  ], { tmp });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Approved and Human Locked: 1 cards/);
+
+  const project = JSON.parse(fs.readFileSync(path.join(projectDir, 'studio.project.json'), 'utf8'));
+  assert.equal(project.cards.length, 1);
+  assert.equal(project.cards[0].locked, true);
+  assert.ok(project.cards[0].human_lock);
+});
+
 test('creates a Studio project and rejects accidental overwrite', (t) => {
   const tmp = tmpDir();
   t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
@@ -309,7 +365,7 @@ test('create --from-folder imports legacy JSON source, outputs audit', (t) => {
   assert.equal(project.lineage.type, 'migrated');
 });
 
-test('migrate --format v1 maps scoped name, writes checksums, and preserves source cards', (t) => {
+test('migrate --format v1 exports canonical runtime payload without source entries', (t) => {
   assert.ok(kdnaCore, '@aikdna/kdna-core is required for v1 export verification');
   const tmp = tmpDir();
   t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
@@ -374,25 +430,22 @@ test('migrate --format v1 maps scoped name, writes checksums, and preserves sour
   const inspected = kdnaCore.inspect(outFile);
   assert.equal(inspected.asset_id, 'kdna:test:legacy-import');
   assert.equal(inspected.checksums_present, true);
+  const layout = assertCanonicalRuntimeContainer(outFile);
+  assert.equal(layout.manifest.lineage.type, 'adaptation');
+  assert.equal(layout.manifest.lineage.source_lineage_type, 'migrated');
 
   const full = kdnaCore.loadV1(outFile, { profile: 'full', as: 'json' }).content;
   assert.equal(full.manifest.creator.name, 'Test Author');
   assert.equal(full.manifest.version, '0.7.3');
   assert.equal(full.manifest.judgment_version, '2026.05.0');
+  assert.equal(full.payload.profile, 'judgment-profile-v1');
   assert.equal(full.payload.core.axioms.length, 1);
-  assert.equal(full.payload.core.boundaries.length, 3);
-  assert.ok(full.payload.core.boundaries.some((b) => b.type === 'axiom_applicability'));
-  assert.ok(full.payload.core.boundaries.some((b) => b.type === 'ontology_boundary'));
-  assert.ok(full.payload.core.boundaries.some((b) => b.type === 'stance_boundary'));
-  assert.equal(full.payload.patterns.filter((p) => p.type === 'term').length, 1);
-  assert.equal(full.payload.patterns.filter((p) => p.type === 'banned_term').length, 1);
   assert.equal(full.payload.scenarios.length, 1);
   assert.equal(full.payload.cases.length, 1);
   assert.equal(full.payload.reasoning.self_checks.length, 1);
   assert.equal(full.payload.reasoning.failure_modes.length, 1);
-  assert.equal(full.payload.reasoning.reasoning_chains.length, 1);
-  assert.equal(full.payload.evolution.stages.length, 1);
-  assert.equal(full.payload.source_cards.length, 12);
+  assert.ok(full.payload.evolution.stages.length >= 1);
+  assert.equal(Object.hasOwn(full.payload, 'source_cards'), false);
   assert.equal(JSON.stringify(full).includes('quality_badge'), false);
   assert.equal(JSON.stringify(full).includes('registry'), false);
 });
@@ -408,10 +461,12 @@ test('export --format v1 exports a Studio project as a valid non-empty v1 asset'
 
   const validation = kdnaCore.validate(outFile);
   assert.equal(validation.overall_valid, true, JSON.stringify(validation.problems));
+  assertCanonicalRuntimeContainer(outFile);
   const loaded = kdnaCore.loadV1(outFile, { profile: 'full', as: 'json' }).content;
   assert.equal(loaded.payload.core.axioms.length, 1);
-  assert.equal(loaded.payload.source_cards.length, 1);
-  assert.ok(loaded.payload.core.boundaries.some((b) => b.type === 'axiom_applicability'));
+  assert.equal(Object.hasOwn(loaded.payload, 'source_cards'), false);
+  assert.equal(loaded.manifest.payload.path, 'payload.kdnab');
+  assert.equal(loaded.manifest.payload.encrypted, false);
 });
 
 test('migrate --format v1 accepts an existing Studio project without dropping cards', (t) => {
@@ -431,9 +486,10 @@ test('migrate --format v1 accepts an existing Studio project without dropping ca
 
   const validation = kdnaCore.validate(outFile);
   assert.equal(validation.overall_valid, true, JSON.stringify(validation.problems));
+  assertCanonicalRuntimeContainer(outFile);
   const loaded = kdnaCore.loadV1(outFile, { profile: 'full', as: 'json' }).content;
   assert.equal(loaded.payload.core.axioms.length, 1);
-  assert.equal(loaded.payload.source_cards.length, 1);
+  assert.equal(Object.hasOwn(loaded.payload, 'source_cards'), false);
 });
 
 // ── Create from KDNA ────────────────────────────────────────────────