@aikdna/kdna-studio-cli 0.5.2 → 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,12 +60,35 @@ Candidate promotion is scope-gated: only candidates with `status == accepted` an
 After export, use the runtime CLI:
 
 ```bash
-kdna verify dist/my_domain.kdna --judgment
-kdna publish 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 trusted KDNA creation. `kdna` is the runtime
-control plane for existing `.kdna` assets.
+`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.
+
+## 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
 
@@ -85,6 +110,6 @@ kdna-studio create migrated --from-folder ./old-domain-json --name @scope/migrat
 ## Related
 
 - [KDNA Core](https://github.com/aikdna/kdna) — Official format specification
-- [kdna-cli](https://github.com/aikdna/kdna-cli) — runtime CLI for verify, install, load, publish
+- [kdna-cli](https://github.com/aikdna/kdna-cli) — runtime CLI for inspect, validate, pack, unpack, and load
 - [kdna-studio-core](https://github.com/aikdna/kdna-studio-core) — authoring SDK used by this CLI
 - [kdna-studio-swift](https://github.com/aikdna/kdna-studio-swift) — native Swift counterpart

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');
@@ -39,7 +49,7 @@ Create (three entry paths):
   kdna-studio create <project-dir> --from-folder <source-dir> --name <@scope/name>
 
 Migrate (dev source → trusted .kdna in one command):
-  kdna-studio migrate <source-dir> --out <file.kdna> --name <@scope/name> --by <id> --statement <text> [--sign]
+  kdna-studio migrate <source-dir|project> --format v1 --out <file.kdna> --name <@scope/name> --by <id> --statement <text> [--sign]
 
 Authoring:
   kdna-studio import <project> <source-file-or-dir>               # import evidence (txt/md/json/yaml/csv/log/srt/vtt/html)
@@ -50,7 +60,8 @@ Authoring:
   kdna-studio card approve <project> <card-id> --by <id> --statement <text> [--sign] [--passphrase <pass>]
   kdna-studio lock <project>
   kdna-studio compile <project> --out <dir>
-  kdna-studio export <project> --out <file.kdna> [--sign]
+  kdna-studio export <project> --format v1 --out <file.kdna>
+  kdna-studio export <project> --out <file.kdna> [--sign]                  # legacy v2
 
 AI Authoring (requires LLM config: kdna-studio llm config):
   kdna-studio distill <project> --ai                             # AI-driven candidate extraction from evidence
@@ -151,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;
@@ -207,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 || {})) {
@@ -380,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);
@@ -1043,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');
@@ -1125,16 +1016,33 @@ function cmdMigrate(args) {
   const out = option(args, '--out');
   const by = option(args, '--by');
   const statement = option(args, '--statement');
-  const name = option(args, '--name') || path.basename(path.resolve(sourceDir || '.'));
+  const requestedName = option(args, '--name');
+  let name = requestedName || path.basename(path.resolve(sourceDir || '.'));
   if (!sourceDir || !out || !by || !statement) {
     fail('Usage: kdna-studio migrate <source-dir> --out <file.kdna> --name <@scope/name> --by <id> --statement <text> [--sign] [--passphrase <pass>]');
   }
 
-  // Step 1: create temp project and import everything from dev source
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kdna-migrate-'));
+  const sourcePath = path.resolve(sourceDir);
+  const format = option(args, '--format');
+  const isStudioProject = fs.existsSync(path.join(sourcePath, 'studio.project.json'));
+  let tmpDir = null;
+  let projectPath = null;
+  let project = null;
+
+  // Step 1: import dev source, or use an existing Studio project directly.
   let creatorIdentity = null;
   try { creatorIdentity = creatorApi.loadIdentity(); } catch { /* proceed without */ }
-  const { project } = importFromFolder(sourceDir, tmpDir, name, creatorIdentity);
+  if (format === 'v1' && isStudioProject) {
+    const loaded = readProject(sourcePath);
+    project = loaded.project;
+    projectPath = loaded.projectPath;
+    if (!requestedName && project.name) name = project.name;
+  } else {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kdna-migrate-'));
+    const imported = importFromFolder(sourceDir, tmpDir, name, creatorIdentity);
+    project = imported.project;
+    projectPath = path.join(tmpDir, 'studio.project.json');
+  }
 
   // Reject if critical judgment fields are missing from axioms
   const criticalMissing = [];
@@ -1188,7 +1096,7 @@ function cmdMigrate(args) {
     project.stages.judgment_cards.locked = locked;
     project.stages.judgment_cards.total = project.cards.length;
   }
-  writeProject(path.join(tmpDir, 'studio.project.json'), project);
+  writeProject(projectPath, project);
   console.log(`Approved and Human Locked: ${locked} cards`);
 
   // Step 3: verify Human Lock gate
@@ -1200,24 +1108,11 @@ function cmdMigrate(args) {
 
   const absOut = path.resolve(out);
   // Step 4: v1 export or v2 compile + export
-  if (args.includes('--format') && option(args, '--format') === 'v1') {
-    let core;
-    try { core = require('@aikdna/kdna-core'); } catch (e) {
-      fail('@aikdna/kdna-core@0.11.0+ is required for v1 export.', 2);
+  if (format === 'v1') {
+    exportProjectV1(project, name, absOut);
+    if (tmpDir) {
+      try { fs.rmSync(tmpDir, { recursive: true }); } catch { /* cleanup */ }
     }
-    const lockedCards = (project.cards || []).filter(c => c.locked);
-    const v1Dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kdna-v1-'));
-    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));
-    core.pack(v1Dir, absOut);
-    const vr = core.validate(absOut);
-    if (!vr.overall_valid) fail('v1 export validation failed: ' + (vr.problems || []).join('; '));
-    console.log('Exported (v1): ' + absOut);
-    console.log('  Name: ' + name + '  Cards: ' + lockedCards.length + '  Validated: all gates pass');
-    try { fs.rmSync(v1Dir, { recursive: true }); } catch { /* cleanup */ }
-    try { fs.rmSync(tmpDir, { recursive: true }); } catch { /* cleanup */ }
     return;
   }
   const { result } = compileProject(tmpDir);
@@ -1240,7 +1135,46 @@ function cmdMigrate(args) {
   console.log(`  Build ID: ${result.identity.build_id}`);
 
   // Cleanup temp
-  try { fs.rmSync(tmpDir, { recursive: true }); } catch { /* best effort */ }
+  if (tmpDir) {
+    try { fs.rmSync(tmpDir, { recursive: true }); } catch { /* best effort */ }
+  }
+}
+
+function exportProjectV1(project, name, outPath) {
+  let core;
+  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  - ');
+    fail(`Human Lock Gate blocked v1 export:\n  - ${reasons}`, EXIT.HUMAN_LOCK_REQUIRED);
+  }
+  const lockedCards = (project.cards || []).filter(c => c.locked);
+  const v1Dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kdna-v1-'));
+  try {
+    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);
+    if (!vr.overall_valid) fail('v1 export validation failed: ' + (vr.problems || []).join('; '));
+    console.log('Exported (v1): ' + outPath);
+    console.log('  Name: ' + name + '  Cards: ' + lockedCards.length + '  Validated: all gates pass');
+  } finally {
+    try { fs.rmSync(v1Dir, { recursive: true }); } catch { /* cleanup */ }
+  }
 }
 
 function compileProject(projectInput) {
@@ -1417,7 +1351,12 @@ function applySignature(files, passphrase = null) {
 function cmdExport(args) {
   const projectInput = args[0];
   const out = option(args, '--out');
-  if (!projectInput || !out) fail('Usage: kdna-studio export <project> --out <file.kdna> [--sign]');
+  if (!projectInput || !out) fail('Usage: kdna-studio export <project> --out <file.kdna> [--format v1] [--sign]');
+  if (option(args, '--format') === 'v1') {
+    const { project } = readProject(projectInput);
+    exportProjectV1(project, option(args, '--name') || project.name, path.resolve(out));
+    return;
+  }
   const { project, result } = compileProject(projectInput);
   const files = { ...result.files };
   files['README.md'] = compileApi.generateReadme(project);
@@ -1843,6 +1782,10 @@ if (!cmd || cmd === '--help' || cmd === '-h') {
   usage();
   process.exit(EXIT.OK);
 }
+if (cmd === '--version' || cmd === '-v') {
+  console.log(require('../package.json').version);
+  process.exit(EXIT.OK);
+}
 
 (async () => {
 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/kdna-studio-cli",
-  "version": "0.5.2",
+  "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,29 +430,68 @@ 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);
 });
 
+test('export --format v1 exports a Studio project as a valid non-empty v1 asset', (t) => {
+  assert.ok(kdnaCore, '@aikdna/kdna-core is required for v1 export verification');
+  const { tmp, projectDir } = createLockedProject(t);
+  const outFile = path.join(tmp, 'project-v1.kdna');
+
+  const result = run(['export', projectDir, '--format', 'v1', '--out', outFile], { tmp });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Exported \(v1\)/);
+
+  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(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) => {
+  assert.ok(kdnaCore, '@aikdna/kdna-core is required for v1 export verification');
+  const { tmp, projectDir } = createLockedProject(t);
+  const outFile = path.join(tmp, 'project-migrated-v1.kdna');
+
+  const result = run([
+    'migrate', projectDir,
+    '--format', 'v1',
+    '--out', outFile,
+    '--by', 'tester',
+    '--statement', 'I confirm this project v1 migration.',
+  ], { tmp });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Cards: 1/);
+
+  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(Object.hasOwn(loaded.payload, 'source_cards'), false);
+});
+
 // ── Create from KDNA ────────────────────────────────────────────────
 
 test('create --from-kdna forks an existing .kdna asset', (t) => {