@aikdna/kdna-cli 0.9.0

package/templates/minimal-domain/kdna.json

@@ -0,0 +1,31 @@
+{
+  "kdna_spec": "1.0-rc",
+  "name": "@aikdna/example_domain",
+  "version": "0.1.0",
+  "language": "en",
+  "languages": ["en"],
+  "created": "YYYY-MM-DD",
+  "updated": "YYYY-MM-DD",
+  "description": "[TODO: describe what judgment this domain improves in one sentence]",
+  "core_insight": "[TODO: one-sentence insight that captures the domain's core judgment principle]",
+  "keywords": ["[TODO: add relevant keywords]"],
+  "access": "open",
+  "status": "experimental",
+  "author": {
+    "name": "Your Name",
+    "id": "your-id"
+  },
+  "license": {
+    "type": "CC-BY-4.0",
+    "commercial": false,
+    "allow_agent_use": true,
+    "allow_redistribution": true,
+    "allow_training": true
+  },
+  "registry": {
+    "repo": "https://github.com/your-org/your-repo"
+  },
+  "file_count": 3,
+  "kdna_file_count": 3,
+  "files": ["KDNA_Core.json", "KDNA_Patterns.json", "tests/before-after.json"]
+}

package/templates/minimal-domain/tests/before-after.json

@@ -0,0 +1,16 @@
+[
+  {
+    "input": "A task related to this domain that needs expert judgment",
+    "without_kdna": {
+      "expected_approach": "How a generic AI would typically respond",
+      "common_mistake": "What the generic response gets wrong"
+    },
+    "with_kdna": {
+      "expected_approach": "How a domain-aware response should differ",
+      "signal_reading": "Which domain signal this input triggers",
+      "diagnosis_path": "The expert reasoning chain"
+    },
+    "domain": "example_domain",
+    "trigger": "keyword or pattern that activates this domain"
+  }
+]

package/templates/standard-domain/KDNA_Core.json

@@ -0,0 +1,76 @@
+{
+  "meta": {
+    "version": "0.1.0",
+    "domain": "your_domain_id",
+    "created": "YYYY-MM-DD",
+    "purpose": "One-sentence statement of what this KDNA helps an AI agent judge in this domain.",
+    "load_condition": "Load when the user asks for <specific task type that triggers this domain>."
+  },
+  "axioms": [
+    {
+      "id": "axiom_one",
+      "one_sentence": "A specific, contestable principle this domain claims about judgment.",
+      "full_statement": "Expand into 2-3 sentences. Be specific. Avoid 'X is important' style. Two experts in this field should be able to agree on whether this axiom applies to a given situation.",
+      "why": "What would the agent get wrong without this axiom? (Be specific.)",
+      "confidence": "high",
+      "evidence_type": ["practice_pattern", "case_observation"],
+      "applies_when": [
+        "describe situation 1 where this axiom guides judgment correctly",
+        "describe situation 2"
+      ],
+      "does_not_apply_when": [
+        "describe situation where applying this axiom would mislead the agent",
+        "describe another case where the axiom should step back"
+      ],
+      "failure_risk": "What bad judgment results if the agent applies this axiom OUTSIDE its scope? (Be specific.)"
+    },
+    {
+      "id": "axiom_two",
+      "one_sentence": "(see writing the axioms guide)",
+      "full_statement": "...",
+      "why": "...",
+      "confidence": "medium",
+      "evidence_type": ["practice_pattern"],
+      "applies_when": ["..."],
+      "does_not_apply_when": ["..."],
+      "failure_risk": "..."
+    }
+  ],
+  "ontology": [
+    {
+      "id": "concept_one",
+      "one_sentence": "One-sentence description of a domain-specific concept.",
+      "essence": "What this concept fundamentally is. Operational, not dictionary.",
+      "boundary": "What this concept is often confused with. Name the confusable, not just 'not X'.",
+      "trigger_signal": "Observable signal in user input that this concept is relevant.",
+      "applies_when": ["..."],
+      "does_not_apply_when": ["..."]
+    }
+  ],
+  "frameworks": [
+    {
+      "id": "frame_diagnose_before_fix",
+      "name": "Diagnose Before Fix",
+      "when_to_use": "Use when asked to evaluate or improve in this domain.",
+      "steps": [
+        "Step 1: identify whether ...",
+        "Step 2: identify whether ...",
+        "Step 3: name the root before suggesting any fix."
+      ]
+    }
+  ],
+  "core_structure": [
+    {
+      "from": "user_symptom_or_complaint",
+      "to": "root_cause_in_this_domain",
+      "via": "the specific check or framing this domain provides"
+    }
+  ],
+  "stances": [
+    {
+      "stance": "A prescriptive position that biases agent behavior in this domain.",
+      "applies_when": ["..."],
+      "does_not_apply_when": ["..."]
+    }
+  ]
+}

package/templates/standard-domain/KDNA_Patterns.json

@@ -0,0 +1,44 @@
+{
+  "meta": {
+    "version": "0.1.0",
+    "domain": "your_domain_id",
+    "created": "YYYY-MM-DD",
+    "purpose": "Common misdiagnoses and self-checks for <domain>.",
+    "load_condition": "Always load with KDNA_Core.json."
+  },
+  "terminology": {
+    "standard_terms": [
+      {
+        "term": "domain_specific_concept",
+        "definition": "Operational definition. Not a dictionary definition. What the agent must do, see, or check when this term applies."
+      }
+    ],
+    "banned_terms": [
+      {
+        "term": "vague_word_agents_default_to",
+        "why": "Why using this term in this domain misleads the agent or the user.",
+        "replace_with": "the specific, operational alternative",
+        "applies_when": ["situation where the substitution matters"]
+      }
+    ]
+  },
+  "misunderstandings": [
+    {
+      "id": "misread_one",
+      "wrong": "A specific belief a real agent in this domain might hold. NOT a straw-man.",
+      "correct": "What the agent should believe instead. Be operational, not slogan.",
+      "key_distinction": "Name the conceptual boundary, not just the negation.",
+      "why": "What bad output results when an agent holds the wrong belief.",
+      "confidence": "high",
+      "evidence_type": ["practice_pattern"],
+      "applies_when": ["describe situations where this misunderstanding is likely"],
+      "does_not_apply_when": ["describe situations where this distinction would be a red herring"],
+      "failure_risk": "What harm if the agent over-applies this distinction outside its scope."
+    }
+  ],
+  "self_check": [
+    "Domain-specific yes/no question 1 the agent should answer about its own output?",
+    "Domain-specific yes/no question 2?",
+    "Domain-specific yes/no question 3?"
+  ]
+}

package/templates/standard-domain/README.md

@@ -0,0 +1,74 @@
+> 🧬 [aikdna.com](https://aikdna.com) — Official website
+
+# [Your domain name]
+
+[![KDNA Spec](https://img.shields.io/badge/KDNA-v1.0-4c1)](https://github.com/knowledge-dna/KDNA)
+
+**[Domain Title]** — [one-sentence description, same as kdna.json.description]
+
+## Core Insight
+
+[one-sentence core insight, same as kdna.json.core_insight]
+
+## Install
+
+```bash
+kdna install @yourscope/your_domain_id
+kdna verify @yourscope/your_domain_id      # structure + trust + judgment
+```
+
+## The Four Questions (v2.1 governance)
+
+Every KDNA must answer four questions. Here are this domain's answers.
+
+### 1. Where does it come from?
+
+- **Authored by**: [Your name / team]
+- **Evidence type**: [practice patterns / case observations / research findings — be specific]
+- **Signed by**: `@yourscope` trust key (fingerprint `[your-fingerprint]`)
+
+### 2. Where does it apply?
+
+This KDNA helps agents [specific judgment] in:
+
+- [situation 1]
+- [situation 2]
+- [situation 3]
+
+### 3. How is it verified?
+
+- `kdna verify @yourscope/your_domain_id --judgment` — checks v2.1 governance fields
+- `kdna compare @yourscope/your_domain_id --input "<task>"` — runs with/without KDNA on a real LLM and shows the reasoning-trajectory diff
+- `evals/` directory contains 10 cases: 3 core + 3 boundary + 3 failure + 1 excluded
+- `demo/` directory holds rendered before/after comparisons. Regenerate with `ANTHROPIC_API_KEY=... node scripts/build-demo.js`
+
+### 4. When does it NOT apply?
+
+Loading this domain on the wrong task is itself a risk. **Do not load** when:
+
+- [explicit case 1 from your axioms' does_not_apply_when]
+- [explicit case 2]
+- [explicit case 3]
+
+If any of the above is true, the agent should decline to load this domain.
+
+## Known Failure Risks
+
+| Risk | When it shows up |
+|------|---|
+| [risk 1 from axiom_one.failure_risk] | [trigger] |
+| [risk 2 from axiom_two.failure_risk] | [trigger] |
+| [risk 3 from misread_one.failure_risk] | [trigger] |
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `KDNA_Core.json` | Axioms (with v2.1 boundaries), ontology, frameworks, causal structure, stances |
+| `KDNA_Patterns.json` | Terminology, banned terms, misunderstandings (with v2.1 boundaries), self-checks |
+| `evals/` | Test cases for `kdna compare` and quality scoring |
+| `kdna.json` | Domain manifest (name, version, judgment_version, signature) |
+
+## License
+
+[Your license — CC-BY-4.0 / MIT / etc.]

package/templates/standard-domain/USAGE.md

@@ -0,0 +1,59 @@
+# standard-domain template
+
+This is the v2.1 reference template for a new KDNA domain. Copy this folder, fill in the bracketed placeholders, and publish.
+
+## What this template includes
+
+```
+standard-domain/
+├── README.md                   # Four Questions + Failure Risks + Files
+├── kdna.json                   # Manifest with judgment_version (v2.1)
+├── KDNA_Core.json              # Axioms with applies_when / does_not_apply_when / failure_risk
+├── KDNA_Patterns.json          # Misunderstandings with same governance fields
+└── evals/
+    ├── 3_core_cases.json       # Domain MUST handle correctly
+    ├── 3_boundary_cases.json   # Edge of scope
+    ├── 3_failure_cases.json    # Known failure modes (cite failure_risk)
+    ├── 1_excluded_case.json    # Wrong domain entirely
+    └── scoring.json            # D1-D8 dimensions
+```
+
+## How to use
+
+```bash
+# 1. Copy to your new domain folder
+cp -r templates/standard-domain ./my_domain
+cd my_domain
+
+# 2. Generate your scope identity (once per scope)
+kdna identity init
+
+# 3. Edit kdna.json:
+#    - name: "@yourscope/your_domain_id"
+#    - judgment_version: "YYYY.MM"
+#    - description, core_insight, keywords, author
+
+# 4. Edit KDNA_Core.json and KDNA_Patterns.json:
+#    - Replace placeholder axioms with your own
+#    - Every axiom MUST have applies_when, does_not_apply_when, failure_risk
+#    - Every misunderstanding MUST have applies_when, failure_risk
+
+# 5. Fill out evals/ — 10 real cases
+
+# 6. Verify quality
+kdna verify ./.
+
+# 7. Publish
+KDNA_IDENTITY_DIR=~/.kdna/identity-official \
+  kdna publish ./. \
+    --release-tag v0.1.0 \
+    --repo yourname/kdna-<your_domain_id>
+
+# 8. Open PR to kdna-registry with the patch JSON the command printed
+```
+
+## Standard vs minimal-domain
+
+`minimal-domain/` is the **bare-minimum** template — 2 files, no v2.1 fields, no evals. Use it only for fast experimentation or learning.
+
+`standard-domain/` is the **registry-ready** template. Any domain meant to be published to the registry should start here and aim for `kdna verify --judgment` ≥ 80% before publishing.

package/templates/standard-domain/evals/1_excluded_case.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://aikdna.com/schemas/eval-cases-v1.json",
+  "domain": "@yourscope/your_domain_id",
+  "category": "excluded",
+  "purpose": "Case where your KDNA should NOT be loaded at all. The loader skill should detect the mismatch.",
+  "cases": [
+    {
+      "id": "excluded-1-wrong-domain-entirely",
+      "title": "Task that belongs to a different KDNA (or no KDNA)",
+      "input": "...",
+      "should_load_this_domain": false,
+      "why_not": "Explain which feature of the input signals 'wrong domain' (format, audience, task type, etc.).",
+      "what_to_load_instead": "@yourscope/other_domain (if known) or no KDNA"
+    }
+  ]
+}

package/templates/standard-domain/evals/3_boundary_cases.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://aikdna.com/schemas/eval-cases-v1.json",
+  "domain": "@yourscope/your_domain_id",
+  "category": "boundary",
+  "purpose": "Cases at the edge of the domain's scope. The agent should detect the boundary and either decline OR be careful about which axioms still apply.",
+  "cases": [
+    {
+      "id": "boundary-1-adjacent-domain",
+      "title": "Task that looks like your domain but isn't",
+      "input": "...",
+      "expected_without_kdna": "...",
+      "expected_with_kdna": "Agent recognizes the boundary, names which axiom's does_not_apply_when triggers, and does NOT over-apply your domain's frame.",
+      "must_contain": ["..."],
+      "must_not_contain": ["the over-applied frame you want to avoid"],
+      "boundary_signal": "[which axiom's does_not_apply_when should trigger]"
+    },
+    {
+      "id": "boundary-2-format-mismatch",
+      "title": "Right topic, wrong format",
+      "input": "...",
+      "expected_without_kdna": "...",
+      "expected_with_kdna": "...",
+      "must_contain": ["..."],
+      "must_not_contain": ["..."],
+      "boundary_signal": "..."
+    },
+    {
+      "id": "boundary-3-audience-mismatch",
+      "title": "Right task, wrong audience for the domain's stance",
+      "input": "...",
+      "expected_without_kdna": "...",
+      "expected_with_kdna": "...",
+      "must_contain": ["..."],
+      "must_not_contain": ["..."],
+      "boundary_signal": "..."
+    }
+  ]
+}

package/templates/standard-domain/evals/3_core_cases.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://aikdna.com/schemas/eval-cases-v1.json",
+  "domain": "@yourscope/your_domain_id",
+  "category": "core",
+  "purpose": "Cases the domain MUST handle correctly. Loading should clearly change the agent's response from generic to domain-specific.",
+  "cases": [
+    {
+      "id": "core-1-typical-task",
+      "title": "Most common task in your domain",
+      "input": "[paste the user prompt that triggers your domain's typical task]",
+      "expected_without_kdna": "[what a baseline agent would say — usually surface-level]",
+      "expected_with_kdna": "[what your domain produces — root cause / specific terminology / boundary awareness]",
+      "must_contain": ["domain-specific term 1", "expected diagnosis word"],
+      "must_not_contain": ["generic advice phrase you want to avoid"]
+    },
+    {
+      "id": "core-2-edge-of-core",
+      "title": "Less-common but still inside scope",
+      "input": "...",
+      "expected_without_kdna": "...",
+      "expected_with_kdna": "...",
+      "must_contain": ["..."],
+      "must_not_contain": ["..."]
+    },
+    {
+      "id": "core-3-trickier-pattern",
+      "title": "A case requiring the agent to apply an axiom non-obviously",
+      "input": "...",
+      "expected_without_kdna": "...",
+      "expected_with_kdna": "...",
+      "must_contain": ["..."],
+      "must_not_contain": ["..."]
+    }
+  ]
+}

package/templates/standard-domain/evals/3_failure_cases.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://aikdna.com/schemas/eval-cases-v1.json",
+  "domain": "@yourscope/your_domain_id",
+  "category": "failure",
+  "purpose": "Cases where loading your KDNA produces a WORSE response than not loading it. Each case should cite the failure_risk declared by your domain.",
+  "cases": [
+    {
+      "id": "failure-1-known-risk-one",
+      "title": "Failure mode named in axiom_one.failure_risk",
+      "input": "...",
+      "expected_failure_with_kdna": "Agent over-applies axiom_one, fights the user's stated goal.",
+      "correct_behavior": "Agent recognizes the boundary, honors the user's actual request, surfaces the trade-off.",
+      "detection_signal": "...",
+      "failure_risk_named_in_domain": "axiom_one.failure_risk: '...'"
+    },
+    {
+      "id": "failure-2-known-risk-two",
+      "title": "Failure mode named in axiom_two.failure_risk",
+      "input": "...",
+      "expected_failure_with_kdna": "...",
+      "correct_behavior": "...",
+      "detection_signal": "...",
+      "failure_risk_named_in_domain": "axiom_two.failure_risk: '...'"
+    },
+    {
+      "id": "failure-3-misunderstanding-risk",
+      "title": "Failure mode named in a misunderstanding's failure_risk",
+      "input": "...",
+      "expected_failure_with_kdna": "...",
+      "correct_behavior": "...",
+      "detection_signal": "...",
+      "failure_risk_named_in_domain": "misread_one.failure_risk: '...'"
+    }
+  ]
+}

package/templates/standard-domain/evals/scoring.json

@@ -0,0 +1,60 @@
+{
+  "$schema": "https://aikdna.com/schemas/eval-scoring-v1.json",
+  "domain": "@yourscope/your_domain_id",
+  "scoring_framework": "D1-D8",
+  "purpose": "How to score whether loading your KDNA actually changes the agent's reasoning trajectory.",
+  "dimensions": [
+    {
+      "id": "D1",
+      "name": "Diagnostic depth",
+      "question": "Root cause vs surface symptoms?",
+      "scale": "0-5"
+    },
+    {
+      "id": "D2",
+      "name": "Terminology consistency",
+      "question": "Used domain-specific terms?",
+      "scale": "0-5"
+    },
+    {
+      "id": "D3",
+      "name": "Misunderstanding detection",
+      "question": "Avoided named misdiagnoses?",
+      "scale": "0-5"
+    },
+    {
+      "id": "D4",
+      "name": "Axiom alignment",
+      "question": "Response grounded in axioms?",
+      "scale": "0-5"
+    },
+    {
+      "id": "D5",
+      "name": "Scenario classification",
+      "question": "Correctly identified case category?",
+      "scale": "0-5"
+    },
+    {
+      "id": "D6",
+      "name": "Actionable specificity",
+      "question": "Suggestions specific enough to act on?",
+      "scale": "0-5"
+    },
+    {
+      "id": "D7",
+      "name": "Boundary awareness",
+      "question": "Recognized when task is outside scope?",
+      "scale": "0-5"
+    },
+    {
+      "id": "D8",
+      "name": "Self-check pass rate",
+      "question": "Of N self-checks, how many can the response answer 'yes'?",
+      "scale": "0/N to N/N"
+    }
+  ],
+  "minimum_threshold_for_kdna_value": {
+    "description": "Loading your KDNA must improve average score by at least +2 vs no-KDNA baseline, averaged across all 10 cases.",
+    "rationale": "If the lift is <+2, the domain is not adding value."
+  }
+}

package/templates/standard-domain/kdna.json

@@ -0,0 +1,28 @@
+{
+  "kdna_spec": "1.0",
+  "name": "@yourscope/your_domain_id",
+  "version": "0.1.0",
+  "judgment_version": "YYYY.MM",
+  "status": "experimental",
+  "access": "open",
+  "language": "en",
+  "created": "YYYY-MM-DD",
+  "updated": "YYYY-MM-DD",
+  "description": "[one-sentence description; appears on registry and in install output]",
+  "core_insight": "[one-sentence core insight that distinguishes this domain]",
+  "keywords": ["[add 3-6 keywords for kdna search]"],
+  "author": {
+    "name": "Your Name",
+    "id": "your-id",
+    "pubkey": "[set automatically by kdna publish — must match your scope trust_pubkey]"
+  },
+  "license": {
+    "type": "CC-BY-4.0",
+    "commercial": false,
+    "allow_agent_use": true,
+    "allow_redistribution": true,
+    "allow_training": true
+  },
+  "file_count": 2,
+  "files": ["KDNA_Core.json", "KDNA_Patterns.json"]
+}

package/validators/kdna-lint.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * kdna-lint — Structural and content validation for KDNA domains.
+ *
+ * Uses @aikdna/kdna-core lintDomain for pure validation logic,
+ * handles file I/O here.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { lintDomain } = require('@aikdna/kdna-core');
+
+const domainDir = process.argv[2];
+if (!domainDir || domainDir === '--help' || domainDir === '-h') {
+  console.log(`kdna-lint — Structural and content validation for KDNA domains.
+
+Usage: kdna-lint <domain-folder>
+
+Runs lint checks on KDNA_*.json files for structure, content, and consistency.
+
+Options:
+  -h, --help    Show this help message`);
+  process.exit(domainDir ? 0 : 2);
+}
+
+if (!fs.existsSync(domainDir) || !fs.statSync(domainDir).isDirectory()) {
+  console.error(`Not a directory: ${domainDir}`);
+  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');
+const dataMap = {};
+for (const f of files) {
+  try {
+    dataMap[f] = JSON.parse(fs.readFileSync(path.join(domainDir, f), 'utf8'));
+  } catch (e) {
+    // lintDomain will report missing required files; skip unparseable here
+  }
+}
+
+const result = lintDomain(dataMap);
+
+if (result.warnings.length) {
+  console.log('Warnings:');
+  result.warnings.forEach((w) => console.log(`  - ${w}`));
+}
+if (result.errors.length) {
+  console.error('Errors:');
+  result.errors.forEach((e) => console.error(`  - ${e}`));
+  process.exit(1);
+}
+console.log(`✓ KDNA domain valid: ${domainDir}`);

package/validators/kdna-validate.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * kdna-validate — Enhanced KDNA domain validator using JSON Schema.
+ *
+ * Uses @aikdna/kdna-core validateDomainSchema and validateCrossFile for
+ * pure validation logic, handles file I/O here.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { validateDomainSchema, validateCrossFile } = require('@aikdna/kdna-core');
+
+const domainDir = process.argv[2];
+if (!domainDir || domainDir === '--help' || domainDir === '-h') {
+  console.log(`kdna-validate — Validate a KDNA domain against JSON Schema.
+
+Usage: kdna-validate <domain-folder>
+
+Checks each KDNA_*.json file against its schema, then runs cross-file validation.
+
+Options:
+  -h, --help    Show this help message`);
+  process.exit(domainDir ? 0 : 2);
+}
+
+if (!fs.existsSync(domainDir) || !fs.statSync(domainDir).isDirectory()) {
+  console.error(`Not a directory: ${domainDir}`);
+  process.exit(2);
+}
+
+const SCHEMA_DIR = path.join(
+  path.dirname(require.resolve('@aikdna/kdna-core/package.json')),
+  'schema',
+);
+
+const FILE_MAP = {
+  'KDNA_Core.json': 'KDNA_Core.schema.json',
+  'KDNA_Patterns.json': 'KDNA_Patterns.schema.json',
+  'KDNA_Scenarios.json': 'KDNA_Scenarios.schema.json',
+  'KDNA_Cases.json': 'KDNA_Cases.schema.json',
+  'KDNA_Reasoning.json': 'KDNA_Reasoning.schema.json',
+  'KDNA_Evolution.json': 'KDNA_Evolution.schema.json',
+};
+
+// Read all KDNA JSON files
+const dataMap = {};
+for (const [file] of Object.entries(FILE_MAP)) {
+  const filePath = path.join(domainDir, file);
+  if (fs.existsSync(filePath)) {
+    try {
+      dataMap[file] = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch {
+      /* skip unparseable files */
+    }
+  }
+}
+
+// Read schemas
+const schemaMap = {};
+for (const [file, schemaFile] of Object.entries(FILE_MAP)) {
+  const schemaPath = path.join(SCHEMA_DIR, schemaFile);
+  if (fs.existsSync(schemaPath)) {
+    try {
+      schemaMap[schemaFile] = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+    } catch {
+      /* skip unparseable schemas */
+    }
+  }
+}
+
+// Schema validation
+const schemaResult = validateDomainSchema(dataMap, schemaMap);
+
+// Cross-file validation
+const crossResult = validateCrossFile(dataMap);
+
+// Combine results
+const errors = [...schemaResult.errors, ...crossResult.errors];
+const warnings = [...schemaResult.warnings, ...crossResult.warnings];
+
+if (warnings.length) {
+  console.log('Warnings:');
+  warnings.forEach((w) => console.log(`  - ${w}`));
+}
+if (errors.length) {
+  console.error('Errors:');
+  errors.forEach((e) => console.error(`  - ${e}`));
+  process.exit(1);
+}
+
+const validCount = Object.keys(dataMap).length;
+console.log(`✓ KDNA domain valid (schema): ${domainDir} (${validCount} files passed)`);