@aikdna/kdna-studio-cli 0.6.5 → 0.7.0

package/README.md

@@ -56,7 +56,7 @@ 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.
 
 The current Studio CLI export workflow uses approved cards as release evidence.
-This is Studio project policy, not a KDNA Core v1 format-validity rule. Human
+This is Studio project policy, not a Core GA format-validity rule. Human
 Lock and other provenance records are optional review evidence, not validity
 requirements.
 
@@ -75,10 +75,10 @@ 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
+`@aikdna/kdna-studio-core` to compile the Studio project into a Core GA
 runtime asset and then packs it with `@aikdna/kdna-core`.
 
-A v1 runtime export contains only these top-level entries:
+A Core GA runtime export contains only these top-level entries:
 
 - `mimetype`
 - `kdna.json`

package/bin/kdna-studio.js

@@ -5,6 +5,7 @@ const path = require('path');
 const crypto = require('crypto');
 const zlib = require('zlib');
 const cbor = require('cbor-x');
+const { execFileSync } = require('child_process');
 
 function loadStudioCore() {
   const publishedCore = require('@aikdna/kdna-studio-core');
@@ -36,7 +37,7 @@ function usage() {
   console.log(`kdna-studio — Studio-compatible KDNA authoring CLI
 
 LLM (AI-powered authoring):
-  kdna-studio llm config [--provider <name>] [--model <name>] [--key <api-key>] [--url <base-url>]
+  kdna-studio llm config [--provider <name>] [--model <name>] [--key-pipe] [--url <base-url>]
   kdna-studio llm show
 
 Identity:
@@ -54,7 +55,7 @@ Migrate (dev source or Studio project → canonical .kdna in one command):
 Authoring:
   kdna-studio import <project> <source-file-or-dir>               # import evidence (txt/md/json/yaml/csv/log/srt/vtt/html)
   kdna-studio filter <project>                                    # check evidence for sensitive content
-  kdna-studio source classify <project>                            # classify evidence against declared target
+  kdna-studio source <project>                                    # classify imported evidence against declared target
   kdna-studio card list <project>
   kdna-studio card add <project> <type> --field key=value [--field key=value] [--template <name>] [--no-strict]
   kdna-studio card update <project> <card-id> --field key=value
@@ -98,6 +99,34 @@ function option(args, name, fallback = null) {
   return value;
 }
 
+function resolveApiKey(args) {
+  // 1. KDNA_API_KEY environment variable (preferred)
+  if (process.env.KDNA_API_KEY) return process.env.KDNA_API_KEY;
+
+  // 2. Read from stdin via --key-pipe flag
+  if (args.includes('--key-pipe')) {
+    if (process.stdin.isTTY) {
+      console.error('Error: --key-pipe requires stdin to be piped. Example: echo $KDNA_API_KEY | kdna-studio llm config --key-pipe');
+      return null;
+    }
+    try {
+      return fs.readFileSync(0, 'utf8').trim();
+    } catch (e) {
+      console.error('Error reading API key from stdin:', e.message);
+      return null;
+    }
+  }
+
+  // 3. Deprecated --key / -k flag (backward compat)
+  const key = option(args, '--key', null) || option(args, '-k', null);
+  if (key) {
+    console.error('Warning: --key is deprecated and exposes secrets in shell history and ps output. Use KDNA_API_KEY env var or pipe via stdin (--key-pipe).');
+    return key;
+  }
+
+  return null;
+}
+
 function optionsAll(args, name) {
   const values = [];
   for (let i = 0; i < args.length; i++) {
@@ -520,6 +549,10 @@ function importFromKdna(kdnaPath) {
   if (!fs.existsSync(absKdna)) fail(`KDNA asset not found: ${absKdna}`);
   if (!absKdna.endsWith('.kdna')) fail('--from-kdna requires a .kdna file');
 
+  const stats = fs.statSync(absKdna);
+  if (stats.size > 50 * 1024 * 1024) {
+    fail(`KDNA file too large (${(stats.size / (1024 * 1024)).toFixed(1)} MiB, max 50 MiB): ${absKdna}`);
+  }
   const zipBuf = fs.readFileSync(absKdna);
   const entries = readZipEntries(zipBuf);
   if (!entries.has('kdna.json')) fail('Not a valid .kdna asset: missing kdna.json');
@@ -842,13 +875,60 @@ function cmdImport(args) {
   let imported = 0;
   let skipped = 0;
 
+  function extractBinaryText(filePath, ext) {
+    try {
+      if (ext === '.pdf') {
+        const result = execFileSync('pdftotext', ['-raw', filePath, '-'], {
+          encoding: 'utf8',
+          timeout: 30000,
+          maxBuffer: 5 * 1024 * 1024,
+        });
+        return { text: result, error: null };
+      }
+      if (ext === '.docx' || ext === '.rtf') {
+        const result = execFileSync('textutil', ['-convert', 'txt', '-stdout', filePath], {
+          encoding: 'utf8',
+          timeout: 30000,
+          maxBuffer: 5 * 1024 * 1024,
+        });
+        return { text: result, error: null };
+      }
+    } catch (e) {
+      // Tool not installed or extraction failed — report distinguishably
+      if (e.code === 'ENOENT') {
+        return { text: null, error: 'tool_missing' };
+      }
+      return { text: null, error: 'extraction_failed', detail: e.message };
+    }
+    return { text: null, error: 'unsupported_format' };
+  }
+
   function importFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     const name = path.basename(filePath);
 
     if (BINARY_EXTS.has(ext)) {
-      console.warn(`Skipping binary format (not yet supported in CLI): ${name}`);
-      skipped++;
+      const extracted = extractBinaryText(filePath, ext);
+      if (!extracted.text || extracted.text.trim().length === 0) {
+        const tool = ext === '.pdf' ? 'pdftotext (poppler-utils)' : 'textutil (macOS built-in)';
+        if (extracted.error === 'tool_missing') {
+          console.warn(`Skipping ${ext} file (${tool} not installed): ${name}`);
+        } else if (extracted.error === 'extraction_failed') {
+          console.warn(`Skipping ${ext} file (extraction failed: ${extracted.detail}): ${name}`);
+        } else {
+          console.warn(`Skipping ${ext} file (empty or unsupported): ${name}`);
+        }
+        skipped++;
+        return;
+      }
+      if (extracted.text.length > 120000) {
+        console.warn(`Extracted text too large (${extracted.text.length} chars, max 120000): ${name}`);
+        skipped++;
+        return;
+      }
+      const evidence = evidenceApi.createEvidenceEntry('text', name, extracted.text.substring(0, 120000), filePath);
+      evidenceApi.addEvidence(project, evidence);
+      imported++;
       return;
     }
 
@@ -865,13 +945,13 @@ function cmdImport(args) {
       return;
     }
     let content;
-    try { content = fs.readFileSync(filePath, 'utf8'); } catch { console.warn(`Cannot read: ${name}`); skipped++; return; }
-
-    if (content.length > 120000) {
-      console.warn(`File too large (${content.length} chars, max 120000): ${name}`);
-      skipped++;
-      return;
-    }
+    try {
+      const fd = fs.openSync(filePath, 'r');
+      const buf = Buffer.alloc(120000);
+      const bytesRead = fs.readSync(fd, buf, 0, 120000, 0);
+      fs.closeSync(fd);
+      content = buf.toString('utf8', 0, bytesRead);
+    } catch { console.warn(`Cannot read: ${name}`); skipped++; return; }
 
     const evidence = evidenceApi.createEvidenceEntry('text', name, content, filePath);
     evidenceApi.addEvidence(project, evidence);
@@ -997,6 +1077,16 @@ function cmdCard(args) {
       }
     }
 
+    // Warn: one_sentence is the compact profile display field
+    if (type === 'axiom') {
+      const oneSentence = fields.one_sentence;
+      if (!oneSentence || String(oneSentence).startsWith('<TBD')) {
+        console.warn('Warning: one_sentence is used by kdna load --profile=compact.');
+        console.warn('Without it, the compact output may show a placeholder or truncated full_statement.');
+        console.warn('Add --field one_sentence="..." for best results.\n');
+      }
+    }
+
     const card = cardApi.createCard(type, fields);
     project.cards.push(card);
     if (project.stages?.judgment_cards) {
@@ -1584,7 +1674,8 @@ function cmdStudioInstall(args) {
       stdio: 'inherit', encoding: 'utf8',
     });
     if (result.status !== 0) process.exit(result.status);
-  } catch {
+  } catch (e) {
+    console.error('Error spawning kdna CLI:', e.message);
     fail('kdna CLI not found. Install with: npm install -g @aikdna/kdna-cli');
   }
 }
@@ -1597,7 +1688,8 @@ function cmdStudioUpdate(args) {
       stdio: 'inherit', encoding: 'utf8',
     });
     if (result.status !== 0) process.exit(result.status);
-  } catch {
+  } catch (e) {
+    console.error('Error spawning kdna CLI:', e.message);
     fail('kdna CLI not found. Install with: npm install -g @aikdna/kdna-cli');
   }
 }
@@ -1615,14 +1707,14 @@ function cmdLlm(args) {
   if (sub === 'config') {
     const provider = option(args, '--provider') || option(args, '-p');
     const model = option(args, '--model') || option(args, '-m');
-    const apiKey = option(args, '--key') || option(args, '-k');
+    const apiKey = resolveApiKey(args);
     const baseURL = option(args, '--url') || option(args, '-u');
     const updates = {};
     if (provider) updates.provider = provider;
     if (model) updates.model = model;
     if (apiKey) updates.apiKey = apiKey;
     if (baseURL) updates.baseURL = baseURL;
-    if (Object.keys(updates).length === 0) fail('Usage: kdna-studio llm config --provider <name> [--model <name>] [--key <api-key>] [--url <base-url>]');
+    if (Object.keys(updates).length === 0) fail('Usage: kdna-studio llm config --provider <name> [--model <name>] [--key-pipe] [--url <base-url>]');
     const cfg = llm.configure(updates);
     console.log(JSON.stringify({ provider: cfg.provider, model: cfg.model, baseURL: cfg.baseURL }, null, 2));
     return;
@@ -1722,7 +1814,7 @@ function cmdTarget(args) {
 
 function cmdSourceClassify(args) {
   const projectInput = args[0];
-  if (!projectInput) fail('Usage: kdna-studio source classify <project>');
+  if (!projectInput) fail('Usage: kdna-studio source <project>');
   const { projectPath, project } = readProject(projectInput);
   const target = project.distillation_target;
   if (!target) fail('Declare a distillation target first: kdna-studio target declare <project>');
@@ -1758,7 +1850,7 @@ async function cmdDistill(args) {
   const useAI = args.includes('--ai');
   const provider = option(args, '--provider');
   const model = option(args, '--model');
-  const apiKey = option(args, '--key');
+  const apiKey = resolveApiKey(args);
   if (!projectInput) fail('Usage: kdna-studio distill <project> [--ai] [--candidates <file.json>]');
   if (!candidatesFile && !useAI) fail('Either --ai or --candidates <file.json> required.');
 
@@ -1777,6 +1869,10 @@ async function cmdDistill(args) {
   } else {
     const rawPath = path.resolve(candidatesFile);
     if (!fs.existsSync(rawPath)) fail(`Candidates file not found: ${rawPath}`);
+    const stats = fs.statSync(rawPath);
+    if (stats.size > 50 * 1024 * 1024) {
+      fail(`Candidates file too large (${(stats.size / (1024 * 1024)).toFixed(1)} MiB, max 50 MiB): ${rawPath}`);
+    }
     rawCandidates = JSON.parse(fs.readFileSync(rawPath, 'utf8'));
     if (!Array.isArray(rawCandidates)) fail('Candidates file must contain a JSON array');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/kdna-studio-cli",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "description": "Official KDNA Studio command-line authoring entry for creating, reviewing, compiling, and exporting .kdna judgment assets through the KDNA toolchain.",
   "type": "commonjs",
   "bin": {
@@ -9,7 +9,6 @@
   "files": [
     "bin/",
     "src/",
-    "tests/",
     "README.md"
   ],
   "scripts": {
@@ -48,4 +47,4 @@
   "devDependencies": {
     "@aikdna/kdna-core": "^0.12.5"
   }
-}
+}

package/src/llm/config.js

@@ -24,7 +24,7 @@ function loadConfig() {
 
   // 1. Read from ~/.kdna/config.json
   const configPath = path.join(os.homedir(), '.kdna', 'config.json');
-  try { if (fs.existsSync(configPath)) Object.assign(config, JSON.parse(fs.readFileSync(configPath, 'utf8')).llm || {}); } catch {}
+  try { if (fs.existsSync(configPath)) Object.assign(config, JSON.parse(fs.readFileSync(configPath, 'utf8')).llm || {}); } catch (e) { console.error('Error reading LLM config file:', e.message); }
 
   // 2. Env vars override
   if (process.env.KDNA_LLM_PROVIDER) config.provider = process.env.KDNA_LLM_PROVIDER;
@@ -41,12 +41,25 @@ function loadConfig() {
     if (wk.models.length > 0 && !config.model) config.model = wk.models[0];
   }
 
-  // 4. Also check provider-specific env vars
-  if (!config.apiKey) {
-    const keyEnv = `KDNA_LLM_API_KEY_${(config.provider || '').toUpperCase().replace(/-/g, '_')}`;
+  // 4. Provider-specific env var (KDNA_LLM_API_KEY_<PROVIDER>)
+  if (!config.apiKey && config.provider) {
+    const keyEnv = `KDNA_LLM_API_KEY_${config.provider.toUpperCase().replace(/-/g, '_')}`;
     if (process.env[keyEnv]) config.apiKey = process.env[keyEnv];
-    // Fallback: OPENAI_API_KEY, ANTHROPIC_API_KEY, DEEPSEEK_API_KEY
-    if (!config.apiKey) config.apiKey = process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.DEEPSEEK_API_KEY || '';
+  }
+
+  // 5. Provider-native fallback — each provider only uses its own native env var
+  if (!config.apiKey && config.provider) {
+    const PROVIDER_NATIVE_KEYS = {
+      openai: 'OPENAI_API_KEY',
+      anthropic: 'ANTHROPIC_API_KEY',
+      deepseek: 'DEEPSEEK_API_KEY',
+      groq: 'GROQ_API_KEY',
+      gemini: 'GEMINI_API_KEY',
+      perplexity: 'PERPLEXITY_API_KEY',
+      openrouter: 'OPENROUTER_API_KEY',
+    };
+    const nativeEnv = PROVIDER_NATIVE_KEYS[config.provider];
+    if (nativeEnv && process.env[nativeEnv]) config.apiKey = process.env[nativeEnv];
   }
 
   return config;
@@ -55,7 +68,7 @@ function loadConfig() {
 function saveConfig(updates) {
   const configPath = path.join(os.homedir(), '.kdna', 'config.json');
   let existing = {};
-  try { if (fs.existsSync(configPath)) existing = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch {}
+  try { if (fs.existsSync(configPath)) existing = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (e) { console.error('Error reading config file for save:', e.message); }
   existing.llm = { ...(existing.llm || {}), ...updates };
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
   fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n');

package/src/llm/index.js

@@ -29,11 +29,12 @@ async function chatWithJSON(messages, options = {}) {
   const result = await chat(messages, { ...options, responseFormat: { type: 'json_object' } });
   try {
     result.data = JSON.parse(result.content);
-  } catch {
+  } catch (e) {
+    console.error('Error parsing LLM JSON response:', e.message);
     // Try to extract JSON from markdown code blocks
     const match = result.content.match(/```(?:json)?\s*([\s\S]*?)```/);
     if (match) {
-      try { result.data = JSON.parse(match[1].trim()); } catch { /* raw text */ }
+      try { result.data = JSON.parse(match[1].trim()); } catch (e2) { console.error('Error parsing JSON from markdown code block:', e2.message); }
     }
   }
   return result;

package/tests/cli.test.js

@@ -1,869 +0,0 @@
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-const test = require('node:test');
-
-let kdnaCore = null;
-try { kdnaCore = require('@aikdna/kdna-core'); } catch { /* optional — runtime digest cross-verification */ }
-
-const root = path.resolve(__dirname, '..');
-const cli = path.join(root, 'bin', 'kdna-studio.js');
-
-function run(args, options = {}) {
-  return spawnSync(process.execPath, [cli, ...args], {
-    cwd: options.cwd || root,
-    env: {
-      ...process.env,
-      KDNA_IDENTITY_DIR: path.join(options.tmp || os.tmpdir(), 'no-identity'),
-      ...(options.env || {}),
-    },
-    encoding: 'utf8',
-  });
-}
-
-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 }));
-  const projectDir = path.join(tmp, 'project');
-  let result = run(['create', projectDir, '--name', '@test/example'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  const evidencePath = path.join(tmp, 'evidence.md');
-  fs.writeFileSync(evidencePath, 'Evidence that specific claims should outrank broad claims.');
-  result = run(['import', projectDir, evidencePath], { 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',
-    '--field',
-    'confidence=high',
-    '--field',
-    'evidence_type=practice',
-  ], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  const cardId = result.stdout.match(/Added card: (\S+)/)?.[1];
-  assert.ok(cardId, result.stdout);
-
-  result = run([
-    'card',
-    'approve',
-    projectDir,
-    cardId,
-    '--by',
-    'expert',
-    '--statement',
-    'I confirm this judgment.',
-  ], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  return { tmp, projectDir, cardId };
-}
-
-test('prints help', () => {
-  const result = run(['--help']);
-  assert.equal(result.status, 0);
-  assert.match(result.stdout, /kdna-studio/);
-  assert.match(result.stdout, /export <project>/);
-});
-
-test('rejects unknown commands with input error', () => {
-  const result = run(['unknown']);
-  assert.equal(result.status, 2);
-  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',
-    '--field',
-    'confidence=high',
-    '--field',
-    'evidence_type=practice',
-  ], { 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 }));
-  const projectDir = path.join(tmp, 'project');
-
-  let result = run(['create', projectDir, '--name', '@test/example'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  const projectPath = path.join(projectDir, 'studio.project.json');
-  assert.ok(fs.existsSync(projectPath));
-  const project = JSON.parse(fs.readFileSync(projectPath, 'utf8'));
-  assert.equal(project.name, '@test/example');
-
-  result = run(['create', projectDir, '--name', '@test/example'], { tmp });
-  assert.equal(result.status, 2);
-  assert.match(result.stderr, /Directory already exists/);
-});
-
-test('blocks compile and export until judgment cards are Human Locked', (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/example'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  result = run([
-    'card',
-    'add',
-    projectDir,
-    'axiom',
-    '--no-strict',
-    '--field',
-    'one_sentence=Prefer specific evidence over broad claims',
-  ], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  result = run(['lock', projectDir], { tmp });
-  assert.equal(result.status, 4);
-  assert.match(result.stderr, /Human Lock Gate blocked export/);
-
-  result = run(['compile', projectDir, '--out', path.join(tmp, 'build')], { tmp });
-  assert.equal(result.status, 4);
-  assert.match(result.stderr, /Human Lock Gate blocked compile/);
-});
-
-test('runs the trusted authoring workflow through compile and export', (t) => {
-  const { tmp, projectDir, cardId } = createLockedProject(t);
-
-  let result = run(['card', 'list', projectDir], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, new RegExp(`${cardId}\\s+axiom\\s+locked\\s+locked`));
-
-  result = run(['lock', projectDir], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /Human Lock Gate passed/);
-
-  const buildDir = path.join(tmp, 'build');
-  result = run(['compile', projectDir, '--out', buildDir], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  assert.ok(fs.existsSync(path.join(buildDir, 'kdna.json')));
-  assert.ok(fs.existsSync(path.join(buildDir, 'KDNA_CARD.json')));
-  assert.ok(fs.existsSync(path.join(buildDir, 'reports', 'provenance-report.json')));
-  const manifest = JSON.parse(fs.readFileSync(path.join(buildDir, 'kdna.json'), 'utf8'));
-  assert.equal(manifest.authoring.compiler, '@aikdna/kdna-studio-core');
-  assert.equal(manifest.authoring.human_confirmed, true);
-  assert.ok(manifest.authoring.human_lock_count >= 1);
-
-  // Content digest must be present and non-trivial
-  assert.ok(manifest.content_digest, 'manifest must have content_digest');
-  assert.match(manifest.content_digest, /^sha256:[0-9a-f]{64}$/);
-  assert.ok(manifest.authoring.content_digest, 'authoring must have content_digest');
-
-  const outFile = path.join(tmp, 'dist', 'example.kdna');
-  result = run(['export', projectDir, '--out', outFile], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  assert.ok(fs.existsSync(outFile));
-  const zipMagic = fs.readFileSync(outFile).subarray(0, 4).toString('hex');
-  assert.equal(zipMagic, '504b0304');
-  const receipt = JSON.parse(fs.readFileSync(path.join(tmp, 'dist', 'build-receipt.json'), 'utf8'));
-  assert.equal(receipt.signature_status, 'unsigned');
-  assert.match(receipt.asset_digest, /^sha256:/);
-
-  // ── Digest chain consistency ──────────────────────────────────
-  // All three sources MUST agree on content_digest.
-  const exportedManifest = JSON.parse(fs.readFileSync(path.join(tmp, 'dist', 'kdna.json'), 'utf8'));
-  const exportedProvenance = JSON.parse(fs.readFileSync(path.join(tmp, 'dist', 'provenance-report.json'), 'utf8'));
-  assert.equal(exportedManifest.content_digest, receipt.content_digest,
-    'manifest.content_digest !== build-receipt.content_digest');
-  assert.equal(exportedProvenance.content_digest, receipt.content_digest,
-    'provenance-report.content_digest !== build-receipt.content_digest');
-  assert.ok(exportedManifest.content_digest.startsWith('sha256:'),
-    'content_digest must be sha256: prefix');
-  assert.equal(exportedManifest.content_digest.length, 71,
-    'content_digest must be sha256: + 64 hex chars');
-});
-
-test('refuses signing without runtime identity keys', (t) => {
-  const { tmp, projectDir } = createLockedProject(t);
-  const outFile = path.join(tmp, 'dist', 'signed.kdna');
-  const result = run(['export', projectDir, '--out', outFile, '--sign'], { tmp });
-  assert.equal(result.status, 5);
-  assert.match(result.stderr, /Signing requires KDNA identity keys/);
-});
-
-// ── Identity ────────────────────────────────────────────────────────
-
-test('identity init creates local creator identity', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-  const identityDir = path.join(tmp, 'identity');
-
-  const result = run(['identity', 'init', '--name', 'Test Creator'], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: identityDir },
-  });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /Creator identity initialized/);
-  assert.match(result.stdout, /kdna:creator:ed25519:/);
-
-  // Verify files were created
-  assert.ok(fs.existsSync(path.join(identityDir, 'kdna.key')));
-  assert.ok(fs.existsSync(path.join(identityDir, 'kdna.pub')));
-  assert.ok(fs.existsSync(path.join(identityDir, 'creator.json')));
-  const creatorJson = JSON.parse(fs.readFileSync(path.join(identityDir, 'creator.json'), 'utf8'));
-  assert.match(creatorJson.creator_id, /^kdna:creator:ed25519:/);
-  assert.equal(creatorJson.display_name, 'Test Creator');
-  assert.equal(creatorJson.verified, false);
-
-  // Double init should fail
-  const result2 = run(['identity', 'init', '--name', 'Duplicate'], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: identityDir },
-  });
-  assert.equal(result2.status, 2);
-  assert.match(result2.stderr, /already exists/);
-});
-
-test('identity show displays current identity', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-  const identityDir = path.join(tmp, 'identity');
-
-  // Init first
-  run(['identity', 'init', '--name', 'Test User'], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: identityDir },
-  });
-
-  const result = run(['identity', 'show'], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: identityDir },
-  });
-  assert.equal(result.status, 0, result.stderr);
-  const info = JSON.parse(result.stdout);
-  assert.match(info.creator_id, /^kdna:creator:ed25519:/);
-  assert.equal(info.display_name, 'Test User');
-});
-
-test('identity show fails when not initialized', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-
-  const result = run(['identity', 'show'], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: path.join(tmp, 'no-such') },
-  });
-  assert.equal(result.status, 2);
-  assert.match(result.stderr, /No identity found/);
-});
-
-// ── Create from folder ──────────────────────────────────────────────
-
-test('create --from-folder imports legacy JSON source, outputs audit', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-
-  const sourceDir = path.join(tmp, 'legacy-source');
-  fs.mkdirSync(sourceDir, { recursive: true });
-
-  // Create legacy KDNA files
-  const core = {
-    meta: { domain: 'test', version: '0.1.0', created: '2026-01-01', purpose: 'test', load_condition: 'always' },
-    axioms: [{
-      id: 'ax_legacy',
-      one_sentence: 'Test axiom from legacy folder.',
-      full_statement: 'A complete testable explanation from a legacy source folder.',
-      why: 'Without this legacy axiom, agent judgment defaults to untrained behavior.',
-      applies_when: ['testing legacy import'],
-      does_not_apply_when: ['production'],
-      failure_risk: 'May produce incorrect results from untrained judgment.',
-    }],
-    ontology: [{ id: 'ont_legacy', one_sentence: 'Legacy concept.', essence: 'Operational meaning.', boundary: 'Not the opposite.', trigger_signal: 'keyword' }],
-    boundaries: [{ id: 'bnd_legacy', scope: 'Legacy scope.', out_of_scope: 'Not covered by legacy.', acceptable_exceptions: [] }],
-    stances: [],
-  };
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Core.json'), JSON.stringify(core));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Patterns.json'), JSON.stringify({
-    meta: { domain: 'test', version: '0.1.0', created: '2026-01-01', purpose: 'patterns', load_condition: 'always' },
-    misunderstandings: [{ id: 'ms_legacy', wrong: 'Legacy wrong belief.', correct: 'Correct understanding.', key_distinction: 'The key distinction between wrong and correct.' }],
-    self_check: ['Did I verify the legacy import?'],
-  }));
-
-  const projectDir = path.join(tmp, 'project');
-  const result = run(['create', projectDir, '--from-folder', sourceDir, '--name', '@test/legacy-import'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  const output = JSON.parse(result.stdout);
-  assert.ok(output.audit, 'must have audit info');
-  assert.ok(output.audit.filesFound.includes('KDNA_Core.json'));
-  assert.ok(output.audit.filesFound.includes('KDNA_Patterns.json'));
-  assert.ok(output.imported > 0, `imported cards: ${output.imported}`);
-  assert.equal(output.source_mode, 'source_folder');
-
-  // Read project and verify cards were imported
-  const projectPath = path.join(projectDir, 'studio.project.json');
-  assert.ok(fs.existsSync(projectPath));
-  const project = JSON.parse(fs.readFileSync(projectPath, 'utf8'));
-  assert.equal(project.source_mode, 'source_folder');
-  assert.ok(project.cards.length > 0);
-  assert.equal(project.lineage.type, 'migrated');
-});
-
-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 }));
-
-  const sourceDir = path.join(tmp, 'legacy-source');
-  fs.mkdirSync(sourceDir, { recursive: true });
-  fs.writeFileSync(path.join(sourceDir, 'kdna.json'), JSON.stringify({
-    name: '@test/legacy-import',
-    version: '0.7.3',
-    judgment_version: '2026.05',
-    asset_type: 'domain_judgment',
-    description: 'Legacy import fixture.',
-    core_insight: 'Preserve real judgment structure.',
-    author: { name: 'Test Author', id: 'test-author' },
-    license: { type: 'CC-BY-4.0' },
-    keywords: ['legacy', 'v1'],
-    languages: ['en'],
-    default_language: 'en',
-    quality_badge: 'tested',
-    registry: { repo: 'https://example.invalid/legacy' },
-  }));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Core.json'), JSON.stringify({
-    axioms: [{
-      id: 'ax_legacy',
-      one_sentence: 'Prefer specific evidence over broad claims.',
-      full_statement: 'When evaluating a claim the agent must preserve specific evidence and not collapse it into generic advice.',
-      why: 'Without this judgment the agent produces plausible but weak summaries.',
-      applies_when: ['reviewing content'],
-      does_not_apply_when: ['pure formatting'],
-      failure_risk: 'May over-diagnose simple copy edits.',
-    }],
-    ontology: [{ id: 'on_legacy', essence: 'Specificity anchor', boundary: 'Not generic polish', trigger_signal: 'abstract claim' }],
-    frameworks: [{ id: 'fw_legacy', name: 'Diagnose before rewrite', when_to_use: 'reviewing drafts', steps: ['diagnose', 'rewrite'] }],
-    stances: [{ id: 'st_legacy', stance: 'Structure first', applies_when: ['draft review'], does_not_apply_when: ['grammar only'] }],
-  }));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Patterns.json'), JSON.stringify({
-    terminology: {
-      standard_terms: [{ term: 'specificity anchor', definition: 'A concrete detail.' }],
-      banned_terms: [{ term: 'make it better', why: 'Non-diagnostic.', replace_with: 'name the structural issue' }],
-    },
-    misunderstandings: [{ wrong: 'Smooth means good.', correct: 'Smooth can hide weak thinking.', key_distinction: 'surface vs structure', why: 'Prevents false praise.' }],
-    self_check: ['Did I preserve the structural judgment?'],
-  }));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Scenarios.json'), JSON.stringify({ scenes: [{ id: 'sc_legacy', name: 'Draft review', trigger: 'user asks for review', action: 'diagnose first' }] }));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Cases.json'), JSON.stringify({ cases: [{ id: 'ca_legacy', title: 'Smooth but empty', scenario: 'draft reads well', expected: 'flag missing claim' }] }));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Reasoning.json'), JSON.stringify({ reasoning_chains: [{ id: 're_legacy', name: 'structure-first', conclusion: 'diagnose structure first', so_what: 'avoid surface polish' }] }));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Evolution.json'), JSON.stringify({ stages: [{ id: 'ev_legacy', name: 'Structural reviewer', description: 'Moves beyond surface editing.' }] }));
-
-  const outFile = path.join(tmp, 'legacy.kdna');
-  const result = run([
-    'migrate', sourceDir,
-    '--out', outFile,
-    '--name', '@test/legacy-import',
-    '--by', 'tester',
-    '--statement', 'I confirm this v1 migration fixture.',
-    '--format', 'v1',
-  ], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  const validation = kdnaCore.validate(outFile);
-  assert.equal(validation.overall_valid, true, JSON.stringify(validation.problems));
-  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.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.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) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-
-  // First create and export a "parent" project
-  const parentTmp = tmpDir();
-  t.after(() => fs.rmSync(parentTmp, { recursive: true, force: true }));
-  const { projectDir: parentDir } = createLockedProject(t);
-  const parentDist = path.join(parentTmp, 'dist');
-  fs.mkdirSync(parentDist, { recursive: true });
-  const parentKdna = path.join(parentDist, 'parent.kdna');
-  run(['export', parentDir, '--out', parentKdna], { tmp: parentTmp });
-
-  // Now fork from that .kdna
-  const projectDir = path.join(tmp, 'forked-project');
-  const result = run(['create', projectDir, '--from-kdna', parentKdna, '--name', '@test/fork'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /Created Studio project/);
-  assert.match(result.stdout, /kdna_asset/);
-
-  const projectPath = path.join(projectDir, 'studio.project.json');
-  assert.ok(fs.existsSync(projectPath));
-  const project = JSON.parse(fs.readFileSync(projectPath, 'utf8'));
-  assert.equal(project.source_mode, 'kdna_asset');
-  assert.ok(project.lineage, 'must have lineage');
-  assert.equal(project.lineage.type, 'fork');
-  assert.ok(project.lineage.parent_name, 'must record parent name');
-});
-
-// ── Card approve --sign ─────────────────────────────────────────────
-
-test('card approve --sign binds Human Lock to creator identity', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-  const identityDir = path.join(tmp, 'identity');
-
-  // Initialize creator identity
-  const init = run(['identity', 'init', '--name', 'Signer'], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: identityDir },
-  });
-  assert.equal(init.status, 0, init.stderr);
-
-  // Create project with an axiom
-  const projectDir = path.join(tmp, 'project');
-  let result = run(['create', projectDir, '--name', '@test/signed'], { 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.',
-    '--field', 'why=Without this axiom the agent may accept broad plausible-sounding claims as equally credible as narrow evidence-backed ones.',
-    '--field', 'applies_when=["reviewing content"]',
-    '--field', 'does_not_apply_when=["pure formatting"]',
-    '--field', 'failure_risk=generic advice',
-    '--field', 'confidence=high',
-    '--field', 'evidence_type=practice',
-  ], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  const cardId = result.stdout.match(/Added card: (\S+)/)?.[1];
-
-  // Approve with --sign
-  result = run([
-    'card', 'approve', projectDir, cardId,
-    '--by', 'signer',
-    '--statement', 'I confirm this judgment with my creator identity.',
-    '--sign',
-  ], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: identityDir },
-  });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /signed/);
-
-  // Verify human_lock has creator_id and signature
-  const project = JSON.parse(fs.readFileSync(path.join(projectDir, 'studio.project.json'), 'utf8'));
-  const lockedCard = project.cards.find(c => c.id === cardId);
-  assert.ok(lockedCard.human_lock, 'must have human_lock');
-  assert.ok(lockedCard.human_lock.creator_id, 'must have creator_id');
-  assert.match(lockedCard.human_lock.creator_id, /^kdna:creator:ed25519:/);
-  assert.ok(lockedCard.human_lock.signature, 'must have signature');
-  assert.match(lockedCard.human_lock.signature, /^ed25519:/);
-});
-
-// ── Blank create with default source_mode ───────────────────────────
-
-test('create (blank) sets source_mode=blank by default', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-  const projectDir = path.join(tmp, 'project');
-
-  const result = run(['create', projectDir, '--name', '@test/blank'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  const project = JSON.parse(fs.readFileSync(path.join(projectDir, 'studio.project.json'), 'utf8'));
-  assert.equal(project.source_mode, 'blank');
-});
-
-// ── export includes creator/lineage in manifest ─────────────────────
-
-test('export includes creator and lineage in kdna.json', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-  const identityDir = path.join(tmp, 'identity');
-
-  // Init identity
-  run(['identity', 'init', '--name', 'Exporter'], {
-    tmp,
-    env: { ...process.env, KDNA_IDENTITY_DIR: identityDir },
-  });
-
-  // Create, add axiom, approve
-  const projectDir = path.join(tmp, 'project');
-  run(['create', projectDir, '--name', '@test/exported'], { tmp });
-  run([
-    'card', 'add', projectDir, 'axiom',
-    '--field', 'one_sentence=Test axiom for lineage.',
-    '--field', 'full_statement=This is a complete testable explanation for the agent to apply in judgment scenarios.',
-    '--field', 'why=Without this axiom the agent would make incorrect judgment calls.',
-    '--field', 'applies_when=["testing"]',
-    '--field', 'does_not_apply_when=["not testing"]',
-    '--field', 'failure_risk=test may pass incorrectly',
-    '--field', 'confidence=high',
-    '--field', 'evidence_type=practice',
-  ], { tmp });
-  let result = run(['card', 'list', projectDir], { tmp });
-  const cardId = result.stdout.match(/(\S+)\s+axiom/)?.[1];
-  run(['card', 'approve', projectDir, cardId, '--by', 'tester', '--statement', 'Verified.'], { tmp });
-  run(['lock', projectDir], { tmp });
-
-  const distDir = path.join(tmp, 'dist');
-  const outFile = path.join(distDir, 'exported.kdna');
-  result = run(['export', projectDir, '--out', outFile], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  // Check exported kdna.json has new fields
-  const exportedManifest = JSON.parse(fs.readFileSync(path.join(distDir, 'kdna.json'), 'utf8'));
-  assert.equal(exportedManifest.authoring.source_mode, 'blank');
-  assert.ok(exportedManifest.lineage, 'must have lineage');
-  assert.equal(exportedManifest.lineage.type, 'original');
-});
-
-// ── E2E: Blank workflow with runtime content_digest check ──────────
-
-test('E2E blank: create → approve → lock → export → runtime digest match', (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/e2e-blank'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  // Add axiom with full fields
-  result = run([
-    'card', 'add', projectDir, 'axiom',
-    '--field', 'one_sentence=E2E blank axiom.',
-    '--field', 'full_statement=A complete testable explanation for the end-to-end blank workflow test.',
-    '--field', 'why=Without this axiom the end-to-end test would not validate blank creation.',
-    '--field', 'applies_when=["e2e testing"]',
-    '--field', 'does_not_apply_when=["production"]',
-    '--field', 'failure_risk=e2e test may incorrectly pass',
-    '--field', 'confidence=high',
-    '--field', 'evidence_type=practice',
-  ], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  const cardId = result.stdout.match(/Added card: (\S+)/)?.[1];
-
-  // Add a misunderstanding
-  result = run([
-    'card', 'add', projectDir, 'misunderstanding',
-    '--field', 'wrong=E2E tests are unnecessary.',
-    '--field', 'correct=E2E tests catch integration issues not visible in unit tests.',
-    '--field', 'key_distinction=E2E tests validate the full pipeline, not individual functions.',
-    '--field', 'why=E2E test failures are hard to debug without a full integration test running.',
-  ], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  // Approve all cards
-  let cards = run(['card', 'list', projectDir], { tmp });
-  for (const line of cards.stdout.trim().split('\n')) {
-    const id = line.split(/\s+/)[0];
-    result = run(['card', 'approve', projectDir, id, '--by', 'tester', '--statement', 'Confirmed.'], { tmp });
-    assert.equal(result.status, 0, result.stderr);
-  }
-
-  // Lock and export
-  result = run(['lock', projectDir], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  const outFile = path.join(tmp, 'blank.kdna');
-  fs.mkdirSync(path.dirname(outFile), { recursive: true });
-  result = run(['export', projectDir, '--out', outFile], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  // ── Verify: source_mode, lineage, digest chain ────────────
-  const distDir = path.dirname(outFile);
-  const manifest = JSON.parse(fs.readFileSync(path.join(distDir, 'kdna.json'), 'utf8'));
-  const receipt = JSON.parse(fs.readFileSync(path.join(distDir, 'build-receipt.json'), 'utf8'));
-  const provenance = JSON.parse(fs.readFileSync(path.join(distDir, 'provenance-report.json'), 'utf8'));
-
-  assert.equal(manifest.authoring.source_mode, 'blank');
-  assert.equal(manifest.lineage.type, 'original');
-  assert.match(manifest.content_digest, /^sha256:[0-9a-f]{64}$/);
-  assert.equal(manifest.content_digest, receipt.content_digest, 'manifest vs receipt digest mismatch');
-  assert.equal(manifest.content_digest, provenance.content_digest, 'manifest vs provenance digest mismatch');
-  assert.equal(manifest.authoring.compiler, '@aikdna/kdna-studio-core');
-  assert.equal(manifest.authoring.human_confirmed, true);
-
-  // ── Runtime cross-verification: content digest consistency ──
-  // Compute content digest from the .kdna ZIP entries and verify it
-  // matches the manifest, receipt, and provenance report.
-  if (kdnaCore) {
-    const reader = kdnaCore.createKdnaAssetReader();
-    const asset = reader.openSync(outFile);
-    const runtimeResult = reader.verifySync(asset);
-    const runtimeDigest = runtimeResult.content_digest;
-
-    assert.ok(runtimeDigest, 'runtime content_digest must be present');
-    assert.match(runtimeDigest, /^sha256:[0-9a-f]{64}$/, 'runtime content_digest must be valid sha256');
-
-    // Read ZIP-internal manifest (avoid sidecar timing issues)
-    const zipManifest = JSON.parse(asset.readEntry('kdna.json').toString());
-    assert.equal(zipManifest.content_digest, receipt.content_digest,
-      `ZIP manifest digest != receipt digest`);
-    assert.equal(zipManifest.content_digest, provenance.content_digest,
-      `ZIP manifest digest != provenance digest`);
-
-    // Verify: runtime computed digest matches ZIP manifest
-    assert.equal(zipManifest.content_digest, runtimeDigest,
-      `ZIP manifest content_digest (${zipManifest.content_digest.slice(0, 20)}...) != runtime computed (${runtimeDigest.slice(0, 20)}...) — trust chain broken`);
-  } else {
-    console.log('  (kdna-core not available, skipping runtime assetReader cross-verification)');
-  }
-});
-
-// ── E2E: Fork workflow ────────────────────────────────────────────
-
-test('E2E fork: parent → fork → approve → export → lineage check', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-
-  // Step 1: Create and export a parent domain
-  const parentDir = path.join(tmp, 'parent');
-  let result = run(['create', parentDir, '--name', '@test/parent-domain'], { tmp });
-  result = run([
-    'card', 'add', parentDir, 'axiom',
-    '--field', 'one_sentence=Parent axiom for forking test.',
-    '--field', 'full_statement=A complete testable explanation from the parent domain for fork lineage verification.',
-    '--field', 'why=Without this parent axiom the fork test would have no source to verify lineage against.',
-    '--field', 'applies_when=["fork testing"]',
-    '--field', 'does_not_apply_when=["not forking"]',
-    '--field', 'failure_risk=forked content may lose lineage',
-    '--field', 'confidence=high',
-    '--field', 'evidence_type=practice',
-  ], { tmp });
-  const pCards = run(['card', 'list', parentDir], { tmp });
-  for (const line of pCards.stdout.trim().split('\n')) {
-    const id = line.split(/\s+/)[0];
-    run(['card', 'approve', parentDir, id, '--by', 'tester', '--statement', 'Parent OK.'], { tmp });
-  }
-  run(['lock', parentDir], { tmp });
-  const parentKdna = path.join(tmp, 'parent.kdna');
-  fs.mkdirSync(path.dirname(parentKdna), { recursive: true });
-  result = run(['export', parentDir, '--out', parentKdna], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  // Step 2: Fork from parent
-  const forkDir = path.join(tmp, 'forked');
-  result = run(['create', forkDir, '--from-kdna', parentKdna, '--name', '@test/forked-domain'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  const fProject = JSON.parse(fs.readFileSync(path.join(forkDir, 'studio.project.json'), 'utf8'));
-  assert.equal(fProject.source_mode, 'kdna_asset');
-  assert.equal(fProject.lineage.type, 'fork');
-  assert.equal(fProject.lineage.parent_name, '@test/parent-domain');
-
-  // Step 3: Approve and export fork
-  const fCards = run(['card', 'list', forkDir], { tmp });
-  for (const line of fCards.stdout.trim().split('\n')) {
-    const id = line.split(/\s+/)[0];
-    run(['card', 'approve', forkDir, id, '--by', 'tester', '--statement', 'Fork confirmed.'], { tmp });
-  }
-  run(['lock', forkDir], { tmp });
-  const forkKdna = path.join(tmp, 'forked.kdna');
-  fs.mkdirSync(path.dirname(forkKdna), { recursive: true });
-  result = run(['export', forkDir, '--out', forkKdna], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  // Step 4: Verify lineage in exported fork
-  const fManifest = JSON.parse(fs.readFileSync(path.join(tmp, 'kdna.json'), 'utf8'));
-  assert.equal(fManifest.authoring.source_mode, 'kdna_asset');
-  assert.equal(fManifest.lineage.type, 'fork');
-  assert.equal(fManifest.lineage.parent_name, '@test/parent-domain');
-  assert.match(fManifest.content_digest, /^sha256:/);
-});
-
-// ── E2E: Migrate workflow ─────────────────────────────────────────
-
-test('E2E migrate: source folder → import → approve → export → verify', (t) => {
-  const tmp = tmpDir();
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-
-  // Step 1: Create legacy source folder
-  const sourceDir = path.join(tmp, 'legacy');
-  fs.mkdirSync(sourceDir, { recursive: true });
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Core.json'), JSON.stringify({
-    meta: { domain: 'legacy_test', version: '0.3.0', created: '2026-01-01', purpose: 'Legacy migrate test', load_condition: 'always' },
-    axioms: [{
-      id: 'ax_mig', one_sentence: 'Migrated axiom for E2E test.',
-      full_statement: 'A complete testable explanation for the migrated legacy axiom in the end-to-end workflow.',
-      why: 'Without this migrated axiom the e2e test cannot verify legacy folder migration.',
-      applies_when: ['legacy migration testing'], does_not_apply_when: ['not migrating'],
-      failure_risk: 'migrated content may not be re-locked',
-    }],
-    ontology: [],
-    stances: [],
-  }));
-  fs.writeFileSync(path.join(sourceDir, 'KDNA_Patterns.json'), JSON.stringify({
-    meta: { domain: 'legacy_test', version: '0.3.0', created: '2026-01-01', purpose: 'legacy patterns', load_condition: 'always' },
-    misunderstandings: [{ id: 'ms_mig', wrong: 'Legacy wrong belief.', correct: 'Correct understanding.', key_distinction: 'The key difference between legacy wrong and correct behavior.' }],
-    self_check: ['Is the migrated content properly re-locked?'],
-  }));
-
-  // Step 2: Import via --from-folder
-  const projectDir = path.join(tmp, 'imported');
-  let result = run(['create', projectDir, '--from-folder', sourceDir, '--name', '@test/e2e-migrate'], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-  const audit = JSON.parse(result.stdout);
-  assert.ok(audit.imported > 0, `No cards imported: ${result.stdout}`);
-  assert.equal(audit.source_mode, 'source_folder');
-
-  // Verify project has source_folder mode
-  const project = JSON.parse(fs.readFileSync(path.join(projectDir, 'studio.project.json'), 'utf8'));
-  assert.equal(project.source_mode, 'source_folder');
-  assert.equal(project.lineage.type, 'migrated');
-
-  // Step 3: Approve and export
-  const cards = run(['card', 'list', projectDir], { tmp });
-  for (const line of cards.stdout.trim().split('\n')) {
-    const id = line.split(/\s+/)[0];
-    result = run(['card', 'approve', projectDir, id, '--by', 'tester', '--statement', 'Migrated content confirmed.'], { tmp });
-    assert.equal(result.status, 0, result.stderr);
-  }
-  result = run(['lock', projectDir], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  const outFile = path.join(tmp, 'migrated.kdna');
-  fs.mkdirSync(path.dirname(outFile), { recursive: true });
-  result = run(['export', projectDir, '--out', outFile], { tmp });
-  assert.equal(result.status, 0, result.stderr);
-
-  // Verify exported manifest
-  const distDir = path.dirname(outFile);
-  const manifest = JSON.parse(fs.readFileSync(path.join(distDir, 'kdna.json'), 'utf8'));
-  assert.equal(manifest.authoring.source_mode, 'source_folder');
-  assert.equal(manifest.lineage.type, 'migrated');
-  assert.match(manifest.content_digest, /^sha256:/);
-  assert.equal(manifest.authoring.human_confirmed, true);
-
-  // Digest chain
-  const receipt = JSON.parse(fs.readFileSync(path.join(distDir, 'build-receipt.json'), 'utf8'));
-  assert.equal(manifest.content_digest, receipt.content_digest);
-});

package/tests/e2e-export-completeness.test.js

@@ -1,93 +0,0 @@
-/**
- * e2e-export-completeness.test.js
- * Verifies all card types survive add → approve → export → validate → load.
- * Catches regressions like: stances hardcoded to [], pattern cards dropped during compile.
- */
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const { spawnSync } = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-
-const studioBin = path.join(__dirname, '..', 'bin', 'kdna-studio.js');
-
-function run(args, opts = {}) {
-  return spawnSync(process.execPath, [studioBin, ...args], {
-    encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env, ...opts.env },
-  });
-}
-
-function runKdna(args) {
-  return spawnSync('kdna', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-}
-
-function tmpDir() { return fs.mkdtempSync(path.join(os.tmpdir(), 'kdna-e2e-export-')); }
-
-function addCard(projectDir, type, fields) {
-  const args = ['card', 'add', projectDir, type];
-  for (const [k, v] of Object.entries(fields)) args.push('--field', `${k}=${v}`);
-  return run(args);
-}
-
-test('e2e: pattern → approve → export → patterns in payload', () => {
-  const tmp = tmpDir();
-  try {
-    const pDir = path.join(tmp, 'p');
-    run(['create', pDir, '--name', '@test/e2e-pattern']);
-    addCard(pDir, 'axiom', {
-      one_sentence: 'AX', full_statement: 'A complete and testable explanation for the agent.',
-      why: 'Without this axiom the agent would fail.',
-      applies_when: '["x"]', does_not_apply_when: '["y"]', failure_risk: 'g',
-      confidence: 'high', evidence_type: 'practice',
-    });
-    addCard(pDir, 'pattern', {
-      type: 'test_pattern', name: 'Test Pattern', one_sentence: 'A test pattern.',
-      what_it_looks_like: 'It looks like X.', how_to_fix: 'Fix by doing Y.', failure_risk: 'low',
-    });
-    const approveR = run(['card', 'approve', pDir, '--all', '--by', 'me', '--statement', 'ok']);
-    assert.equal(approveR.status, 0, approveR.stderr);
-    const exportR = run(['export', pDir, '--format', 'v1', '--out', path.join(tmp, 'out.kdna')]);
-    assert.equal(exportR.status, 0, exportR.stderr);
-    runKdna(['unpack', path.join(tmp, 'out.kdna'), path.join(tmp, 'unpacked')]);
-    const payload = JSON.parse(fs.readFileSync(path.join(tmp, 'unpacked', 'payload.kdnab'), 'utf8'));
-    const patternCards = (payload.patterns || []).filter(p => p.type === 'test_pattern');
-    assert.ok(patternCards.length > 0, `Expected >0 pattern cards in payload patterns, got ${patternCards.length}`);
-  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
-});
-
-test('e2e: stances → approve → export → stances in payload', () => {
-  const tmp = tmpDir();
-  try {
-    const pDir = path.join(tmp, 'p');
-    run(['create', pDir, '--name', '@test/e2e-stance']);
-    addCard(pDir, 'axiom', {
-      one_sentence: 'AX', full_statement: 'A complete and testable explanation for the agent.',
-      why: 'Without this axiom the agent would fail.',
-      applies_when: '["x"]', does_not_apply_when: '["y"]', failure_risk: 'g',
-      confidence: 'high', evidence_type: 'practice',
-    });
-    addCard(pDir, 'stance', { statement: 'Stance one: Always diagnose before prescribing.' });
-    addCard(pDir, 'stance', { statement: 'Stance two: Trust burns slowly and is lost quickly.' });
-    run(['card', 'approve', pDir, '--all', '--by', 'me', '--statement', 'ok']);
-    run(['export', pDir, '--format', 'v1', '--out', path.join(tmp, 'out.kdna')]);
-    runKdna(['unpack', path.join(tmp, 'out.kdna'), path.join(tmp, 'unpacked')]);
-    const payload = JSON.parse(fs.readFileSync(path.join(tmp, 'unpacked', 'payload.kdnab'), 'utf8'));
-    assert.equal((payload.core?.stances || []).length, 2, 'Expected 2 stances in payload');
-  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
-});
-
-test('e2e: missing required fields reports ALL fields at once', () => {
-  const tmp = tmpDir();
-  try {
-    const pDir = path.join(tmp, 'p');
-    run(['create', pDir, '--name', '@test/e2e-completeness']);
-    const r = addCard(pDir, 'axiom', { one_sentence: 'test' });
-    assert.notEqual(r.status, 0);
-    assert.ok(r.stderr.includes('full_statement'), 'must mention full_statement');
-    assert.ok(r.stderr.includes('why'), 'must mention why');
-    assert.ok(r.stderr.includes('applies_when'), 'must mention applies_when');
-    assert.ok(r.stderr.includes('confidence'), 'must mention confidence');
-  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
-});