@aikdna/kdna-studio-core 1.5.3 → 1.5.5

package/README.md

@@ -1,17 +1,34 @@
 # KDNA Studio Core
 
-**KDNA Studio Core is the judgment asset refinery.** It turns scattered notes, documents, works, and feedback into loadable .kdna judgment assets — not by compressing content, but by distilling the stable judgment patterns embedded within it.
+**KDNA Studio Core is the judgment asset refinery.** It turns scattered notes, documents, works, and feedback into loadable `.kdna` judgment assets — not by compressing content, but by distilling stable judgment patterns into a declared domain and loading scope.
 
-AI may propose judgment candidates from content analysis. Humans must confirm judgment. Only human-locked judgment can compile into KDNA.
+Studio Core is part of the official authoring toolchain. It can record human review, Human Lock, signatures, and release evidence as provenance signals, but those signals are not KDNA Core v1 format-validity requirements and they do not make content officially endorsed, certified, or universally safe.
 
-Open-source Studio-compatible authoring kernel for creating trusted `.kdna` assets — JS/npm package. Supports two authoring paths: interview-first (expert self-expression) and distillation-first (pattern extraction from existing content). Both end with Human Judgment Lock.
+Open-source Studio-compatible authoring kernel for creating reviewable `.kdna` assets — JS/npm package. Supports two authoring paths: interview-first (direct expression) and distillation-first (pattern extraction from existing content). Both end with a canonical KDNA Core v1 runtime export.
 
-**KDNA Studio Core is the JS authoring kernel.** It is not a UI tool and not a CLI package. It is a pure-logic engine for creating KDNA judgment cards, Human Locks, compiler output, and authoring provenance from JavaScript applications and Studio-compatible tools.
+**KDNA Studio Core is the JS authoring kernel.** It is not a UI tool and not a CLI package. It is a pure-logic engine for creating KDNA judgment cards, optional provenance records, compiler output, and runtime `.kdna` exports from JavaScript applications and Studio-compatible tools.
 
-A `.kdna` asset is not created by writing JSON files. It is compiled by a
-Studio-compatible authoring pipeline that performs human confirmation,
-validation, canonicalization, identity generation, digest computation, signing,
-optional encryption, and provenance recording.
+A `.kdna` asset is not a public source JSON folder. Studio-compatible tooling
+uses a project workspace for authoring, review, and audit, then exports the
+canonical KDNA Core v1 runtime container. Human confirmation, Human Lock,
+signing, optional encryption, and release evidence are provenance layers, not
+format-validity requirements.
+
+Studio Core distinguishes authoring compile output from runtime distribution
+output. Authoring compile output may include source entries such as
+`KDNA_Core.json` and `KDNA_Patterns.json` for audit and review. Runtime export
+must produce the canonical KDNA Core v1 distribution shape:
+
+```text
+mimetype
+kdna.json
+payload.kdnab
+checksums.json
+```
+
+Runtime export must validate with `@aikdna/kdna-core` and must plan through the
+LoadPlan contract in `aikdna/kdna`. Studio products must not create app-private
+`.kdna` shapes that Chat or CLI cannot inspect, validate, or plan-load.
 
 **Hard boundary:** Optional encryption, when supported, MUST be represented as
 protected entries inside the `.kdna` container (RFC-0008). App-private encrypted
@@ -21,8 +38,8 @@ conforming KDNA runtime assets.
 | Library | Language | Role |
 |---------|----------|------|
 | `@aikdna/kdna-cli` | JS/npm | **Operate** KDNA — install, verify, load, compare, publish |
-| **`@aikdna/kdna-studio-core`** | JS/npm | **Authoring kernel** — project model, cards, Human Lock, compiler, provenance |
-| `@aikdna/kdna-studio-cli` | JS/npm | **Create via CLI** — `kdna-studio` create, compile, export |
+| **`@aikdna/kdna-studio-core`** | JS/npm | **Authoring kernel** — project model, cards, review/provenance, compiler, runtime export |
+| `@aikdna/kdna-studio-cli` | JS/npm | **Create via CLI** — `kdna-studio` create, review, export |
 | `@aikdna/kdna-core` | JS/npm | **Use** KDNA — load, validate, format |
 
 ## What it does
@@ -33,14 +50,16 @@ conforming KDNA runtime assets.
 - **Evidence Relevance** — classify source material as relevant, weakly relevant, out-of-scope, or split-domain before distillation
 - **Scope Gate** — mark candidates with `scope_fit`, relevance score, and suggested split domain before they can become cards
 - **Judgment Cards** — 8 card types: axiom, ontology, stance, framework, misunderstanding, self_check, banned_term, terminology
-- **Human Lock** — AI proposes, human confirms. Only locked cards compile.
+- **Review and provenance** — AI may propose candidates; projects can record human confirmation, Human Lock, signatures, and release evidence when needed.
 - **Authoring Provenance** — every compiled manifest records Studio-compatible
-  compiler metadata, project digest, Human Lock count, and confirmation status.
-- **Asset Build Reports** — every compile emits build, provenance, Human Lock,
+  compiler metadata, project digest, review counts, and confirmation status.
+- **Asset Build Reports** — every compile emits build, provenance, review,
   quality gate, eval, and receipt artifacts for audit.
 - **Feynman Restatement** — verify understanding, not just agreement
 - **Quality Gates** — readiness check: draft → structurally_ready → judgment_ready → publish_ready
 - **Compiler** — locked cards → `KDNA_Core.json` + `KDNA_Patterns.json`
+- **Runtime Export** — compiled judgment → canonical `mimetype` +
+  `kdna.json` + `payload.kdnab` + `checksums.json`
 - **Test Lab** — A/B comparison (No KDNA vs Best Prompt vs KDNA)
 - **Provenance** — content fingerprinting, build tracking, audit trail
 
@@ -54,14 +73,14 @@ conforming KDNA runtime assets.
 ## Authoring Flow
 
 ```
-Evidence Room → Judgment Cards → Human Lock → Quality Gate → Compile → Validate → Export
+Evidence Room → Judgment Cards → Review/Provenance → Quality Gate → Compile → Validate → Export
 ```
 
 For distillation-first authoring, the flow starts with an explicit target:
 
 ```
 Declare Domain + Scope → Import Evidence → Classify Relevance → Distill Candidates
-  → Scope Gate → Human Review → Promote to Cards → Human Lock → Compile → Export
+  → Scope Gate → Review → Promote to Cards → Provenance → Compile → Export
 ```
 
 A single `.kdna` asset should stay scoped to one domain and loading condition. If a task needs several judgment domains, create multiple domain assets and compose them through a KDNA Cluster rather than making one broad file.
@@ -99,9 +118,9 @@ kdna-studio card add my_domain axiom \
   --field does_not_apply_when='["Out of scope"]' \
   --field failure_risk="What could go wrong"
 kdna-studio card approve my_domain <card-id> --by expert --statement "I confirm this judgment."
-kdna-studio export my_domain --out dist/my_domain.kdna --sign
-kdna verify dist/my_domain.kdna --judgment
-kdna publish dist/my_domain.kdna
+kdna-studio export my_domain --format v1 --out dist/my_domain.kdna
+kdna validate dist/my_domain.kdna
+kdna plan-load dist/my_domain.kdna
 ```
 
 ## Quick Start
@@ -110,6 +129,8 @@ kdna publish dist/my_domain.kdna
 const {
   project: projectApi,
   cards: cardApi,
+  compile,
+  exportRuntime,
   distillation
 } = require('@aikdna/kdna-studio-core');
 
@@ -141,7 +162,7 @@ const card = cardApi.createCard('axiom', {
 });
 project.cards.push(card);
 
-// 3. Human Lock
+// 3. Optional review provenance for this Studio project
 const locked = cardApi.lockCard(card, {
   by: 'writer_001',
   statement: 'This represents my professional writing judgment.',
@@ -151,12 +172,48 @@ const locked = cardApi.lockCard(card, {
 // 4. Check readiness
 const gate = projectApi.checkHumanLockGate(project);
 if (!gate.blocked) {
-  // 5. Export
-  const json = projectApi.exportProject(project);
-  console.log('Ready to publish');
+  // 5. Compile and runtime-export
+  const compiled = compile.compileDomain(project, { strictAuthority: false });
+  const runtimeAsset = exportRuntime.exportRuntimeAsset(project, { compiled });
+  console.log(Object.keys(runtimeAsset.files));
 }
 ```
 
+## Runtime Export Contract
+
+`compile.compileDomain(project)` is an authoring compile step. It returns source
+and evidence artifacts for review, audit, and reports. It is not itself the
+runtime distribution contract.
+
+Use `exportRuntime.exportRuntimeAsset(project)` to produce a KDNA Core v1
+runtime source directory payload:
+
+```js
+const { exportRuntime } = require('@aikdna/kdna-studio-core');
+
+const runtimeAsset = exportRuntime.exportRuntimeAsset(project);
+// runtimeAsset.files contains only:
+// - mimetype
+// - kdna.json
+// - payload.kdnab
+// - checksums.json
+```
+
+The exported files are tested against `@aikdna/kdna-core.validate`. In the OPEN
+workspace they are also tested against the current `aikdna/kdna` LoadPlan
+implementation when available.
+
+Access values are canonicalized for runtime export:
+
+| Studio / legacy value | Runtime value |
+|---|---|
+| `open` | `public` |
+| `protected` | `licensed` |
+| `runtime` | `remote` |
+
+Top-level source JSON entries such as `KDNA_Core.json`, `KDNA_Patterns.json`,
+and `KDNA_CARD.json` must not be present in runtime export output.
+
 ## Card Types (v1.0)
 
 | Type | Compiles to | Description |
@@ -177,13 +234,16 @@ draft → revised → locked → tested → published → deprecated
 ```
 
 Rules:
-- Only `locked`/`tested`/`published` cards can be compiled
-- Cards must have Human Lock (`human_lock.by` + `human_lock.statement`) before locking
-- Human Lock must confirm `applies_when`, `does_not_apply_when`, `failure_risk` were reviewed
+- `locked`/`tested`/`published` are Studio project review states, not KDNA Core format-validity states.
+- Studio release exports use reviewed cards as release evidence.
+- A validated `.kdna` file can still be structurally valid without Human Lock; trust, authorship, signatures, and release evidence are separate layers.
 
 ## Human Lock
 
-AI can propose. Human must confirm. Only locked judgment can compile.
+Human Lock is optional provenance metadata. It records that a human reviewed
+specific judgment fields in a Studio project. It is useful for public,
+enterprise, or high-risk assets, but it is not a KDNA Core v1 format-validity
+requirement and does not certify content quality.
 
 ```js
 lockCard(card, {
@@ -201,7 +261,7 @@ lockCard(card, {
 
 Apache-2.0 — see [LICENSE](LICENSE).
 
-KDNA Studio Core is open source. Official KDNA Studio App, hosted collaboration, managed registry, quality review workflows, and enterprise private registry may be commercial services.
+KDNA Studio Core is open source. Official KDNA Studio App, hosted collaboration, managed review workflows, and enterprise private distribution may be commercial services.
 
 ## Related
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aikdna/kdna-studio-core",
-  "version": "1.5.3",
-  "description": "Official KDNA Studio Core SDK for authoring, locking, compiling, and exporting .kdna judgment assets through the KDNA toolchain.",
+  "version": "1.5.5",
+  "description": "Official KDNA Studio Core SDK for authoring, reviewing, compiling, and exporting .kdna judgment assets through the KDNA toolchain.",
   "type": "commonjs",
   "main": "src/index.js",
   "files": [
@@ -19,12 +19,12 @@
     "domain-judgment",
     "authoring",
     "judgment-cards",
-    "human-lock",
+    "provenance",
     "compile",
     "validate"
   ],
   "dependencies": {
-    "@aikdna/kdna-core": "^0.11.1",
+    "@aikdna/kdna-core": "^0.12.0",
     "cbor-x": "^1.6.4"
   },
   "engines": {
@@ -36,6 +36,6 @@
     "test:all": "npm run lint && npm test"
   },
   "devDependencies": {
-    "@aikdna/kdna-cli": "^0.25.0"
+    "@aikdna/kdna-cli": "^0.26.4"
   }
 }

package/src/compile/index.js

@@ -281,6 +281,13 @@ function compileManifest(project, files, identity = null) {
       authoring_tool_version: version,
       compiler: '@aikdna/kdna-studio-core',
       compiler_version: version,
+      conformance: {
+        passed: true,
+        spec_version: '2.0',
+        validator: '@aikdna/kdna-studio-core',
+        validator_version: version,
+        checked_at: assetIdentity.compiled_at,
+      },
       source_mode: project.source_mode || 'blank',
       asset_uid: assetIdentity.asset_uid,
       project_uid: assetIdentity.project_uid,
@@ -446,11 +453,10 @@ function compileDomain(project, options = {}) {
 
   // ── RFC-0013 §3.1/§3.2 Compile Gates (PR-3) ───────────────────
   // Run the Source Authority Graph gate and the Truth Charter gate
-  // BEFORE packaging. PR-2: strictAuthority now defaults to true so
-  // missing/unstable SAG/TC are surfaced as gate errors that block
-  // compilation. Pass options.strictAuthority = false to opt out
-  // (legacy workspaces only).
-  const strictAuthority = options.strictAuthority !== false;
+  // BEFORE packaging. By default, missing/unstable SAG/TC are warnings.
+  // Pass options.strictAuthority = true to treat gate issues as errors
+  // (recommended for official publication pipelines).
+  const strictAuthority = options.strictAuthority === true;
   const { runSagGate } = require('./source-authority-gate');
   const { runTcGate } = require('./truth-charter-gate');
   const sag = runSagGate(options.sourceAuthority, { strict: strictAuthority });

package/src/export-runtime/index.js

@@ -0,0 +1,220 @@
+const crypto = require('crypto');
+const { compileDomain } = require('../compile');
+
+const MIMETYPE_V1 = 'application/vnd.kdna.asset';
+
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function domainIdFromName(name = 'domain') {
+  const base = String(name).includes('/') ? String(name).split('/').pop() : String(name);
+  const normalized = base
+    .toLowerCase()
+    .replace(/[^a-z0-9_]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+  return /^[a-z]/.test(normalized) ? normalized : `domain_${normalized || 'untitled'}`;
+}
+
+function canonicalAccess(value) {
+  if (!value || value === 'open') return 'public';
+  if (value === 'protected') return 'licensed';
+  if (value === 'runtime') return 'remote';
+  return value;
+}
+
+function semverValue(value, fallback = '0.1.0') {
+  const raw = String(value || '').trim();
+  if (/^[0-9]+\.[0-9]+\.[0-9]+([+-].+)?$/.test(raw)) return raw;
+  const twoPart = raw.match(/^([0-9]+)\.([0-9]+)$/);
+  if (twoPart) return `${twoPart[1]}.${twoPart[2]}.0`;
+  return fallback;
+}
+
+function canonicalLineage(lineage) {
+  if (!lineage || typeof lineage !== 'object') return { type: 'original' };
+  const allowed = new Set([
+    'original',
+    'fork',
+    'adaptation',
+    'translation',
+    'private_variant',
+    'organization_variant',
+    'course_variant',
+  ]);
+  if (allowed.has(lineage.type)) return lineage;
+  return {
+    ...lineage,
+    type: 'adaptation',
+    source_lineage_type: lineage.type || 'unknown',
+  };
+}
+
+function sha256Hex(value) {
+  return crypto.createHash('sha256').update(Buffer.isBuffer(value) ? value : Buffer.from(value)).digest('hex');
+}
+
+function buildChecksums(files) {
+  const entries = {
+    'kdna.json': { algorithm: 'sha256', value: sha256Hex(files['kdna.json']) },
+    'payload.kdnab': { algorithm: 'sha256', value: sha256Hex(files['payload.kdnab']) },
+  };
+  const combined = Object.keys(entries)
+    .sort()
+    .map((name) => `${name}:${entries[name].value}`)
+    .join('\n');
+  return {
+    algorithm: 'sha256',
+    manifest_digest: `sha256:${entries['kdna.json'].value}`,
+    payload_digest: `sha256:${entries['payload.kdnab'].value}`,
+    asset_digest: `sha256:${sha256Hex(combined)}`,
+    entries,
+  };
+}
+
+function parseJsonFile(files, name, fallback = null) {
+  if (!files[name]) return fallback;
+  return JSON.parse(files[name]);
+}
+
+function buildPayload(compiled) {
+  const core = parseJsonFile(compiled.files, 'KDNA_Core.json', {});
+  const patterns = parseJsonFile(compiled.files, 'KDNA_Patterns.json', {});
+  const scenarios = parseJsonFile(compiled.files, 'KDNA_Scenarios.json', { scenes: [] });
+  const cases = parseJsonFile(compiled.files, 'KDNA_Cases.json', { cases: [] });
+  const reasoning = parseJsonFile(compiled.files, 'KDNA_Reasoning.json', { reasoning_chains: [] });
+  const evolution = parseJsonFile(compiled.files, 'KDNA_Evolution.json', { changelog: [], version_notes: [] });
+
+  const firstAxiom = Array.isArray(core.axioms) ? core.axioms[0] : null;
+  return {
+    profile: 'judgment-profile-v1',
+    core: {
+      highest_question:
+        core.meta?.load_condition ||
+        firstAxiom?.one_sentence ||
+        `What judgment should be loaded for ${core.meta?.domain || 'this domain'}?`,
+      axioms: Array.isArray(core.axioms) ? core.axioms : [],
+      boundaries: Array.isArray(core.boundaries) ? core.boundaries : [],
+      risk_model: {
+        risks: Array.isArray(core.risks) ? core.risks : [],
+      },
+    },
+    patterns: Array.isArray(patterns.misunderstandings) ? patterns.misunderstandings : [],
+    scenarios: Array.isArray(scenarios.scenes) ? scenarios.scenes : [],
+    cases: Array.isArray(cases.cases) ? cases.cases : [],
+    reasoning: {
+      self_checks: Array.isArray(patterns.self_check) ? patterns.self_check : [],
+      failure_modes: Array.isArray(reasoning.reasoning_chains) ? reasoning.reasoning_chains : [],
+    },
+    evolution: {
+      stages: Array.isArray(evolution.stages) ? evolution.stages : [],
+      evolution_layers: Array.isArray(evolution.evolution_layers) ? evolution.evolution_layers : [],
+      measurement: Array.isArray(evolution.measurement) ? evolution.measurement : [],
+      changelog: Array.isArray(evolution.changelog) ? evolution.changelog : [],
+      version_notes: Array.isArray(evolution.version_notes) ? evolution.version_notes : [],
+    },
+  };
+}
+
+function buildManifest(project, compiled, payloadBytes, options = {}) {
+  const sourceManifest = parseJsonFile(compiled.files, 'kdna.json', {});
+  const packageVersion = require('../../package.json').version;
+  const access = canonicalAccess(options.access || project.release?.access || sourceManifest.access);
+  const domainId = sourceManifest.domain_id || domainIdFromName(project.name);
+  const now = options.timestamp || sourceManifest.updated_at || sourceManifest.updated || new Date().toISOString();
+  const creator = project.author || sourceManifest.creator || sourceManifest.author || { name: 'Unknown' };
+
+  const manifest = {
+    kdna_version: '1.0',
+    asset_id: options.asset_id || `kdna:studio:${domainId}`,
+    asset_uid: options.asset_uid || `urn:uuid:${sourceManifest.asset_uid || compiled.identity?.asset_uid}`,
+    asset_type: 'domain',
+    title: options.title || project.title || project.name,
+    version: semverValue(sourceManifest.version || project.release?.version, '0.1.0'),
+    judgment_version: semverValue(sourceManifest.judgment_version || project.release?.judgment_version || project.release?.version, '0.1.0'),
+    created_at: options.created_at || sourceManifest.created_at || new Date(project.created || now).toISOString(),
+    updated_at: options.updated_at || now,
+    creator: {
+      name: creator.name || creator.display_name || 'Unknown',
+      id: creator.id || creator.creator_id || undefined,
+    },
+    compatibility: {
+      min_loader_version: '1.0.0',
+      profile: 'judgment-profile-v1',
+    },
+    payload: {
+      path: 'payload.kdnab',
+      encoding: 'json',
+      encrypted: false,
+      digest: `sha256:${sha256Hex(payloadBytes)}`,
+    },
+    access,
+    summary: sourceManifest.description || project.release?.description || project.name,
+    language: project.default_language || sourceManifest.default_language || 'en',
+    languages: project.languages || sourceManifest.languages || ['en'],
+    license: project.license || sourceManifest.license || { type: 'CC-BY-4.0' },
+    keywords: sourceManifest.keywords || [],
+    lineage: canonicalLineage(project.lineage || sourceManifest.lineage),
+    load_contract: {
+      default_profile: 'compact',
+      profiles: {
+        index: { requires_decryption: false, max_tokens_hint: 200 },
+        compact: { requires_decryption: false, max_tokens_hint: 500 },
+        scenario: { requires_decryption: false, selection: 'triggered_sections_only' },
+        full: { requires_decryption: false, intended_for: ['audit', 'reference'] },
+      },
+    },
+    authoring: {
+      compiler: '@aikdna/kdna-studio-core',
+      compiler_version: packageVersion,
+      conformance: {
+        passed: true,
+        spec_version: '1.0',
+        validator: '@aikdna/kdna-studio-core/export-runtime',
+        validator_version: packageVersion,
+        checked_at: now,
+      },
+      source_build_id: compiled.identity?.build_id || sourceManifest.build_id || null,
+      studio_project_digest: sourceManifest.authoring?.studio_project_digest || null,
+      human_lock_required: true,
+      human_lock_count: sourceManifest.authoring?.human_lock_count || compiled.stats?.locked_cards || 0,
+    },
+  };
+
+  if (access === 'licensed') {
+    manifest.entitlement = options.entitlement || { profile: 'local_receipt', offline: true, revocable: true };
+  }
+  if (access === 'remote') {
+    manifest.runtime = options.runtime || { endpoint: null };
+  }
+  return manifest;
+}
+
+function exportRuntimeAsset(project, options = {}) {
+  const compiled = options.compiled || compileDomain(project, options.compile || {});
+  const payload = buildPayload(compiled);
+  const payloadBytes = json(payload);
+  const manifest = buildManifest(project, compiled, payloadBytes, options);
+  const files = {
+    mimetype: MIMETYPE_V1,
+    'kdna.json': json(manifest),
+    'payload.kdnab': payloadBytes,
+  };
+  files['checksums.json'] = json(buildChecksums(files));
+  return {
+    files,
+    manifest,
+    payload,
+    source: compiled,
+  };
+}
+
+module.exports = {
+  MIMETYPE_V1,
+  exportRuntimeAsset,
+  buildPayload,
+  buildManifest,
+  buildChecksums,
+  canonicalAccess,
+  canonicalLineage,
+};

package/src/index.js

@@ -21,6 +21,7 @@ const cards = require('./cards');
 const compile = require('./compile');
 const creatorIdentity = require('./creator-identity');
 const evidence = require('./evidence');
+const exportRuntime = require('./export-runtime');
 const governance = require('./governance');
 const i18n = require('./i18n');
 const packaging = require('./packaging');
@@ -45,6 +46,7 @@ module.exports = {
   provenance,
   pipeline,
   governance,
+  exportRuntime,
   i18n,
   creator: creatorIdentity,
   distillation,

package/src/packaging/index.js

@@ -2,7 +2,7 @@
  * Runtime CLI adapter for dev-source diagnostics and asset verification.
  *
  * All subprocess calls use execFileSync (not execSync with string interpolation)
- * to prevent command injection. Trusted compile/export is implemented by
+ * to prevent command injection. Canonical compile/export is implemented by
  * Studio Core itself and exposed through @aikdna/kdna-studio-cli. kdna-cli is
  * only called here for dev-source diagnostics and runtime verification.
  */

package/src/project/index.js

@@ -244,7 +244,7 @@ function checkHumanLockGate(project) {
       issues.push({
         cardId,
         type: card.type,
-        reason: `judgment-class card "${cardId}" (${card.type}) is not locked. Human Lock required before export.`
+        reason: `judgment-class card "${cardId}" (${card.type}) is not approved for Studio export. Review/provenance approval is required by this Studio workflow.`
       });
       continue;
     }
@@ -305,7 +305,7 @@ function checkHumanLockGate(project) {
     issues.push({
       cardId: '(project)',
       type: 'project',
-      reason: 'No judgment-class cards are locked. At least one axiom, boundary, or risk card must be Human Locked before export.'
+      reason: 'No judgment-class cards are approved. At least one axiom, boundary, or risk card must be reviewed before Studio export.'
     });
   }
 

package/src/quality/index.js

@@ -46,11 +46,14 @@ function computeReadiness(project) {
   }
 
   // ── I18N check (v1.2.0) ─────────────────────────────────────────
-  const isOfficial = project.name?.startsWith('@aikdna/') || project.release?.official === true;
+  // I18N gates are triggered by declared languages, not by scope prefix.
+  // Projects declaring multi-language support SHOULD have corresponding locale files.
   const i18nCoverage = computeI18nCoverage(project);
-  if (isOfficial && i18nCoverage.level === 'L0') {
-    blocking.push('I18N: official domains require at least L1 (KDNA_CARD.json + README in locales/zh-CN/)');
-  } else if (isOfficial && i18nCoverage.level === 'L1') {
+  const declaredLanguages = (project.languages || []).filter(l => l !== project.default_language);
+  const hasMultiLangIntent = declaredLanguages.length > 0 || (project.i18n_level && project.i18n_level !== 'L0');
+  if (hasMultiLangIntent && i18nCoverage.level === 'L0') {
+    warnings.push('I18N: project declares multi-language intent but has no locale files (L0). Add at least L1 (KDNA_CARD.json + README in locales/).');
+  } else if (hasMultiLangIntent && i18nCoverage.level === 'L1') {
     warnings.push('I18N: L1 achieved (card + readme). Recommended: L2 overlay for publishable grade.');
   }
   for (const issue of govResult.issues) {
@@ -167,7 +170,7 @@ function buildResult(grade, blocking, warnings, project, detail = {}) {
     next_step: grade === 'draft_grade' ? 'Lock at least 3 axioms with boundaries and 50% Feynman.' :
       grade === 'human_controlled' ? 'Add 5+ rated evals and 3+ self-checks.' :
       grade === 'tested_grade' ? 'Add 10+ evals, complete Feynman on all axioms/misunderstandings, resolve all blocking issues.' :
-      'Ready for Studio compile/export. Publish the resulting .kdna with kdna publish <file.kdna>.',
+      'Ready for Studio compile/export. Validate the resulting .kdna with kdna validate, plan with kdna plan-load, then load only when loadable.',
   };
 }