@aikdna/kdna-cli 0.16.10 → 0.17.0

package/README.md

@@ -1,10 +1,16 @@
 # @aikdna/kdna-cli
 
-**KDNA CLI is the runtime control plane for loading, validating, composing, testing, and governing domain judgment for AI agents.**
+**KDNA CLI is the official open-source reference implementation for KDNA validation, loading, packaging, comparison, registry access, and agent-facing runtime workflows.**
 
-KDNA CLI 是 AI Agent 加载、验证、组合、测试和治理领域判断的运行控制平面。
+It is the runtime control plane for loading, validating, composing, testing, and governing domain judgment for AI agents.
 
-Part of the [KDNA](https://github.com/aikdna/KDNA) ecosystem.
+KDNA CLI 是 KDNA 验证、加载、打包、比较、注册表访问和 Agent 运行时工作流的官方开源参考实现，也是 AI Agent 加载、验证、组合、测试和治理领域判断的运行控制平面。
+
+The CLI is how a KDNA cognitive kernel becomes usable by agents. It installs KDNA domains, verifies their structure and trust metadata, loads them into agent-readable form, compares judgment paths with and without KDNA, and records traces for audit.
+
+KDNA CLI 让一个认知内核真正被 Agent 使用。它负责安装 KDNA、验证结构与信任信息、把 KDNA 转换成 Agent 可加载的形式、对比加载前后的判断路径，并记录可审计的使用痕迹。
+
+Part of the [KDNA](https://github.com/aikdna/kdna) ecosystem.
 
 ## Install
 
@@ -28,99 +34,157 @@ kdna doctor --agents
 
 ### Domain Authoring
 
-| Command | Description |
-|---------|-------------|
-| `kdna init <name>` | Scaffold a new domain from template |
-| `kdna validate <path>` | Validate domain structure |
-| `kdna validate --schema <path>` | Schema-only validation |
-| `kdna pack <path>` | Pack into .kdna container |
-| `kdna pack <path> --encrypt --license <file>` | Pack encrypted .kdnae container |
-| `kdna unpack <file>` | Unpack .kdna or .kdnae container |
-| `kdna inspect <path>` | Inspect domain or .kdna file |
-| `kdna publish <path>` | Pack + sign + publish to registry |
-| `kdna publish --check <path>` | Quality gate check only |
-| `kdna version bump <level> [path]` | Bump domain version |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna init <name>` | Beta | Scaffold a new domain from template |
+| `kdna validate <path>` | Stable | Validate domain structure |
+| `kdna validate --schema <path>` | Stable | Schema-only validation |
+| `kdna pack <path>` | Beta | Pack into .kdna container |
+| `kdna pack <path> --encrypt --license <file>` | Beta | Pack encrypted .kdnae container |
+| `kdna unpack <file>` | Beta | Unpack .kdna or .kdnae container |
+| `kdna inspect <path>` | Beta | Inspect domain or .kdna file |
+| `kdna publish <path>` | Experimental | Pack + sign + publish to registry |
+| `kdna publish --check <path>` | Experimental | Quality gate check only |
+| `kdna version bump <level> [path]` | Beta | Bump domain version |
 
 ### Agent Runtime
 
-| Command | Description |
-|---------|-------------|
-| `kdna available [--json]` | List installed domains with v2.1 fields |
-| `kdna match "<task>" [--json]` | Signal matching — find relevant domains |
-| `kdna load <name> [--as=prompt\|json\|raw]` | Emit domain in agent-ready format |
-| `kdna postvalidate <name> --output <file>` | Post-generation judgment check |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna available [--json]` | Beta | List installed domains with v2.1 fields |
+| `kdna match "<task>" [--json]` | Beta | Signal matching — find relevant domains |
+| `kdna load <name> [--as=prompt\|json\|raw]` | Beta | Emit domain in agent-ready format |
+| `kdna postvalidate <name> --output <file>` | Beta | Post-generation judgment check |
 
 ### Testing & Verification
 
-| Command | Description |
-|---------|-------------|
-| `kdna verify <name>` | 3-layer: structure + trust + judgment |
-| `kdna compare <name> --input "..."` | With/without KDNA reasoning diff |
-| `kdna compare <name> --input "..." --report-md` | Markdown report with scoring |
-| `kdna compare <name> --input "..." --report-json` | JSON report with scoring |
-| `kdna diff <name>@<v1> <name>@<v2>` | Judgment-level diff between versions |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna verify <name>` | Beta | 3-layer: structure + trust + judgment |
+| `kdna compare <name> --input "..."` | Beta | With/without KDNA reasoning diff |
+| `kdna compare <name> --input "..." --report-md` | Beta | Markdown report with scoring |
+| `kdna compare <name> --input "..." --report-json` | Beta | JSON report with scoring |
+| `kdna diff <name>@<v1> <name>@<v2>` | Beta | Judgment-level diff between versions |
 
 ### Diagnostics & Trace
 
-| Command | Description |
-|---------|-------------|
-| `kdna doctor` | System health check |
-| `kdna doctor --agents` | Agent integration check (Codex/Claude/OpenCode/Cursor/Gemini) |
-| `kdna doctor --json` | Machine-readable health report |
-| `kdna trace` | View recent load/postvalidate traces |
-| `kdna trace --json` | Machine-readable trace output |
-| `kdna trace --export <file>` | Export traces for audit |
-| `kdna trace --since 7d\|30d\|90d` | Filter by time range |
-| `kdna history` | Recent domain usage (last 20) |
-| `kdna history --stats` | Aggregate by domain and agent |
-| `kdna history --domain <name>` | Filter by domain |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna doctor` | Beta | System health check |
+| `kdna doctor --agents` | Beta | Agent integration check (Codex/Claude/OpenCode/Cursor/Gemini) |
+| `kdna doctor --json` | Beta | Machine-readable health report |
+| `kdna trace` | Experimental | View recent load/postvalidate traces |
+| `kdna trace --json` | Experimental | Machine-readable trace output |
+| `kdna trace --export <file>` | Experimental | Export traces for audit |
+| `kdna trace --since 7d\|30d\|90d` | Experimental | Filter by time range |
+| `kdna history` | Experimental | Recent domain usage (last 20) |
+| `kdna history --stats` | Experimental | Aggregate by domain and agent |
+| `kdna history --domain <name>` | Experimental | Filter by domain |
 
 ### License & Authorization
 
-| Command | Description |
-|---------|-------------|
-| `kdna license generate <domain> --to <email>` | Generate signed license |
-| `kdna license install <license.json>` | Register license for auto-decrypt |
-| `kdna license verify <license.json>` | Verify license signature and validity |
-| `kdna license bind <license.json>` | Bind license to this machine |
-| `kdna license show <license.json>` | Display license details |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna license generate <domain> --to <email>` | Experimental | Generate signed license |
+| `kdna license install <license.json>` | Experimental | Register license for auto-decrypt |
+| `kdna license verify <license.json>` | Experimental | Verify license signature and validity |
+| `kdna license bind <license.json>` | Experimental | Bind license to this machine |
+| `kdna license show <license.json>` | Experimental | Display license details |
 
 ### Cluster Composition
 
-| Command | Description |
-|---------|-------------|
-| `kdna cluster lint <path>` | Validate cluster manifest |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna cluster lint <path>` | Planned | Validate cluster manifest |
 
 ### Registry & Distribution
 
-| Command | Description |
-|---------|-------------|
-| `kdna install <name>` | Install domain from registry |
-| `kdna install ./file.kdna` | Install from local .kdna file |
-| `kdna install ./file.kdnae` | Install from encrypted .kdnae (auto-decrypt with license) |
-| `kdna remove <name>` | Uninstall a domain |
-| `kdna update <name>` | Update installed domain |
-| `kdna info <name>` | Show domain metadata and trust status |
-| `kdna list [--available]` | List installed or available domains |
-| `kdna search <keyword>` | Search registry |
-| `kdna registry refresh` | Refresh registry cache |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna install <name>` | Beta | Install domain from registry |
+| `kdna install ./file.kdna` | Beta | Install from local .kdna file |
+| `kdna install ./file.kdnae` | Beta | Install from encrypted .kdnae (auto-decrypt with license) |
+| `kdna remove <name>` | Beta | Uninstall a domain |
+| `kdna update <name>` | Beta | Update installed domain |
+| `kdna info <name>` | Beta | Show domain metadata and trust status |
+| `kdna list [--available]` | Beta | List installed or available domains |
+| `kdna search <keyword>` | Beta | Search registry |
+| `kdna registry refresh` | Beta | Refresh registry cache |
 
 ### Identity & Signing
 
-| Command | Description |
-|---------|-------------|
-| `kdna identity init` | Generate Ed25519 signing key |
-| `kdna identity show` | Display public key and buyer ID |
-| `kdna identity export [--out]` | Backup private key (encrypted) |
-| `kdna identity import <file>` | Restore identity from backup |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna identity init` | Experimental | Generate Ed25519 signing key |
+| `kdna identity show` | Experimental | Display public key and buyer ID |
+| `kdna identity export [--out]` | Experimental | Backup private key (encrypted) |
+| `kdna identity import <file>` | Experimental | Restore identity from backup |
 
 ### Setup
 
-| Command | Description |
-|---------|-------------|
-| `kdna setup` | One-command setup: CLI + skill + data root |
+| Command | Status | Description |
+|---------|--------|-------------|
+| `kdna setup` | Beta | One-command setup: CLI + skill + data root |
+
+---
+
+## SPEC Compatibility
+
+KDNA CLI follows the canonical KDNA domain structure defined in [`aikdna/kdna`](https://github.com/aikdna/kdna).
+
+A valid KDNA domain is a lowercase `snake_case` folder. A complete domain may include up to six files:
+
+- `KDNA_Core.json`
+- `KDNA_Patterns.json`
+- `KDNA_Scenarios.json`
+- `KDNA_Cases.json`
+- `KDNA_Reasoning.json`
+- `KDNA_Evolution.json`
+
+The minimum valid domain requires:
+
+- `KDNA_Core.json`
+- `KDNA_Patterns.json`
+
+Each file must include `meta.version`, `meta.domain`, `meta.created`, `meta.purpose`, and `meta.load_condition`.
+
+---
+
+## Default Registry
+
+By default, KDNA CLI uses the official KDNA registry. Users may override it with `KDNA_REGISTRY_URL`.
+
+```bash
+# Use the official registry (default)
+kdna install @aikdna/writing
+
+# Use a custom registry
+export KDNA_REGISTRY_URL="https://my-registry.example.com/domains.json"
+kdna install @myorg/internal
+```
+
+---
+
+## Open Source and Commercial Boundary
+
+KDNA keeps the protocol, schemas, validator, core CLI, benchmark tools, and reference examples open source.
+
+Commercial or hosted layers may include:
+
+- Managed registry services
+- Quality badge review workflows
+- Hosted runtime guard
+- Enterprise private registry
+- Team collaboration in KDNA Studio
+- Licensed/private judgment asset distribution
+
+KDNA supports both open judgment assets and licensed/private judgment assets. Open domains remain the default path for community adoption, while encrypted containers and licenses support professional and enterprise distribution.
+
+KDNA 同时支持开放判断资产和授权/私有判断资产。开放 domain 是社区采用的默认路径；加密容器和 license 用于专业资产与企业分发。
+
+---
 
-### Environment Variables
+## Environment Variables
 
 | Variable | Purpose |
 |----------|---------|
@@ -165,7 +229,7 @@ kdna license verify --json <file>
 | Authoring | KDNA Studio | Human-led judgment production |
 | Consumption | KDNAChat | Load, use, compare |
 | Governance | KDNA Governance Console | Approve, release, audit |
-| Distribution | Registry | Discover, install, trade |
+| Distribution | Registry | Discover, install, license, distribute |
 
 ## Development
 
@@ -178,9 +242,9 @@ npm test
 
 ## Related
 
-- [@aikdna/kdna-core](https://github.com/aikdna/KDNA/tree/main/packages/kdna-core) — Pure logic library
+- [@aikdna/kdna-core](https://github.com/aikdna/kdna/tree/main/packages/kdna-core) — Pure logic library
 - [KDNA Registry](https://github.com/aikdna/kdna-registry) — Domain catalog
-- [KDNA SPEC](https://github.com/aikdna/KDNA) — Protocol specification
+- [KDNA SPEC](https://github.com/aikdna/kdna) — Protocol specification
 - [aikdna.com](https://aikdna.com) — Website
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/kdna-cli",
-  "version": "0.16.10",
+  "version": "0.17.0",
   "description": "KDNA CLI — create, validate, install, and manage domain cognition packages for AI agents.",
   "type": "commonjs",
   "bin": {
@@ -31,7 +31,6 @@
     "kdna-cli",
     "ai-agent",
     "domain-cognition",
-    "knowledge-dna",
     "cli"
   ],
   "license": "Apache-2.0",
@@ -47,7 +46,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@aikdna/kdna-core": "^0.3.0"
+    "@aikdna/kdna-core": "^0.4.0"
   },
   "optionalDependencies": {
     "ajv": "^8.17.1",

package/src/agent.js

@@ -365,12 +365,44 @@ function cmdLoad(input, args = []) {
     if (manifest.replaced_by) console.error(`Try: ${manifest.replaced_by}`);
     process.exit(2);
   }
+
+  // ═══ Trust check before loading ═══
+  const loadWarnings = [];
+  const signature = manifest.signature;
+  const isPlaceholder = !signature || signature === '' || signature.includes('placeholder');
+  if (isPlaceholder) {
+    loadWarnings.push('⚠  Domain is unsigned — no cryptographic proof of authorship. Trust depends on source.');
+  }
+  if (manifest.status === 'deprecated') {
+    loadWarnings.push(`⚠  Domain is deprecated${manifest.replaced_by ? ', replaced by ' + manifest.replaced_by : ''}.`);
+  }
+  const riskLevel = manifest.risk_level || 'R1';
+  if (riskLevel === 'R3' || riskLevel === 'R4') {
+    loadWarnings.push(`⚠  High risk domain (${riskLevel}) — may influence agent behavior in safety-critical ways.`);
+    if (manifest.quality_badge === 'untested' || !manifest.quality_badge) {
+      loadWarnings.push('⚠  High risk + untested — load only if you trust the source and understand the risks.');
+    }
+  }
+  if (loadWarnings.length > 0) {
+    console.error(loadWarnings.join('\n'));
+  }
   const core = readJson(path.join(dir, 'KDNA_Core.json')) || {};
   const pat = readJson(path.join(dir, 'KDNA_Patterns.json')) || {};
 
   // JSON format
   if (format === 'json') {
-    process.stdout.write(JSON.stringify({ manifest, core, patterns: pat }, null, 2) + '\n');
+    process.stdout.write(JSON.stringify({
+      manifest,
+      core,
+      patterns: pat,
+      trust: {
+        signature: isPlaceholder ? 'unsigned' : 'present',
+        risk_level: riskLevel,
+        deprecated: manifest.status === 'deprecated',
+        yanked: false,
+        warnings: loadWarnings,
+      },
+    }, null, 2) + '\n');
     recordTrace({
       timestamp: new Date().toISOString(),
       agent: detectAgent(),
@@ -910,4 +942,346 @@ function cmdPostvalidate(args = []) {
   process.exit(results.violations.length ? 1 : 0);
 }
 
-module.exports = { cmdAvailable, cmdMatch, cmdLoad, cmdSelect, cmdPostvalidate };
+// ─── kdna route ─────────────────────────────────────────────────────────
+
+function cmdRoute(taskText, args = []) {
+  const wantJson = args.includes('--json');
+
+  if (!taskText) {
+    const err = { error: 'Usage: kdna route "<task description>" [--json] [--discover]' };
+    if (wantJson) { console.log(JSON.stringify(err)); process.exit(2); }
+    console.error(err.error);
+    process.exit(2);
+  }
+
+  const traceId = `route_${require('crypto').randomUUID()}`;
+  const taskTokens = tokenize(taskText);
+  const installed = listInstalled();
+  const result = {
+    status: 'SKIP_NO_JUDGMENT_NEEDED',
+    action: 'skip',
+    needs_kdna: false,
+    selected_domain: null,
+    reason: '',
+    confidence: 0,
+    candidates: [],
+    rejected_domains: [],
+    trust: null,
+    ambiguity: null,
+    registry_suggestions: [],
+    auto_install: false,
+    trace_id: traceId,
+    created_at: new Date().toISOString(),
+  };
+
+  // ═══ Gate 1: Intent — does this task need domain judgment? ═══
+  const judgmentKeywords = [
+    'review', 'diagnose', 'critique', 'evaluate', 'assess', 'judge',
+    'should i', 'is this good', 'is this correct', 'how would you rate',
+    '分析', '诊断', '评估', '判断', '审查', '该怎么', '好不好',
+  ];
+  const mechanicalKeywords = [
+    'format', 'translate', 'convert', 'list', 'find', 'lookup', 'search',
+    'run', 'execute', 'compile', 'build', 'fix syntax', 'fix the bug',
+    '格式化', '翻译', '转换', '列出', '查找', '搜索', '运行', '执行', '编译', '修复语法',
+  ];
+
+  const taskLower = taskText.toLowerCase();
+  const hasJudgmentSignal = judgmentKeywords.some(k => taskLower.includes(k));
+  const hasMechanicalSignal = mechanicalKeywords.some(k => taskLower.includes(k));
+
+  result.needs_kdna = hasJudgmentSignal && !hasMechanicalSignal;
+
+  if (!result.needs_kdna) {
+    result.status = 'SKIP_NO_JUDGMENT_NEEDED';
+    result.action = 'skip';
+    result.reason = hasMechanicalSignal
+      ? 'task is mechanical — no domain judgment required'
+      : 'task does not appear to need domain judgment';
+    if (wantJson) { console.log(JSON.stringify(result, null, 2)); return; }
+    console.log('SKIP (no judgment needed)');
+    return;
+  }
+
+  if (!installed.length) {
+    result.status = 'SKIP_NO_LOCAL_DOMAIN';
+    result.action = 'skip';
+    result.reason = 'task may benefit from judgment, but no KDNA domains are installed';
+    if (wantJson) { console.log(JSON.stringify(result, null, 2)); return; }
+    console.log('SKIP (no domains installed)');
+    return;
+  }
+
+  // ═══ Gate 2: Negative Match First — check does_not_apply_when ═══
+  // ═══ Gate 3: Domain Fit — evaluate applies_when + relevance ═══
+  const candidates = [];
+
+  for (const e of installed) {
+    const manifest = readJson(path.join(e.dir, 'kdna.json')) || {};
+    if (manifest.yanked === true) {
+      result.rejected_domains.push({
+        domain: manifest.name || e.full,
+        triggered_rule: 'yanked',
+        reason: 'domain has been yanked',
+      });
+      continue;
+    }
+
+    const core = readJson(path.join(e.dir, 'KDNA_Core.json')) || {};
+
+    // Negative match: does_not_apply_when
+    let disqualified = null;
+    for (const a of core.axioms || []) {
+      for (const d of a.does_not_apply_when || []) {
+        const score = overlapScore(taskTokens, d);
+        if (score.hits >= 2) {
+          disqualified = { axiom: a.id, text: d, hits: score.hits };
+          break;
+        }
+      }
+      if (disqualified) break;
+    }
+
+    if (disqualified) {
+      result.rejected_domains.push({
+        domain: manifest.name || e.full,
+        triggered_rule: `${disqualified.axiom}.does_not_apply_when`,
+        reason: `"${disqualified.text.slice(0, 100)}"`,
+      });
+      continue;
+    }
+
+    // Positive fit: applies_when + domain relevance
+    let fitScore = 0;
+    const fitReasons = [];
+
+    for (const a of core.axioms || []) {
+      for (const ap of a.applies_when || []) {
+        const score = overlapScore(taskTokens, ap);
+        if (score.hits >= 2) {
+          fitScore += score.hits * 3;
+          fitReasons.push({ source: a.id, hits: score.hits, text: ap.slice(0, 120) });
+        }
+      }
+    }
+    fitScore += domainRelevanceScore(taskTokens, manifest);
+
+    // Confidence based on fitScore normalized
+    const confidence = Math.min(0.95, fitScore > 0 ? 0.5 + fitScore * 0.05 : 0.15);
+
+    candidates.push({
+      domain: manifest.name || e.full,
+      version: manifest.version || '?',
+      status: manifest.status || 'experimental',
+      score: fitScore,
+      confidence,
+      reasons: fitReasons.slice(0, 5),
+      description: manifest.description || '',
+    });
+  }
+
+  // Sort by score
+  candidates.sort((a, b) => b.score - a.score);
+
+  // ═══ Gate 4: Decision ═══
+  const strongCandidates = candidates.filter(c => c.score >= 6);
+  const weakCandidates = candidates.filter(c => c.score > 0 && c.score < 6);
+
+  if (strongCandidates.length === 0 && weakCandidates.length === 0) {
+    // No matches at all
+    result.status = 'SKIP_NO_LOCAL_DOMAIN';
+    result.action = 'skip';
+    result.reason = 'no installed domain matches this task';
+    if (result.rejected_domains.length > 0) {
+      result.reason += ` (${result.rejected_domains.length} domains explicitly excluded by does_not_apply_when)`;
+    }
+    result.candidates = candidates.map(c => ({
+      domain: c.domain,
+      decision: 'rejected',
+      reason: 'insufficient match score',
+      confidence: c.confidence,
+    }));
+  } else if (strongCandidates.length > 1) {
+    // Multiple strong matches — ambiguity
+    result.status = 'ASK_AMBIGUOUS_DOMAIN';
+    result.action = 'ask';
+    result.reason = `${strongCandidates.length} domains strongly match this task with different judgment frames`;
+
+    result.ambiguity = {
+      domains: strongCandidates.slice(0, 3).map(c => ({
+        domain: c.domain,
+        description: c.description,
+        judgment_frame: c.reasons.length > 0 ? c.reasons[0].text : c.description,
+        risk_if_wrong: `may misclassify the task as a ${c.domain.split('/').pop()} problem`,
+      })),
+      recommendation: 'Choose the domain whose judgment frame best matches the task intent. Do not blend domains.',
+    };
+
+    result.candidates = strongCandidates.map(c => ({
+      domain: c.domain, decision: 'ambiguous', reason: `score ${c.score}`, confidence: c.confidence,
+    }));
+  } else if (strongCandidates.length === 1) {
+    // One strong match + possible weak matches
+    const selected = strongCandidates[0];
+    result.candidates = [
+      { domain: selected.domain, decision: 'strong_match', reason: `score ${selected.score}`, confidence: selected.confidence },
+      ...weakCandidates.map(c => ({ domain: c.domain, decision: 'weak_match', reason: `score ${c.score}`, confidence: c.confidence })),
+    ];
+
+    // ═══ Trust Gate ═══
+    const trust = checkTrust(selected.domain);
+    result.trust = trust;
+
+    if (!trust.passed) {
+      result.status = 'BLOCK_TRUST_FAILED';
+      result.action = 'block';
+      result.reason = `domain matched but trust check failed: ${trust.failures.join(', ')}`;
+    } else {
+      result.status = 'LOAD_STRONG_FIT';
+      result.action = 'load';
+      result.selected_domain = selected.domain;
+      result.confidence = selected.confidence;
+      result.reason = `match: "${selected.description.slice(0, 100)}"`;
+    }
+  } else {
+    // Only weak matches — skip
+    result.status = 'SKIP_WEAK_FIT';
+    result.action = 'skip';
+    result.reason = weakCandidates.length > 0
+      ? `${weakCandidates.length} domain(s) have weak match only — skipping to avoid contamination`
+      : 'no installed domain matches this task';
+    result.candidates = weakCandidates.map(c => ({
+      domain: c.domain, decision: 'weak_match', reason: `score ${c.score}`, confidence: c.confidence,
+    }));
+  }
+
+  // Add rejected domains to candidates array for full trace
+  for (const r of result.rejected_domains) {
+    result.candidates.push({
+      domain: r.domain,
+      decision: 'rejected',
+      reason: r.reason,
+      confidence: 0,
+      matched_does_not_apply_when: r.triggered_rule,
+    });
+  }
+
+  if (wantJson) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  // Human output
+  console.log(`Task: ${taskText.slice(0, 100)}${taskText.length > 100 ? '…' : ''}`);
+  console.log(`Route: ${result.status} → ${result.action}`);
+  if (result.reason) console.log(`Reason: ${result.reason}`);
+  if (result.selected_domain) console.log(`Domain: ${result.selected_domain}`);
+  if (result.rejected_domains.length) {
+    console.log(`Rejected: ${result.rejected_domains.map(r => r.domain).join(', ')}`);
+  }
+}
+
+function checkTrust(domainName, options = {}) {
+  const failures = [];
+  const warnings = [];
+  const installed = listInstalled();
+  const entry = installed.find(e => `${e.scope}/${e.ident}` === domainName || e.full === domainName);
+  if (!entry) {
+    failures.push('domain not found in installed directory');
+    return { passed: false, failures, warnings };
+  }
+
+  const manifest = readJson(path.join(entry.dir, 'kdna.json')) || {};
+  const core = readJson(path.join(entry.dir, 'KDNA_Core.json')) || {};
+  const evolution = readJson(path.join(entry.dir, 'KDNA_Evolution.json')) || {};
+
+  // 1. Yank check
+  if (manifest.yanked === true) {
+    failures.push('domain is yanked');
+  }
+
+  // 2. Deprecation check
+  if (manifest.status === 'deprecated') {
+    warnings.push(`domain is deprecated${manifest.replaced_by ? ', replaced by ' + manifest.replaced_by : ''}`);
+  }
+
+  // 3. Signature check
+  const signature = manifest.signature;
+  const isPlaceholder = !signature || signature === '' || signature.includes('placeholder');
+  if (manifest.access === 'licensed' || manifest.access === 'runtime') {
+    if (isPlaceholder) {
+      failures.push('commercial domain has no valid signature');
+    }
+  } else if (isPlaceholder) {
+    warnings.push('domain is unsigned — trust depends on source');
+  }
+
+  // 4. Risk level check
+  const riskLevel = manifest.risk_level || entry.risk_level || 'R1';
+  const riskMap = { R0: 0, R1: 1, R2: 2, R3: 3, R4: 4 };
+  const riskNum = riskMap[riskLevel] || 1;
+  if (riskNum >= 3) {
+    warnings.push(`domain risk level is ${riskLevel} — high-risk judgment may influence agent behavior`);
+  }
+  if (riskNum >= 2 && (manifest.quality_badge === 'untested' || !manifest.quality_badge)) {
+    warnings.push(`risk level ${riskLevel} with quality_badge '${manifest.quality_badge || 'none'}' — consider requiring review`);
+  }
+
+  // 5. SPEC compatibility check
+  const specVersion = manifest.spec_version || manifest.kdna_spec || 'unknown';
+  const supportedSpecs = ['1.0-rc', '1.0', '0.7'];
+  if (!supportedSpecs.includes(specVersion)) {
+    warnings.push(`SPEC version '${specVersion}' may not be fully compatible with current loader`);
+  }
+
+  // 6. License validity (commercial domains)
+  if (manifest.access === 'licensed' || manifest.access === 'runtime') {
+    const licenseStorePath = path.join(process.env.HOME || '.', '.kdna', 'licenses.json');
+    let licenseOk = false;
+    try {
+      if (require('fs').existsSync(licenseStorePath)) {
+        const store = JSON.parse(require('fs').readFileSync(licenseStorePath, 'utf8'));
+        const keys = store.keys || {};
+        for (const [hash, entry] of Object.entries(keys)) {
+          if (entry.active && entry.domain_id === domainName) {
+            if (!entry.expires_at || new Date(entry.expires_at) > new Date()) {
+              licenseOk = true;
+              break;
+            }
+          }
+        }
+        if (!licenseOk) {
+          warnings.push('commercial domain has no active license — install with: kdna install ' + domainName + ' --license <key>');
+        }
+      } else {
+        warnings.push('no license store found — commercial domain may require a license');
+      }
+    } catch { /* license check unavailable */ }
+  }
+
+  // 7. Human Lock check (judgment-class cards)
+  const judgmentCardTypes = ['axiom', 'boundary', 'risk'];
+  const axioms = core.axioms || [];
+  const hasJudgmentCards = axioms.length > 0;
+  if (hasJudgmentCards) {
+    const humanLocks = evolution.human_locks || [];
+    const lockedAxioms = axioms.filter(a => {
+      // Check if axiom has a human_lock field OR if an evolution lock covers it
+      return a.human_lock || humanLocks.some(hl => hl.lock_type === 'accept');
+    }).length;
+    if (lockedAxioms === 0 && humanLocks.length === 0) {
+      warnings.push('domain has no Human Lock records — judgment-class content may not be human-verified');
+    }
+  }
+
+  return {
+    passed: failures.length === 0,
+    failures,
+    warnings,
+    riskLevel,
+    specVersion,
+    signatureValid: !isPlaceholder,
+  };
+}
+
+module.exports = { cmdAvailable, cmdMatch, cmdLoad, cmdSelect, cmdPostvalidate, cmdRoute, checkTrust };

package/src/cli.js

@@ -26,6 +26,7 @@ const {
   cmdSelect,
   cmdLoad,
   cmdPostvalidate,
+  cmdRoute,
 } = require('./cmds/quality');
 const { cmdCluster } = require('./cmds/cluster');
 const { cmdIdentity } = require('./cmds/identity');
@@ -101,6 +102,7 @@ Studio Integration (Phase 1):
   studio readiness <project.json>  Generate domain readiness card
 
 Agent Runtime:
+  route "<task>" [--json] [--discover]  5-Gate 7-State routing decision
   available [--json]               List installed domains with v2.1 fields
   match "<task>" [--json]          Signal matching — find relevant domains
   select --input "..." [--json]    Selection policy — decide which domains to load
@@ -294,7 +296,7 @@ switch (cmd) {
     if (!target) error('Usage: kdna card <path> [--json] [--locale zh-CN]');
     const localeIdx = args.indexOf('--locale');
     const locale = localeIdx >= 0 ? args[localeIdx + 1] : null;
-    cmdCard(target, locale);
+    cmdCard(target, args.includes('--json'), locale);
     break;
   }
   case 'verify': {
@@ -340,6 +342,10 @@ switch (cmd) {
     cmdSelect(args);
     break;
   }
+  case 'route': {
+    cmdRoute(args);
+    break;
+  }
   case 'postvalidate': {
     cmdPostvalidate(args);
     break;
@@ -513,7 +519,7 @@ switch (cmd) {
       const idx = args.indexOf('--check');
       const target = args[idx + 1] || args.filter((a) => !a.startsWith('--'))[1] || '.';
       if (!target || target.startsWith('--')) error('Usage: kdna publish --check <path>');
-      cmdPublishCheck(target);
+      cmdPublishCheck(target, args);
     } else {
       const { cmdPublish } = require('./publish');
       const target = args.filter((a) => !a.startsWith('--'))[1];

package/src/cmds/domain.js

@@ -11,38 +11,31 @@ const {
   ENCRYPTED_FILES,
 } = require('./encrypt');
 
-// ─── Validate ────────────────────────────────────────────────────────
-
-function cmdValidate(dir, schemaOnly, jsonMode = false) {
-  const abs = path.resolve(dir);
-  if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
-    error(`Not a directory: ${abs}`, EXIT.INPUT_ERROR);
-  }
-
-  const { lintDomain, validateDomainSchema, validateCrossFile } = require('@aikdna/kdna-core');
-
-  // Resolve schemas from @aikdna/kdna-core package
-  const SCHEMA_DIR = path.join(
-    path.dirname(require.resolve('@aikdna/kdna-core/package.json')),
-    'schema',
-  );
-
-  // Read all KDNA JSON files
-  const files = fs.readdirSync(abs).filter((f) => f.endsWith('.json') && f !== 'kdna.json');
+const KDNA_DOMAIN_FILES = new Set([
+  'KDNA_Core.json',
+  'KDNA_Patterns.json',
+  'KDNA_Scenarios.json',
+  'KDNA_Cases.json',
+  'KDNA_Reasoning.json',
+  'KDNA_Evolution.json',
+]);
+
+function readKDNAContentFiles(abs) {
   const dataMap = {};
-  const schemaMap = {};
-
-  for (const f of files) {
+  const parseErrors = [];
+  for (const f of fs.readdirSync(abs).filter((name) => KDNA_DOMAIN_FILES.has(name))) {
     try {
       dataMap[f] = JSON.parse(fs.readFileSync(path.join(abs, f), 'utf8'));
     } catch (e) {
       dataMap[f] = null;
-      console.error(`  JSON parse error in ${f}: ${e.message}`);
+      parseErrors.push(`${f}: ${e.message}`);
     }
   }
+  return { dataMap, parseErrors };
+}
 
-  // Schema validation — always load all available schemas
-  const FILE_TO_SCHEMA = {
+function loadSchemaMap(schemaDir) {
+  const fileToSchema = {
     'KDNA_Core.json': 'KDNA_Core.schema.json',
     'KDNA_Patterns.json': 'KDNA_Patterns.schema.json',
     'KDNA_Scenarios.json': 'KDNA_Scenarios.schema.json',
@@ -51,10 +44,11 @@ function cmdValidate(dir, schemaOnly, jsonMode = false) {
     'KDNA_Evolution.json': 'KDNA_Evolution.schema.json',
   };
 
+  const schemaMap = {};
   const loadedSchemas = [];
   const missingSchemas = [];
-  for (const [, schemaFile] of Object.entries(FILE_TO_SCHEMA)) {
-    const schemaPath = path.join(SCHEMA_DIR, schemaFile);
+  for (const schemaFile of Object.values(fileToSchema)) {
+    const schemaPath = path.join(schemaDir, schemaFile);
     if (fs.existsSync(schemaPath)) {
       try {
         schemaMap[schemaFile] = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
@@ -67,50 +61,132 @@ function cmdValidate(dir, schemaOnly, jsonMode = false) {
     }
   }
 
-  if (missingSchemas.length) {
-    console.log(
-      `  Note: ${missingSchemas.length} schema file(s) not found (optional file schemas): ${missingSchemas.join(', ')}`,
-    );
-    console.log(`  Schema dir: ${SCHEMA_DIR}`);
-  }
+  return { schemaMap, loadedSchemas, missingSchemas };
+}
 
-  // Validation layers
-  const errors = [];
+function validateDomainDirectory(abs, schemaMap, schemaOnly) {
+  const { lintDomain, validateDomainSchema, validateCrossFile } = require('@aikdna/kdna-core');
+  const { dataMap, parseErrors } = readKDNAContentFiles(abs);
+  const errors = parseErrors.map((msg) => `JSON parse error in ${msg}`);
   const warnings = [];
 
-  // Layer 1: Lint (structural + content checks)
   if (!schemaOnly) {
     const lintResult = lintDomain(dataMap);
     errors.push(...lintResult.errors);
     warnings.push(...lintResult.warnings);
   }
 
-  // Layer 2: JSON Schema validation against loaded schemas
   const schemaResult = validateDomainSchema(dataMap, schemaMap);
   errors.push(...schemaResult.errors);
   warnings.push(...schemaResult.warnings);
 
-  // Layer 3: Cross-file consistency
   const crossResult = validateCrossFile(dataMap);
   errors.push(...crossResult.errors);
   warnings.push(...crossResult.warnings);
 
-  const validCount = Object.keys(dataMap).filter((k) => dataMap[k]).length;
+  return {
+    path: abs,
+    valid: errors.length === 0,
+    files: Object.keys(dataMap).filter((k) => dataMap[k]).length,
+    errors,
+    warnings,
+  };
+}
+
+function isClusterDirectory(abs) {
+  const manifest = readJson(path.join(abs, 'kdna.json'));
+  return !!(
+    manifest?.cluster ||
+    fs.existsSync(path.join(abs, 'KDNA_Cluster.json')) ||
+    fs.existsSync(path.join(abs, 'cluster_manifest.json'))
+  );
+}
+
+function validateClusterDirectory(abs, schemaMap, schemaOnly) {
+  const manifest = readJson(path.join(abs, 'kdna.json')) || {};
+  const clusterManifest = readJson(path.join(abs, 'KDNA_Cluster.json')) || {};
+  const fallbackManifest = readJson(path.join(abs, 'cluster_manifest.json')) || {};
+  const subDomains = manifest.sub_domains || fallbackManifest.domains || [];
+  const errors = [];
+  const warnings = [];
+
+  if (!Array.isArray(subDomains) || subDomains.length === 0) {
+    errors.push('Cluster has no sub_domains/domains list to validate');
+  }
+
+  const domains = [];
+  for (const name of subDomains) {
+    const domainPath = path.join(abs, name);
+    if (!fs.existsSync(domainPath) || !fs.statSync(domainPath).isDirectory()) {
+      errors.push(`Cluster sub-domain not found: ${name}`);
+      continue;
+    }
+    const result = validateDomainDirectory(domainPath, schemaMap, schemaOnly);
+    domains.push({ name, ...result });
+    warnings.push(...result.warnings.map((w) => `${name}: ${w}`));
+    errors.push(...result.errors.map((e) => `${name}: ${e}`));
+  }
+
+  if (!manifest.cluster && !clusterManifest.name && !fallbackManifest.name) {
+    warnings.push('Cluster metadata is minimal: no cluster marker or cluster name found');
+  }
+
+  return {
+    path: abs,
+    valid: errors.length === 0,
+    cluster: true,
+    domains,
+    files: domains.reduce((sum, d) => sum + d.files, 0),
+    errors,
+    warnings,
+  };
+}
+
+// ─── Validate ────────────────────────────────────────────────────────
+
+function cmdValidate(dir, schemaOnly, jsonMode = false) {
+  const abs = path.resolve(dir);
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+    error(`Not a directory: ${abs}`, EXIT.INPUT_ERROR);
+  }
+
+  // Resolve schemas from @aikdna/kdna-core package
+  const SCHEMA_DIR = path.join(
+    path.dirname(require.resolve('@aikdna/kdna-core/package.json')),
+    'schema',
+  );
+
+  const { schemaMap, loadedSchemas, missingSchemas } = loadSchemaMap(SCHEMA_DIR);
+
+  if (missingSchemas.length) {
+    console.log(
+      `  Note: ${missingSchemas.length} schema file(s) not found (optional file schemas): ${missingSchemas.join(', ')}`,
+    );
+    console.log(`  Schema dir: ${SCHEMA_DIR}`);
+  }
+
+  const result = isClusterDirectory(abs)
+    ? validateClusterDirectory(abs, schemaMap, schemaOnly)
+    : validateDomainDirectory(abs, schemaMap, schemaOnly);
+  const { errors, warnings } = result;
+  const validCount = result.files;
   const schemaInfo = schemaOnly
     ? ` (schema-only mode, ${loadedSchemas.length} schemas loaded)`
     : '';
 
   if (jsonMode) {
-    const result = {
+    const payload = {
       path: abs,
       valid: errors.length === 0,
       files: validCount,
+      cluster: !!result.cluster,
+      domains: result.domains,
       schemas_loaded: loadedSchemas.length,
       schema_only: schemaOnly,
       errors,
       warnings,
     };
-    console.log(JSON.stringify(result, null, 2));
+    console.log(JSON.stringify(payload, null, 2));
     process.exit(errors.length ? EXIT.VALIDATION_FAILED : EXIT.OK);
   }
 
@@ -124,7 +200,13 @@ function cmdValidate(dir, schemaOnly, jsonMode = false) {
     process.exit(EXIT.VALIDATION_FAILED);
   }
 
-  console.log(`✓ KDNA domain valid: ${abs} (${validCount} files, schema OK${schemaInfo})`);
+  if (result.cluster) {
+    console.log(
+      `✓ KDNA cluster valid: ${abs} (${result.domains.length} domains, ${validCount} KDNA files, schema OK${schemaInfo})`,
+    );
+  } else {
+    console.log(`✓ KDNA domain valid: ${abs} (${validCount} files, schema OK${schemaInfo})`);
+  }
 }
 
 // ─── Pack / Unpack (.kdna ZIP container) ──────────────────────────────────
@@ -140,6 +222,19 @@ function cmdPack(dir, outputDir) {
   if (!core) error('KDNA_Core.json not found or invalid');
   if (!pat) error('KDNA_Patterns.json not found or invalid');
 
+  // Human Lock Gate — check judgment-class cards before packing
+  const { checkHumanLock } = require('../publish');
+  const hl = checkHumanLock(abs);
+  if (!hl.passed) {
+    console.error('Human Lock Gate: BLOCKED');
+    for (const issue of hl.issues) {
+      console.error(`  ✗ ${issue}`);
+    }
+    console.error('Judgment-class cards must be locked with valid Human Lock before packing.');
+    console.error('Use kdna publish --check for details.');
+    process.exit(EXIT.HUMAN_LOCK_REQUIRED);
+  }
+
   const domainName = core.meta?.domain || path.basename(abs);
 
   // Ensure kdna.json manifest exists (generate if missing)
@@ -1025,7 +1120,7 @@ zf.close()
 
 // ─── KDNA Card (locale-aware) ────────────────────────────────────
 
-function cmdCard(dir, locale = null) {
+function cmdCard(dir, jsonMode = false, locale = null) {
   const abs = path.resolve(dir);
   let card = readJson(path.join(abs, 'KDNA_CARD.json'));
 
@@ -1043,8 +1138,6 @@ function cmdCard(dir, locale = null) {
     );
   }
 
-  const jsonMode = process.argv.includes('--json');
-
   if (jsonMode) {
     console.log(JSON.stringify(card, null, 2));
     return;

package/src/cmds/quality.js

@@ -100,6 +100,17 @@ function cmdPostvalidate(args) {
   cmdPostvalidate(args);
 }
 
+function cmdRoute(args) {
+  const { cmdRoute } = require('../agent');
+  const positional = args.filter((a) => !a.startsWith('--'));
+  const flags = args.filter((a) => a.startsWith('--'));
+  if (!positional[1]) {
+    const { error, EXIT } = require('./_common');
+    error('Usage: kdna route "<task description>" [--json] [--discover]', EXIT.INPUT_ERROR);
+  }
+  cmdRoute(positional.slice(1).join(' ').trim(), flags);
+}
+
 module.exports = {
   cmdCompare,
   cmdDiff,
@@ -109,4 +120,5 @@ module.exports = {
   cmdSelect,
   cmdLoad,
   cmdPostvalidate,
+  cmdRoute,
 };

package/src/publish.js

@@ -141,9 +141,71 @@ function isGenericSelfCheck(question) {
   return false;
 }
 
+// ─── Human Lock Gate ──────────────────────────────────────────────────
+
+const JUDGMENT_CARD_TYPES = ['axiom', 'boundary', 'risk', 'aesthetic'];
+
+/**
+ * Check whether the domain satisfies Human Lock requirements.
+ * Returns { passed, issues[] } — publish should be blocked if !passed.
+ */
+function checkHumanLock(domainPath) {
+  const core = readJson(path.join(domainPath, 'KDNA_Core.json'));
+  if (!core) return { passed: false, issues: ['KDNA_Core.json not found'] };
+
+  const issues = [];
+  const cards = [];
+
+  // Collect judgment-class cards from axioms, boundaries, risks
+  if (core.axioms) {
+    for (const a of core.axioms) {
+      cards.push({ type: 'axiom', id: a.id || '?', status: a.status, human_lock: a.human_lock });
+    }
+  }
+  if (core.boundaries) {
+    for (const b of core.boundaries) {
+      cards.push({ type: 'boundary', id: b.id || '?', status: b.status, human_lock: b.human_lock });
+    }
+  }
+  if (core.risks || core.risk_model) {
+    const risks = core.risks || core.risk_model || [];
+    for (const r of risks) {
+      cards.push({ type: 'risk', id: r.id || '?', status: r.status, human_lock: r.human_lock });
+    }
+  }
+
+  if (cards.length === 0) return { passed: true, issues: [] };
+
+  for (const card of cards) {
+    // Rule 1: Must be locked
+    if (!card.status || !['locked', 'tested', 'published'].includes(card.status)) {
+      issues.push(`${card.type} "${card.id}" is not locked. Human Lock required before publish.`);
+      continue;
+    }
+    // Rule 2: Must have human_lock record
+    if (!card.human_lock || !card.human_lock.by || !card.human_lock.statement) {
+      issues.push(`${card.type} "${card.id}" is locked but has no valid Human Lock record.`);
+      continue;
+    }
+    // Rule 3: Lock must confirm judgment fields were reviewed
+    const checked = card.human_lock.checked || {};
+    if (!checked.applies_when) {
+      issues.push(`${card.type} "${card.id}" Human Lock does not confirm applies_when was reviewed.`);
+    }
+    if (!checked.does_not_apply_when) {
+      issues.push(`${card.type} "${card.id}" Human Lock does not confirm does_not_apply_when was reviewed.`);
+    }
+    if (!checked.failure_risk) {
+      issues.push(`${card.type} "${card.id}" Human Lock does not confirm failure_risk was reviewed.`);
+    }
+  }
+
+  return { passed: issues.length === 0, issues };
+}
+
 // ─── Main check function ──────────────────────────────────────────────
 
-function cmdPublishCheck(domainPath) {
+function cmdPublishCheck(domainPath, args = []) {
   const abs = path.resolve(domainPath);
   if (!fs.existsSync(abs)) error(`Domain not found: ${abs}`);
 
@@ -152,6 +214,35 @@ function cmdPublishCheck(domainPath) {
   console.log('═'.repeat(60));
   console.log('');
 
+  // ─── Human Lock Gate (must pass before any other checks) ──────────
+  const hl = checkHumanLock(abs);
+  if (!hl.passed) {
+    if (args.includes('--force')) {
+      console.warn('  ⚠  Human Lock Gate: OVERRIDDEN (--force). Proceeding with checks.');
+      console.warn(`     ${hl.issues.length} unresolved Human Lock issue(s):`);
+      for (const issue of hl.issues) {
+        console.warn(`       ${issue}`);
+      }
+      console.warn('');
+    } else {
+      console.error('  Human Lock Gate: BLOCKED');
+      console.error(`  ${hl.issues.length} issue(s) found:`);
+      for (const issue of hl.issues) {
+        console.error(`    ✗ ${issue}`);
+      }
+      console.error('');
+      console.error('  Judgment-class cards (axiom, boundary, risk, aesthetic)');
+      console.error('  must be locked with a valid Human Lock record before publishing.');
+      console.error('  Use kdna-studio or manually add human_lock to each card.');
+      console.error('  Use --force for emergency override (audited).');
+      console.error('');
+      process.exit(EXIT.HUMAN_LOCK_REQUIRED);
+    }
+  } else {
+    console.log('  ✓ Human Lock Gate: passed');
+    console.log('');
+  }
+
   let errors = 0;
   let warnings = 0;
   let passes = 0;
@@ -551,6 +642,26 @@ function cmdPublish(domainPath, args = []) {
   console.log('═'.repeat(60));
   console.log(`  Publishing ${name}@${manifest.version}`);
   console.log('═'.repeat(60));
+
+  // ─── Human Lock Gate ──────────────────────────────────────────────
+  const hl = checkHumanLock(abs);
+  if (!hl.passed) {
+    console.error('');
+    console.error('  Human Lock Gate: BLOCKED');
+    for (const issue of hl.issues) {
+      console.error(`    ✗ ${issue}`);
+    }
+    console.error('');
+    console.error('  Use kdna publish --check for details, or --force to override.');
+    if (!args.includes('--force')) {
+      process.exit(EXIT.HUMAN_LOCK_REQUIRED);
+    }
+    console.warn('  ⚠  --force override: publishing without Human Lock (emergency only)');
+  } else {
+    console.log(`  ✓ Human Lock Gate: passed`);
+  }
+  console.log('');
+
   console.log(`  Identity fingerprint: ${fingerprint(publicKey)}`);
   console.log(`  Scope trust key:      ${scopeKey.slice(0, 28)}…`);
   console.log('');
@@ -633,4 +744,4 @@ function cmdPublish(domainPath, args = []) {
   );
 }
 
-module.exports = { cmdPublishCheck, cmdPublish, canonicalPayload, publicKeyToScopeFormat };
+module.exports = { cmdPublishCheck, cmdPublish, checkHumanLock, canonicalPayload, publicKeyToScopeFormat };

package/src/verify.js

@@ -21,6 +21,13 @@ const crypto = require('crypto');
 const { RegistryResolver, parseName } = require('./registry');
 const { EXIT } = require('./cmds/_common');
 
+let validateManifestFn;
+try {
+  validateManifestFn = require('@aikdna/kdna-core').validateManifest;
+} catch {
+  // kdna-core not available — manifest validation skipped
+}
+
 const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
 const INSTALL_DIR = path.join(USER_KDNA_DIR, 'domains');
 
@@ -54,6 +61,17 @@ function checkStructure(destDir) {
     }
   }
 
+  // Validate kdna.json against canonical manifest schema
+  if (validateManifestFn) {
+    const manifest = readJson(path.join(destDir, 'kdna.json'));
+    if (manifest) {
+      const mResult = validateManifestFn(manifest);
+      for (const e of mResult.errors) issues.push({ severity: 'error', msg: e });
+      for (const w of mResult.warnings) issues.push({ severity: 'warn', msg: w });
+      if (mResult.errors.length === 0) passed.push('kdna.json conforms to manifest schema v1.0-rc');
+    }
+  }
+
   for (const f of optional) {
     if (fs.existsSync(path.join(destDir, f))) passed.push(`has ${f}`);
   }
@@ -552,6 +570,33 @@ function checkGovernance(destDir) {
 
 function cmdVerify(input, args = []) {
   const jsonMode = args.includes('--json');
+  const trustReport = args.includes('--trust-report');
+
+  // --trust-report: standalone mode — output full trust report and exit
+  if (trustReport) {
+    const parsed = parseName(input);
+    if (!parsed) {
+      console.log(JSON.stringify({ ok: false, error: `Invalid name: ${input}` }));
+      process.exit(EXIT.INPUT_ERROR);
+    }
+    const destDir = path.join(INSTALL_DIR, parsed.scope, parsed.ident);
+    if (!destDir || !require('fs').existsSync(destDir)) {
+      console.log(JSON.stringify({ ok: false, error: `Domain not installed: ${input}` }));
+      process.exit(EXIT.INPUT_ERROR);
+    }
+    const { checkTrust: agentCheckTrust } = require('./agent');
+    const trust = agentCheckTrust(parsed.full);
+    console.log(JSON.stringify({
+      domain: parsed.full,
+      passed: trust.passed,
+      failures: trust.failures,
+      warnings: trust.warnings,
+      risk_level: trust.riskLevel,
+      spec_version: trust.specVersion,
+      signature_valid: trust.signatureValid,
+    }, null, 2));
+    process.exit(trust.passed ? 0 : EXIT.TRUST_FAILED);
+  }
 
   const want = {
     structure: args.includes('--structure'),

package/validators/kdna-lint.js

@@ -10,6 +10,15 @@ const fs = require('fs');
 const path = require('path');
 const { lintDomain } = require('@aikdna/kdna-core');
 
+const KDNA_DOMAIN_FILES = new Set([
+  'KDNA_Core.json',
+  'KDNA_Patterns.json',
+  'KDNA_Scenarios.json',
+  'KDNA_Cases.json',
+  'KDNA_Reasoning.json',
+  'KDNA_Evolution.json',
+]);
+
 const domainDir = process.argv[2];
 if (!domainDir || domainDir === '--help' || domainDir === '-h') {
   console.log(`kdna-lint — Structural and content validation for KDNA domains.
@@ -28,19 +37,44 @@ if (!fs.existsSync(domainDir) || !fs.statSync(domainDir).isDirectory()) {
   process.exit(2);
 }
 
-// Read all KDNA JSON files in the domain directory
-const files = fs.readdirSync(domainDir).filter((f) => f.endsWith('.json') && f !== 'kdna.json');
+// Read only canonical domain content files. Governance metadata such as
+// KDNA_CARD.json is part of the package, but not one of the 6 KDNA JSON files.
+const files = fs.readdirSync(domainDir).filter((f) => KDNA_DOMAIN_FILES.has(f));
 const dataMap = {};
 for (const f of files) {
   try {
     dataMap[f] = JSON.parse(fs.readFileSync(path.join(domainDir, f), 'utf8'));
-  } catch (e) {
+  } catch {
     // lintDomain will report missing required files; skip unparseable here
   }
 }
 
 const result = lintDomain(dataMap);
 
+// Also validate kdna.json manifest if present and validateManifest is available
+let manifestPath;
+try {
+  manifestPath = path.join(domainDir, 'kdna.json');
+  if (fs.existsSync(manifestPath)) {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    let validateManifestFn;
+    try {
+      validateManifestFn = require('@aikdna/kdna-core').validateManifest;
+    } catch {
+      // validateManifest not yet available in installed kdna-core — skip manifest check
+    }
+    if (validateManifestFn) {
+      const mResult = validateManifestFn(manifest);
+      for (const e of mResult.errors) result.errors.push(`kdna.json: ${e}`);
+      for (const w of mResult.warnings) result.warnings.push(`kdna.json: ${w}`);
+    }
+  }
+} catch (e) {
+  if (e.code !== 'ENOENT') {
+    result.errors.push(`kdna.json: failed to parse — ${e.message}`);
+  }
+}
+
 if (result.warnings.length) {
   console.log('Warnings:');
   result.warnings.forEach((w) => console.log(`  - ${w}`));

package/validators/kdna-validate.js

@@ -42,7 +42,8 @@ const FILE_MAP = {
   'KDNA_Evolution.json': 'KDNA_Evolution.schema.json',
 };
 
-// Read all KDNA JSON files
+// Read only canonical domain content files. Governance metadata such as
+// KDNA_CARD.json is valid package metadata, but not part of the 6-file domain set.
 const dataMap = {};
 for (const [file] of Object.entries(FILE_MAP)) {
   const filePath = path.join(domainDir, file);
@@ -57,7 +58,7 @@ for (const [file] of Object.entries(FILE_MAP)) {
 
 // Read schemas
 const schemaMap = {};
-for (const [file, schemaFile] of Object.entries(FILE_MAP)) {
+for (const schemaFile of Object.values(FILE_MAP)) {
   const schemaPath = path.join(SCHEMA_DIR, schemaFile);
   if (fs.existsSync(schemaPath)) {
     try {