| name | elohim-import |
| description | Workflows for transforming Elohim Protocol source content (markdown, Gherkin) into seed-data for the lamad learning platform. Use when "import this content to lamad", "transform markdown to content nodes", "run the elohim-import CLI", or working on the genesis → seed-data pipeline. Complements holochain-import (DHT-seed layer) by handling the transformation layer. |
| metadata | {"sourceRuntime":"claude","master":"package","governance":"epr:elohim-agent/skills/elohim-import"} |
Elohim Import Skill
This skill provides domain expertise for transforming raw Elohim Protocol content into structured learning content for the lamad system. It supports both direct import of raw source files and creative transformation into structured concepts and paths.
Design Principles
- Rust DNA is source of truth - TypeScript/JSON schemas align with Holochain Rust structs
- Maximal model complexity - The graph supports rich relationships; AI derives meaning for learners
- No static complexity - Complexity is relative to the learner, not the content
- This skill IS the AI - During prototyping, Claude (via this skill) fulfills the AI derivation role at import time. In production, distributed AI agents will compute paths dynamically per-learner.
Content Pipeline Architecture
Holochain DNA (Rust) [Source of truth - entry types, relationships]
↓
hc-rna (Rust) [Schema analyzer → JSON Schema + validation]
↓
genesis/docs/content/ [Raw markdown, Gherkin - human authored]
↓
Claude + MCP tools [Non-deterministic, creative transformation]
↓
genesis/data/lamad/ [Structured JSON - schema-aligned seed data]
↓
hc-rna-fixtures --analyze [Validate metadata before seeding]
↓
genesis/seeder [Deterministic script - loads JSON to DHT]
↓
Holochain DHT [Production data]
Content Architecture Philosophy
The DNA validates metadata, not content:
┌─────────────────────────────────────────────────────────────────┐
│ DNA (Holochain) Cache Layer Client │
│ ──────────────── ─────────── ────── │
│ │
│ Metadata: Blobs: Rendering: │
│ - id (required) - video.mp4 - format hint │
│ - title (required) - app.zip - graceful deg │
│ - format_hint (any) - quiz.json - fallbacks │
│ - blob_hash (optional) - feature.gherkin │
│ - provenance (signed) │
└─────────────────────────────────────────────────────────────────┘
This means:
contentFormat accepts ANY string (client hint, not DNA validation)- New formats don't require DNA upgrades
- Blobs are stored in cache layer, not DHT
- DNA focuses on provenance and metadata, not content rendering
Pedagogical Seed Generation Pipeline
This section documents the repeatable process for generating meaningful learning path hierarchies. The pipeline transforms raw content into pedagogically-sound curricula with proper scope and sequence.
Core Terminology
| Term | Definition |
|---|
| Chapter | Domain/theme grouping (answers "what world?") |
| Module | Capability grouping (answers "what can I do?") |
| Section | = Lesson (≤1hr, answers "what concept?") |
| Content | Individual learning artifact |
| Skill | Assessment derived from content |
| Assessment | Aggregation of skill questions, scoped to lesson |
The Scoping Questions Framework
Each hierarchy level must answer a different question to provide distinct semantic value:
| Level | Question | Title Pattern | Example |
|---|
| Chapter | "What domain?" | Domain noun phrase | "AI Governance" |
| Module | "What capability?" | Verb + Object | "Navigating Constitutional Architecture" |
| Section | "What concept?" | Concept noun phrase | "The Appeals Hierarchy" |
| Content | "What artifact?" | Specific title | "The Appellant Journey" |
Anti-patterns to AVOID:
- ❌ Repeating parent title at child level ("Governance" → "Governance Overview" → "Governance Intro")
- ❌ Generic titles ("Introduction", "Overview", "Basics")
- ❌ Purely structural titles ("Part 1", "Section A", "Module 1")
Good patterns:
- ✅ Each level adds specificity
- ✅ Titles answer different questions
- ✅ Can reconstruct location from title alone
Section = Lesson (Critical Constraint)
Each Section represents ONE LESSON with a maximum duration of ~1 hour. This constraint is based on human learning capacity limits.
Content Budget per Section:
- 2-4 concept items (articles, videos, etc.)
- ~15-45 minutes of content consumption
- ~15-20 minutes for reflection/assessment
- Natural break points for session boundaries
Section Structure:
Section: [Concept Title]
├── Content 1: Foundation (the "what")
├── Content 2: Depth (the "how" or "why")
├── Content 3: Example/Application (optional)
└── Assessment(s): Verify understanding before proceeding
Assessments as Skills (Khan Academy Model)
Assessments are NOT separate artifacts. They are smart aggregations of questions generated FROM each piece of content, scoped to the Lesson (Section) level.
Content → Skills → Assessments:
Content Item: "The Appeals Process" (article)
└── Generates skill questions about appeals
Content Item: "Appellant Scenario" (example)
└── Generates application questions about the same concept
Section Assessment = Aggregation of questions from both content items
Multiple Assessments per Lesson:
A section can have multiple assessments approaching the same concept from different angles:
Section: "Adding Two Numbers" (Lesson)
├── Content: Explanation of addition
├── Content: Visual representations
├── Assessment 1: "Adding Two Numbers" (core - direct practice)
└── Assessment 2: "Adding Two Numbers - Word Problems" (applied)
Assessment Types:
core: Direct application of concepts (knowledge recall, understanding)applied: Scenarios, word problems, real-world applicationsynthesis: Combining multiple concepts, higher-order thinking
The 6-Phase Pedagogical Pipeline
Phase 1: Audience Analysis
Purpose: Understand the learner before designing curriculum.
Create an audience archetype document (stored in data/lamad/audiences/):
archetype:
name: "Policy-Developer-Blogger"
description: "Tech-literate advocate interested in systems change"
entry_knowledge:
- Basic understanding of distributed systems
- Familiarity with governance concepts
- Some exposure to blockchain/crypto discourse
motivations:
- Understand enough to advocate effectively
- Implement or contribute to the protocol
- Write/communicate about these ideas
decisions_enabled:
- "Should I/my organization adopt this approach?"
- "How do I explain this to stakeholders?"
- "Where can I contribute technically?"
time_budget: "6-8 hours total, 30-60 min sessions"
resistance_points:
- Skepticism about "love" in technology
- Concerns about feasibility at scale
- Questions about economic sustainability
Phase 2: Content Inventory & Concept Extraction
Purpose: Map all atomic concepts and their relationships.
- Read all source docs for the target domain
- Extract atomic concepts (single ideas that can stand alone)
- Identify relationships (prereq, related, extends, exemplifies)
- Tag concepts by type (theory, practice, example, assessment)
Phase 3: Learning Objective Mapping
Purpose: Define what learners should be able to DO at each level.
Using Bloom's Taxonomy progression (Remember → Understand → Apply → Analyze → Evaluate → Create):
- Chapter (Terminal Objectives): "Evaluate governance decisions against constitutional principles"
- Module (Enabling Objectives): "Apply the appeals process to novel scenarios"
- Section (Concept Objectives): "Explain how appeals escalate through constitutional layers"
Phase 4: Hierarchical Scope Generation
Purpose: Generate titles that provide DISTINCT semantic value at each level.
Apply the Scoping Questions Framework to transform flat content into properly scoped hierarchy.
Example Transformation:
BEFORE (flat):
Chapter: AI Governance
Step: Governance Overview
Step: Quiz
Step: Policy Maker Perspective
AFTER (properly scoped):
Chapter: AI Governance (domain)
Module: Understanding Constitutional Architecture (capability)
Section: The Layered Governance Model (concept)
Content: Governance Epic Overview
Content: Constitutional Layers Diagram
Module: Navigating the System as a Stakeholder (capability)
Section: The Policy Maker's Interface (concept)
Content: Policy Maker README
Section: The Appellant's Journey (concept)
Content: Appellant README
Phase 5: Sequence Optimization
Purpose: Order content for optimal learning.
Sequencing Principles:
- Prerequisites first: Concepts that enable understanding come before those that require it
- Scaffold complexity: Simple → Complex within each module
- Theory before practice: Concepts before applications
- Assess after clusters: Check understanding after related concepts
- End with synthesis: Final module should integrate previous learning
Phase 6: Narrative Threading
Purpose: Each level tells a coherent story.
Narrative Templates:
- Chapter description: "In [Chapter], you'll explore [domain]. By the end, you'll be able to [terminal objective]."
- Module description: "This module builds your ability to [capability]. You'll learn [key concepts] through [content types]."
- Section description: "[Concept] is [brief definition]. Understanding this enables you to [application]."
Path JSON Schema (4-Level with Assessments)
{
"id": "elohim-protocol",
"title": "Elohim Protocol: Living Documentation",
"chapters": [
{
"id": "chapter-2-governance",
"title": "AI Governance",
"description": "Constitutional oversight, appeals, and democratic AI governance",
"modules": [
{
"id": "mod-constitutional-architecture",
"title": "Understanding Constitutional Architecture",
"description": "Learn how the layered governance model enables both local autonomy and global coherence",
"sections": [
{
"id": "sec-layered-model",
"title": "The Layered Governance Model",
"estimatedMinutes": 45,
"conceptIds": [
"governance-epic",
"constitutional-layers"
],
"assessments": [
{
"id": "skill-governance-layers-core",
"title": "Governance Layers",
"type": "core",
"description": "Identify and explain the constitutional layers"
},
{
"id": "skill-governance-layers-applied",
"title": "Governance Layers - Scenarios",
"type": "applied",
"description": "Apply layer concepts to real-world scenarios"
}
]
}
]
}
]
}
]
}
Directory Structure (Updated)
| Directory | Purpose |
|---|
/docs/content/ | Raw source content (markdown, gherkin) |
/data/lamad/ | Structured JSON seed data |
/data/lamad/content/ | Concept JSON files |
/data/lamad/paths/ | Learning path JSON files |
/data/lamad/assessments/ | Assessment JSON files |
/data/lamad/audiences/ | Audience archetype YAML files |
When to Use This Skill
Reference this skill when the user:
- Wants to import raw source files directly as content
- Wants to create learning paths or modules from docs
- Needs to transform markdown into structured concepts
- Is building the content graph (concepts + relationships)
- Wants to create quizzes or assessments
- Needs to seed content to Holochain
Directory Structure
| Directory | Purpose |
|---|
/docs/content/ | Raw source content (markdown, gherkin) |
/data/lamad/ | Structured JSON seed data |
/data/lamad/content/ | Concept JSON files |
/data/lamad/paths/ | Learning path JSON files |
/data/lamad/assessments/ | Assessment JSON files |
MCP Server: elohim-content
The elohim-content MCP server provides tools for reading, transforming, and writing content.
Source Reading Tools
| Tool | Purpose | Example |
|---|
read_doc | Read markdown/gherkin from docs/content/ | {"path": "elohim-protocol/governance/epic.md"} |
list_docs | List documents by epic or pattern | {"epic": "governance"} |
search_docs | Search for concepts/keywords | {"query": "constitutional oversight"} |
Seed Data CRUD
| Tool | Purpose |
|---|
list_seeds | List existing seed files (concepts, paths, assessments) |
read_seed | Read a specific seed JSON file |
write_seed | Write/update structured JSON to data/lamad/ |
delete_seed | Remove a seed file |
validate_seed | Validate against Holochain schemas |
Content Graph Tools
| Tool | Purpose |
|---|
create_concept | Create atomic concept from docs or raw source |
create_relationship | Link concepts (DEPENDS_ON, RELATES_TO, CONTAINS, etc.) |
query_graph | Find concepts by tags, relationships |
get_related | Get related concepts for a node |
update_concept | Modify concept content/metadata |
delete_concept | Remove concept and relationships |
Path Authoring Tools
Paths are views/projections over the content graph:
| Tool | Purpose |
|---|
create_path | Create ordered traversal through graph |
create_chapter | Group concepts into chapter |
create_module | Group into module |
create_section | Group into section |
add_to_path | Add concept at position |
remove_from_path | Remove concept (keeps in graph) |
generate_path | Auto-generate from graph region |
Assessment Tools
| Tool | Purpose |
|---|
create_quiz | Generate quiz from concepts |
create_assessment | Build assessment instrument |
update_assessment | Modify questions/scoring |
Import Modes
1. Direct Source Import
Import a raw source file directly as content, preserving the original markdown:
1. Read the source file
→ read_doc(path: "elohim-protocol/manifesto.md")
2. Create concept with full content
→ create_concept(
id: "manifesto",
title: "Elohim Protocol Manifesto",
content: <full markdown from file>,
sourceDoc: "elohim-protocol/manifesto.md",
tags: ["elohim", "manifesto", "vision"]
)
Use this mode when:
- The source file should be preserved as-is
- Content is already atomic (single document = single concept)
- You want 1:1 mapping from docs to content
2. Creative Transformation
Transform source material into multiple atomic concepts with relationships:
1. Read the source file(s)
→ read_doc(path: "elohim-protocol/governance/epic.md")
2. Extract multiple atomic concepts
→ create_concept(id: "separation-of-powers", ...)
→ create_concept(id: "appeals-process", ...)
→ create_concept(id: "constitutional-oversight", ...)
3. Create relationships
→ create_relationship(source: "appeals-process", target: "separation-of-powers", type: "DEPENDS_ON")
Use this mode when:
- Source content covers multiple distinct concepts
- You want to build a knowledge graph
- Content needs to be chunked for learning purposes
Content Model
Content Graph vs Paths
┌─────────────────────────────────────┐
│ CONTENT GRAPH │
│ (multi-dimensional knowledge graph) │
│ │
│ Concept ←→ Concept ←→ Concept │
│ ↑ ↑ ↑ │
│ DEPENDS_ON RELATES_TO CONTAINS │
│ ↓ ↓ ↓ │
│ Concept ←→ Concept ←→ Concept │
└─────────────────────────────────────┘
↓
┌─────────────────────────────────────┐
│ PATH (one view/projection) │
│ │
│ Chapter → Module → Section │
│ (ordered traversal of graph) │
└─────────────────────────────────────┘
- Content Graph: Underlying knowledge graph with all relationships
- Path: One ordered traversal/projection over the graph
- Exploration: Users can leave path to explore related graph nodes
Concept Schema
Aligned with Holochain DNA Content struct:
{
"id": "separation-of-powers",
"title": "Separation of Powers",
"content": "Markdown content here...",
"contentFormat": "markdown",
"contentType": "article",
"sourceDoc": "elohim-protocol/governance/epic.md",
"tags": ["governance", "constitutional"],
"relationships": [
{"target": "appeals-process", "type": "RELATES_TO"},
{"target": "ai-oversight", "type": "DEPENDS_ON"},
{"target": "governance-epic", "type": "DERIVED_FROM"}
],
"estimatedMinutes": 8
}
ContentFormat Values
All content should have a contentFormat that maps to a renderer. Valid values:
| Format | Description | Renderer |
|---|
markdown | Rich text with embedded media (default for most content) | MarkdownRenderer |
html | Raw HTML content | MarkdownRenderer |
plaintext | Unformatted text | MarkdownRenderer |
gherkin | Behavior-driven development scenarios | GherkinRenderer |
html5-app | Interactive web apps (e.g., Evolution of Trust). Rendered via sandboxed iframe. Can have attestation quizzes built to verify understanding. | IframeRenderer |
video-embed | Embedded video (YouTube, Vimeo, etc.) | IframeRenderer |
video-file | Direct video file (blob-based streaming) | VideoRenderer |
audio-file | Direct audio file (podcasts, lectures, music) | AudioRenderer |
perseus-quiz-json | Legacy Khan Academy Perseus quiz format | SophiaRenderer |
sophia-quiz-json | Sophia Moment format with purpose-based assessment (mastery/discovery/reflection). Uses psyche-core for psychometric aggregation. | SophiaRenderer |
epub | E-book format | EpubRenderer |
external-link | Link to external resource | ExternalLinkRenderer |
Content Principle: Content should translate into consumable multimedia experiences. Raw data formats (like bible-json, contributor-json) are not valid - transform them into markdown or appropriate media format during import.
Example html5-app content:
{
"id": "simulation-evolution-of-trust",
"contentType": "simulation",
"title": "The Evolution of Trust",
"description": "An interactive guide to the game theory of trust",
"url": "https://ncase.me/trust/",
"content": "https://ncase.me/trust/",
"contentFormat": "html5-app",
"metadata": {
"author": "Nicky Case",
"sourceUrl": "https://github.com/ncase/trust",
"embedStrategy": "iframe",
"requiredCapabilities": ["javascript"],
"securityPolicy": {
"sandbox": ["allow-scripts", "allow-same-origin"]
}
}
}
Content Fields
| Field | Type | Description |
|---|
estimatedMinutes | number | Reading/viewing time in minutes |
contentType | "article" | "video" | "simulation" | "assessment" | "discovery-assessment" | Semantic type |
contentFormat | ContentFormat | How content is rendered (see table above) |
metadata | object | Extensible JSON for additional data |
Note: Complexity is NOT stored on content. It's relative to the learner - a beginner finds content "deep" that an expert finds "light".
This skill IS the AI: During prototyping, Claude (via this skill) makes complexity and sequencing judgments when creating relationships and paths. When building a learning path, Claude assesses prerequisite depth, concept ordering, and appropriate chunking based on the target learner profile. In production, distributed AI agents will make these assessments dynamically per-learner.
Path Schema
Paths use a 4-level hierarchy aligned between MCP schemas and Angular models:
Path
└── Chapter (PathChapter)
└── Module (PathModule)
└── Section (PathSection)
└── conceptIds: string[]
Example:
{
"id": "governance-intro",
"title": "Introduction to Constitutional Governance",
"description": "Learn the foundations of AI constitutional oversight",
"difficulty": "beginner",
"chapters": [
{
"id": "ch-foundations",
"title": "Constitutional Foundations",
"order": 0,
"modules": [
{
"id": "mod-principles",
"title": "Core Principles",
"order": 0,
"sections": [
{
"id": "sec-separation",
"title": "Separation of Powers",
"order": 0,
"conceptIds": ["separation-of-powers", "checks-balances"]
}
]
}
]
}
]
}
Angular Model Types:
PathChapter - contains modules: PathModule[] (required)PathModule - contains sections: PathSection[] (required)PathSection - contains conceptIds: string[] (required, links to ContentNode IDs)
Step Flattening with Module Metadata:
The seeder flattens the hierarchical structure (chapters → modules → sections → conceptIds) into a flat array of steps stored in Holochain. Each step includes metadata for UI filtering:
interface PathStep {
stepType: string;
resourceId: string;
orderIndex: number;
chapterId?: string;
moduleId?: string;
sectionId?: string;
}
This enables the UI to:
- Display total steps across entire path (e.g., 56 steps)
- Filter steps by module when viewing a module (e.g., "Step 2 of 5" within current module)
- Navigate between modules while preserving hierarchical context
Relationship Types (DNA-aligned)
Aligned with Holochain DNA Relationship.relationship_type:
| Type | Description |
|---|
RELATES_TO | General association between concepts |
CONTAINS | Parent-child hierarchical relationship |
DEPENDS_ON | Prerequisite dependency (must understand first) |
IMPLEMENTS | Implementation of a concept |
REFERENCES | Citation or reference to another concept |
DERIVED_FROM | This content was derived from source content |
The DERIVED_FROM Relationship
Use DERIVED_FROM to link derived/transformed content back to its source:
Source Document (raw) Derived Content (atomic lesson)
┌─────────────────────┐ ┌─────────────────────────────┐
│ governance-epic.md │ ←──── │ separation-of-powers.json │
│ (full epic document)│ │ relationships: [ │
└─────────────────────┘ │ {target: "governance-epic",│
│ type: "DERIVED_FROM"} │
│ ] │
└─────────────────────────────┘
This enables:
- Provenance tracking: Know where content came from
- Discovery: "View source document" links in UI
- Hierarchy derivation: AI can traverse
DERIVED_FROM to build scope/sequence
Example Workflows
Enrich Content with Attention Metadata
When importing or updating content, add attention metadata for digestible learning sessions:
1. Read existing concept
→ read_seed(path: "content/separation-of-powers.json")
2. Estimate reading time (word count / 200 wpm)
→ ~1500 words = 8 minutes
3. Update with metadata
→ write_seed(path: "content/separation-of-powers.json", {
...existingContent,
estimatedMinutes: 8,
contentType: "article"
})
Note: Do NOT add a static complexity field. Complexity is relative to the learner. Instead, this skill (Claude) embeds complexity judgments into the graph structure - through relationship types (DEPENDS_ON for prerequisites), ordering in paths, and chunking decisions made during import.
Import Raw Source Files
Import a collection of markdown files directly:
1. List available documents
→ list_docs(epic: "governance")
2. For each document, read and create concept
→ doc = read_doc(path: "elohim-protocol/governance/epic.md")
→ create_concept(
id: "governance-epic",
title: doc.frontmatter.title || "Governance Epic",
content: doc.content,
sourceDoc: doc.path,
tags: doc.frontmatter.tags || ["governance"]
)
Transform into Learning Module
1. Read the governance epic
→ read_doc(path: "elohim-protocol/governance/epic.md")
2. Extract atomic concepts
→ create_concept(id: "separation-of-powers", title: "...", content: "...")
→ create_concept(id: "appeals-process", ...)
→ create_concept(id: "constitutional-oversight", ...)
3. Create relationships
→ create_relationship(source: "appeals-process", target: "separation-of-powers", type: "DEPENDS_ON")
4. Build learning path
→ create_path(id: "governance-intro", title: "...")
→ create_chapter(id: "ch-foundations", pathId: "governance-intro", ...)
→ create_module(id: "mod-principles", pathId: "governance-intro", chapterId: "ch-foundations", ...)
→ create_section(id: "sec-overview", conceptIds: ["separation-of-powers", "appeals-process"], ...)
5. Create quiz
→ create_quiz(id: "gov-quiz-1", title: "Governance Basics", conceptIds: [...])
Seed to Holochain
After creating content in data/lamad/, run the seeder:
cd /projects/elohim/holochain/seeder
npm run seed
The seeder reads JSON from data/lamad/ and loads it to Holochain DHT.
Epics Available
Source content organized by epic:
| Epic | Description |
|---|
governance | AI constitutional oversight and appeals |
value_scanner | Care economy and value recognition |
public_observer | Civic participation and oversight |
autonomous_entity | Workplace transformation |
social_medium | Relationship-centered digital communication |
economic_coordination | REA-based value flows |
Schema Definitions
Schemas are defined in /projects/elohim/mcp-servers/elohim-content/src/schemas/index.ts:
conceptSchema - Atomic knowledge unitpathSchema - Learning path with chapters/modules/sectionsassessmentSchema - Quiz and assessment instrumentsquestionSchema - Individual assessment questions
CLI Commands
The CLI in elohim-library/projects/elohim-service/ provides import and exploration commands:
npx ts-node src/cli/import.ts list-epics
npx ts-node src/cli/import.ts explore --epic governance
npx ts-node src/cli/import.ts list-user-types
Seed Data Validation (hc-rna-fixtures)
The hc-rna-fixtures CLI validates JSON seed data against the DNA schema before seeding. This catches errors at build time rather than runtime.
Quick Start
cd /projects/elohim/holochain/rna/rust
RUSTFLAGS="" cargo build --features cli --bin hc-rna-fixtures
RUSTFLAGS="" cargo run --features cli --bin hc-rna-fixtures -- \
-f /projects/elohim/genesis/data/lamad/content --analyze -v
Validation Modes
| Mode | Required Fields | Description |
|---|
metadata (default) | id, title | Validates only truly required fields. Content format is a hint. |
strict | All DNA fields | Full schema validation against integrity zome |
loose | id only | Minimal validation for exploratory work |
hc-rna-fixtures -f fixtures/ --mode metadata --analyze
hc-rna-fixtures -f fixtures/ --mode strict -i path/to/integrity/src/lib.rs
hc-rna-fixtures -f fixtures/ --mode loose --analyze
Understanding the Output
======================================================================
FIXTURE ANALYSIS (Metadata-Focused)
======================================================================
Total files: 3525
Valid metadata: 3525 ✅
With blob refs: 1 📦
Missing required: 0 ❌
--- Content Formats (client hints) ---
gherkin: 2946 files
markdown: 528 files
plaintext: 38 files
perseus-quiz-json: 12 files
html5-app: 1 file
- Valid metadata: Files with required
id and title fields
- With blob refs: Files that reference external blobs (need cache resolution)
- Content Formats: Distribution of
contentFormat values (hints, not validated)
Field Categories
The validator understands different field categories:
| Category | Fields | Validation |
|---|
| Required | id, title | Must be present, correct type |
| Client Hints | contentFormat, contentType | Any string value accepted |
| Blob Resolution | blob_hash, entry_point, blob_url | Indicates cache layer content |
| Auto-Defaulted | reach, trust_score, schema_version | Seeder/zome provides defaults |
Pre-Seed Validation Workflow
Before running the seeder, always validate:
cd /projects/elohim/holochain/rna/rust
RUSTFLAGS="" cargo run --features cli --bin hc-rna-fixtures -- \
-f /projects/elohim/genesis/data/lamad/content --analyze -v
cd /projects/elohim/genesis
npm run seed
Common Validation Issues
| Issue | Cause | Fix |
|---|
Missing required field 'id' | JSON lacks id field | Add unique identifier |
Missing required field 'title' | JSON lacks title field | Add human-readable title |
Invalid JSON | Malformed JSON syntax | Check for trailing commas, unclosed braces |
Fixture must be a JSON object | Array at root level | Wrap in object or split into files |
Generating Rust Fixtures (Future)
The tool can also generate a Rust module with embedded fixtures for compile-time validation:
hc-rna-fixtures -f fixtures/ -o src/fixtures.rs --module-name seed_data
Troubleshooting
No content in data/lamad/
Use the MCP tools to:
- Direct import: Read source files and create concepts with full content
- Transform: Extract atomic concepts from source material
Seeder can't find content
Ensure JSON files exist in:
data/lamad/content/*.json - Conceptsdata/lamad/paths/*.json - Learning pathsdata/lamad/assessments/*.json - Assessments
MCP server not responding
Build and restart the MCP server:
cd /projects/elohim/mcp-servers/elohim-content
npm install
npm run build
