# Reference anchor — no learning, no QRA generation
./run.sh create "Chuck Yeager" --template expert --no-learn \
  --note "Reference anchor only — thin content, no YouTube"

personas:
  - name: Hasard Lee
    template: expert
    content_tier: rich        # rich | moderate | thin | none
    qra_target: 300           # Target QRA count based on content tier
    skip_voice_training: false # true for thin/none personas
    # ...

# Interactive client persona (uses /interview)
./run.sh create "Jane Smith" --template client --interactive

# Expert persona with auto-learning
./run.sh create "Robert Sapolsky" --template expert --learn

# Quick stakeholder
./run.sh create "Bob Jones" --template stakeholder \
  --role "Engineering Manager" \
  --organization "Acme Corp"

# List all personas
./run.sh list

# Query persona
./run.sh show "Jane Smith" --json

# Batch create from manifest
./run.sh batch personas.yaml --dry-run
./run.sh batch personas.yaml --skip-learn
./run.sh batch personas.yaml --category writers

./run.sh create NAME [OPTIONS]

Options:
  --template {client,expert,stakeholder,adversary}  Persona template
  --interactive, -i    Use /interview for collaborative creation
  --learn              Trigger /ask learn for knowledge enrichment
  --scope SCOPE        Memory scope (default: template-based)
  --role ROLE          Job title or role
  --organization ORG   Company or institution
  --domain DOMAIN      Area of expertise
  --goal GOAL          Add a goal (repeatable)
  --concern CONCERN    Add a concern (repeatable)
  --colleague NAME     Add colleague relationship (repeatable)
  --bridge BRIDGE      Add Federated Taxonomy bridge (repeatable)

./run.sh list [OPTIONS]

Options:
  --scope SCOPE        Filter by scope
  --template TEMPLATE  Filter by template type
  --tag TAG            Filter by tag
  --json               Output as JSON

./run.sh show NAME [OPTIONS]

Options:
  --scope SCOPE        Memory scope to search
  --json               Output as JSON
  --with-colleagues    Include colleague details

./run.sh update NAME [OPTIONS]

Options:
  --add-goal GOAL      Add a goal
  --add-concern CONCERN  Add a concern
  --add-colleague NAME   Add colleague relationship
  --set-role ROLE      Update role
  --remove-goal GOAL   Remove a goal

./run.sh relate NAME [OPTIONS]

Options:
  --colleague NAME     Peer relationship
  --reports-to NAME    Hierarchical (reports to)
  --manages NAME       Hierarchical (manages)
  --mentors NAME       Mentorship relationship
  --bridges BRIDGE     Shared taxonomy bridges (comma-separated)
  --context TEXT       Relationship context/notes

./run.sh batch MANIFEST [OPTIONS]

Options:
  --category, -c CATEGORY  Only process specific category
  --skip-learn             Skip auto-learning
  --dry-run                Preview without creating

./run.sh simulacrum NAME [OPTIONS]

Options:
  --probes, -p TEXT        Probe types (default: philosophy,technique,motivation)
  --scope, -s SCOPE        Memory scope
  --json                   Output as JSON

./run.sh simulacrum "Hayao Miyazaki" --probes "philosophy,technique,criticism"

# Output:
Simulacrum Validation: Hayao Miyazaki
  Grade: B (Accuracy: 0.80)

Simulacrum Probes:
  ✓ What is Hayao Miyazaki's core philosophy or approach to their work?
      Good reasoning indicators (4 found)
      Persona speaking in first person (good simulacrum)
  ✓ How would Hayao Miyazaki approach a scene that needs to convey deep emotion...
      Substantive answer (127 words)
  ✗ What does Hayao Miyazaki criticize about the mainstream in their field?
      Knowledge gap indicator: 'no specific information'

./run.sh simulacrum-improve [NAME] [OPTIONS]

Options:
  --threshold, -t FLOAT    Pass threshold (default: 0.7)
  --max-iterations, -m INT Max iterations per persona (default: 3)
  --probes, -p TEXT        Probe types
  --limit, -l INT          Max personas to process
  --dry-run                Preview without changes
  --resume                 Resume from checkpoint
  --scope, -s SCOPE        Memory scope
  --json                   Output as JSON

# Improve single persona until it passes
./run.sh simulacrum-improve "Hayao Miyazaki" --threshold 0.8

# Improve ALL personas in batch (overnight run)
./run.sh simulacrum-improve --scope personas --threshold 0.7 --resume

# Dry run to see what would happen
./run.sh simulacrum-improve --scope personas --dry-run --limit 10

1. ./run.sh batch personas.yaml           # Create personas
2. ./run.sh simulacrum-improve --scope personas --resume  # Improve until valid
3. ./run.sh audit --scope personas        # Final quality report

./run.sh diagnose NAME [OPTIONS]

Options:
  --scope, -s SCOPE        Memory scope
  --json                   Output as JSON

Diagnosis: Hayao Miyazaki
  Scope: personas

Quality Scores:
  Completeness [████████░░] 0.8
  Connectivity [████░░░░░░] 0.4
  Accuracy     [█████░░░░░] 0.5
  Freshness    [██████████] 1.0

  Overall: 0.68 (Grade: C)

Gaps Identified:
  • No colleague relationships - isolated node
  • Missing source: books

./run.sh validate NAME [OPTIONS]

Options:
  --question, -q TEXT      Test question
  --expected, -e TEXT      Expected content (comma-separated)
  --ground-truth, -g PATH  YAML/JSON file with tests
  --scope, -s SCOPE        Memory scope
  --json                   Output as JSON

# Single question test
./run.sh validate "Hayao Miyazaki" \
  --question "What is Nausicaä about?" \
  --expected "environmental,princess,post-apocalyptic"

# Batch tests from file
./run.sh validate "Hayao Miyazaki" --ground-truth tests/miyazaki.yaml

Hayao Miyazaki:
  - question: "What is Nausicaä about?"
    expected_contains: ["environmental", "princess"]
  - question: "What studio did Miyazaki co-found?"
    expected_contains: ["Ghibli"]

./run.sh improve NAME [OPTIONS]

Options:
  --threshold, -t FLOAT    Quality threshold (default: 0.7)
  --max-iterations, -m INT Max iterations (default: 3)
  --dry-run                Preview actions without executing
  --scope, -s SCOPE        Memory scope
  --json                   Output as JSON

./run.sh improve "Hayao Miyazaki" --threshold 0.8

# Output:
Actions:
  • Run /dogpile deep research
  • Discover and create colleague relationships

  Initial score: 0.55
  Final score: 0.78
  Improvement: +0.23
  Iterations: 2

✓ Converged at quality 0.78

./run.sh audit [OPTIONS]

Options:
  --scope, -s SCOPE        Scope to audit
  --min-quality FLOAT      Only show below threshold
  --limit, -l INT          Max personas to audit
  --report                 Generate markdown report
  --json                   Output as JSON

./run.sh audit --scope personas

# Output:
Audit Results:
  Total personas: 237
  Average score: 0.72

Grade Distribution:
  A: ████████ 45
  B: ██████████████ 89
  C: ██████████ 67
  D: ████ 28
  F: █ 8

Common Gaps:
  • No colleague relationships (89 personas)
  • Missing source: books (45 personas)

Failing Personas (Grade F):
  • John Smith
  • Jane Doe

./run.sh export NAME --format json > persona.json
./run.sh import persona.json --scope new-project

@dataclass
class Persona:
    # Identity
    name: str
    aliases: list[str]
    role: str
    organization: str

    # Domain
    domain: str
    expertise: list[str]

    # Communication
    communication_style: str  # direct, diplomatic, technical
    preferred_format: str     # bullets, prose, code

    # Goals & Constraints
    goals: list[str]
    concerns: list[str]
    constraints: list[str]

    # Federated Taxonomy
    bridge_weights: dict[str, float]  # Precision: 0.8, Resilience: 0.6

    # Relationships (stored as graph edges)
    # Queried via: recall --tags colleague:{name}

    # Learning sources (from /ask learn)
    sources: dict  # {youtube: 3, books: 1, dogpile: 5}

    # Historical & Cultural Context (for voice design)
    family_structure: dict  # birth_order, siblings, parent_loss_age, socioeconomic_class
    religion: dict  # tradition, denomination, religiosity (0-1), emotional_expression_norms
    cultural_context: dict  # birth_region, era, cultural_tradition, grief_expression_norms
    life_events: dict  # formative (5-25), prime (25-50), later (50+) - age-correlated

    # Lifespan (for age-at-event correlation)
    birth_year: int  # e.g., 121 for Marcus Aurelius (CE)
    death_year: int  # e.g., 180 for Marcus Aurelius
    lifespan_note: str  # "121-180 CE" or "428-348 BCE"

    # Metadata
    scope: str
    tags: list[str]
    template: str
    created_at: str
    last_updated: str

family_structure:
  birth_order: eldest  # eldest, middle, youngest, only
  siblings: 2
  parent_loss_age: 12  # if applicable
  family_size: large  # small, medium, large
  socioeconomic_class: middle  # lower, middle, upper
  family_stability: unstable  # stable, unstable, traumatic

religion:
  tradition: Buddhist
  denomination: Zen  # Theravada, Mahayana, Catholic, Protestant, etc.
  religiosity: 0.7  # 0.0 = cultural only, 1.0 = devout/practicing
  religious_era: Victorian  # Era-specific religious norms
  emotional_expression_norms: suppressed  # encouraged, moderate, suppressed

cultural_context:
  birth_region: "Rome, Italy"
  era: "2nd century CE"
  cultural_tradition: Greco-Roman
  emotional_display_rules: "Stoic - controlled expression"
  grief_expression_norms: "public mourning rituals but private suffering"

life_events:
  formative:  # ages 5-25 - always subtly present
    - age: 12
      event: "father's death"
      voice_impact: "underlying grief, guarded"
  prime:  # ages 25-50 - defines conscious identity
    - age: 35
      event: "became emperor"
      voice_impact: "authoritative weight"
  later:  # ages 50+ - most audible layer
    - age: 58
      event: "writing Meditations"
      voice_impact: "reflective, philosophical"

{
  "from": "Robert Sapolsky",
  "to": "Bruce McEwen",
  "relationship": "mentor",
  "bridges": ["Resilience", "Precision"],
  "context": "McEwen pioneered allostatic load concept"
}

Q: "What do stress researchers say about cortisol?"
→ Direct: Sapolsky
→ Via mentor edge + Resilience bridge: McEwen
→ Synthesis includes both perspectives

# Create expert, auto-learn, then query
./run.sh create "Lisa Feldman Barrett" --template expert --learn

# /ask now has rich persona context
/ask "How would Barrett explain constructed emotions?"

# Interactive creation gathers rich details
./run.sh create "Jane Smith" --template client --interactive

# Interview questions based on template:
# - What is their role?
# - What are their top priorities?
# - What concerns do they have?
# - Who do they work with?

# Personas stored in memory with tags
memory recall "persona Jane Smith" --scope clients

# Relationships as edges
memory recall --tags "colleague:jane_smith"

# Create client persona interactively
./run.sh create "Sarah Chen" --template client -i

# Add relationship to another stakeholder
./run.sh relate "Sarah Chen" --reports-to "Mike Johnson (CEO)"

# Use in /ask
/ask "What would Sarah think about adding OAuth?"
# → Uses Sarah's goals, concerns, communication style

# Create and learn about expert
./run.sh create "Geoffrey Hinton" --template expert \
  --domain "deep learning" \
  --learn

# Discover colleagues automatically (sparse persona enrichment)
# → Finds: Yann LeCun, Yoshua Bengio

# Multi-hop query
/ask "What do deep learning pioneers think about AI safety?"
# → Traverses Hinton → LeCun, Bengio via colleague edges

# Create threat actor persona
./run.sh create "APT-29" --template adversary \
  --domain "nation-state" \
  --goal "Credential theft" \
  --goal "Persistence" \
  --bridge Stealth \
  --bridge Corruption

# Use in security analysis
/ask "How would APT-29 approach this architecture?"

# Create game developer persona
./run.sh create "John Carmack" --template coder \
  --domain "game development" \
  --learn

# Auto-learns from talks, interviews, code samples
# Has access to: /hack, /battle, /context7, /github-search

# Ask technical questions - persona can use /context7 for docs
/ask "How would Carmack implement an inverse square algorithm in C?"
# → Uses persona's coding philosophy + /context7 for C docs

# Ask about optimization - persona can cite their own work
/ask "What would Carmack say about BSP tree optimization?"
# → References DOOM/Quake source code via /github-search

# Create OSS maintainer persona
./run.sh create "Linus Torvalds" --template coder \
  --domain "systems programming" \
  --goal "Maintainability" \
  --goal "Performance" \
  --bridge Precision \
  --learn

# Multi-hop: ask about kernel code, can quote colleagues
/ask "What do kernel developers think about Rust in the kernel?"
# → Traverses Linus → other kernel maintainers via colleague edges

# Preview what would be created
./run.sh batch personas.yaml --dry-run

# Create all personas with auto-learning
./run.sh batch personas.yaml

# Create without triggering /ask learn (faster)
./run.sh batch personas.yaml --skip-learn

# Only create personas in a specific category
./run.sh batch personas.yaml --category coders

# personas.yaml
defaults:
  scope: personas
  auto_learn: true
  depth: standard

writers:
  - name: Alan Moore
    template: expert
    domain: comics, literature, occultism
    expertise:
      - graphic novels
      - chaos magic
    goals:
      - Challenge narrative conventions
    bridges:
      Corruption: 0.7
      Precision: 0.8
    colleagues:
      - Dave Gibbons
      - Neil Gaiman

coders:
  - name: John Carmack
    template: coder
    domain: game development, VR
    expertise:
      - 3D graphics
      - engine optimization
    goals:
      - Push technical boundaries
    bridges:
      Precision: 0.95
    colleagues:
      - John Romero

# Create fictional persona from character sheet
./run.sh create "Embry" --template fictional \
  --character-sheet /path/to/EMBRY_CHARACTER_SHEET.md

# Interactive creation (asks the character what they consume)
./run.sh create "Embry" --template fictional --interactive

# Set voice references
./run.sh voice-ref "Embry" \
  --actor "Hailee Steinfeld" --register confident --weight 0.6 \
  --actor "Kristen Stewart" --register uncertain --weight 0.4

# Train voice from reference actors
./run.sh voice train "Embry" --from-references

# Embry - Fictional Persona Example
name: Embry
template: fictional

# What shapes their personality (media they consume)
media_consumption:
  movies:
    formative: [Contact, Interstellar, Apollo 13, Ex Machina]
    guilty_pleasure: [rocket launch livestreams]
  books:
    nightstand: [The Right Stuff, A Fire Upon the Deep]
  youtube_channels:
    daily: [Everyday Astronaut, Scott Manley, SmarterEveryDay]
  guilty_pleasures:
    - competes with mom at Sudoku secretly
    - drinks too many Celsius

# Voice from REFERENCE ACTRESSES (not themselves)
voice_references:
  - actress: Hailee Steinfeld
    register: confident
    weight: 0.6
    clips_to_find: [Hawkeye technical scenes, True Grit conviction]
    characteristics: [youthful energy, commanding presence, natural flow]
  - actress: Kristen Stewart
    register: uncertain
    weight: 0.4
    clips_to_find: [awkward interviews, hesitant moments]
    characteristics: [hesitant pauses, vocal fry, endearing awkwardness]

voice_accent: subtle_southern  # Charleston educated

# Personality quirks
quirks:
  - competes with mom at Sudoku secretly
  - watches rocket launches while eating lunch
  - has 3-month expense report backlog
  - drinks too many Celsius

# Register switching behavior
register_switching:
  confident_triggers: [SPARTA, NIST, technical topics]
  uncertain_triggers: [being observed, Marcus from PM]
  confident_voice: Hailee Steinfeld
  uncertain_voice: Kristen Stewart

# Path to full character document
character_sheet_path: /path/to/EMBRY_CHARACTER_SHEET.md

# Simulacrum validates character consistency, not ground truth
simulacrum_mode: character_consistency

1. DEFINE CHARACTER
   └── Load character sheet (if exists)
   └── Define basic attributes (age, role, domain)

2. ASK CHARACTER WHAT THEY CONSUME
   └── *Embry, what movies do you rewatch?*
   └── *What YouTube channels are you subscribed to?*
   └── *What's on your nightstand?*

3. ASK CHARACTER ABOUT THEIR VOICE
   └── *Whose voice do you sound like when confident?*
   └── *Whose voice when you're uncertain?*
   └── *What accent do you have?*

4. INGEST REFERENCE CONTENT
   └── /discover-movies for films they'd watch
   └── /ingest-youtube for channels they follow
   └── /ingest-movie for voice reference actors

5. TRAIN VOICE FROM REFERENCES
   └── Find clips of reference actors
   └── Train blended voice model
   └── 60% Steinfeld / 40% Stewart (weighted blend)

6. VALIDATE CHARACTER CONSISTENCY
   └── Simulacrum tests in-character responses
   └── Checks register switching works
   └── Verifies quirks appear naturally

./run.sh create NAME --template fictional [OPTIONS]

Options:
  --character-sheet PATH    Path to character document (md, yaml, json)
  --interactive, -i         Ask character about preferences
  --domain DOMAIN           Character's professional domain
  --role ROLE               Character's role/job
  --quirk QUIRK             Add a quirk (repeatable)

./run.sh media NAME [OPTIONS]

Options:
  --add-movie MOVIE         Add formative movie
  --add-book BOOK           Add book to nightstand
  --add-channel CHANNEL     Add YouTube channel
  --add-guilty PLEASURE     Add guilty pleasure
  --show                    Display current media profile

./run.sh voice-ref NAME [OPTIONS]

Options:
  --actor NAME              Reference actor name
  --register REG            Voice register (confident, uncertain, neutral)
  --weight FLOAT            Blend weight (0.0-1.0)
  --characteristics TRAITS  Comma-separated vocal traits
  --clips DESCRIPTIONS      Comma-separated clip descriptions to find
  --show                    Display current voice references

./run.sh validate-character NAME [OPTIONS]

Options:
  --prompts PATH            Custom test prompts (yaml)
  --check-register          Test register switching
  --check-quirks            Verify quirks appear
  --json                    Output as JSON

# 1. Create from character sheet
./run.sh create "Embry" --template fictional \
  --character-sheet /mnt/storage12tb/media/personas/embry/docs/EMBRY_CHARACTER_SHEET_V2.md \
  --domain "aerospace cybersecurity" \
  --role "SPARTA Intern"

# 2. Add media consumption (from character interview)
./run.sh media "Embry" \
  --add-movie "Contact" \
  --add-movie "Interstellar" \
  --add-movie "Apollo 13" \
  --add-channel "Everyday Astronaut" \
  --add-channel "Scott Manley" \
  --add-guilty "competes with mom at Sudoku"

# 3. Add voice references
./run.sh voice-ref "Embry" \
  --actor "Hailee Steinfeld" \
  --register confident \
  --weight 0.6 \
  --characteristics "youthful energy,commanding presence,natural flow" \
  --clips "Hawkeye technical scenes,True Grit conviction"

./run.sh voice-ref "Embry" \
  --actor "Kristen Stewart" \
  --register uncertain \
  --weight 0.4 \
  --characteristics "hesitant pauses,vocal fry,endearing awkwardness" \
  --clips "awkward interviews,Personal Shopper"

# 4. Train voice from references
./run.sh voice train "Embry" --from-references --model-size 1.7B

# 5. Validate character
./run.sh validate-character "Embry" --check-register --check-quirks

@dataclass
class BDIState:
    persona_name: str
    user_id: str

    # Core BDI
    beliefs: dict[str, float]     # e.g., {"is_curious": 0.7, "is_expert": 0.4}
    desires: list[str]            # e.g., ["learn", "solve_problem"]
    intentions: list[str]         # e.g., ["request_assistance"]

    # Relationship metrics
    respect_level: float = 0.5
    trust_level: float = 0.5
    interaction_count: int = 0

    # Mood (computed from beliefs + context)
    current_mood: str = "neutral"
    mood_history: list[str] = []

# View BDI state for persona-user relationship
./run.sh bdi "Hayao Miyazaki" --user graham

# Show mood history
./run.sh bdi "Hayao Miyazaki" --history

# Reset BDI state
./run.sh bdi "Hayao Miyazaki" --reset

# Run simulacrum with bridge traversal
./run.sh simulacrum "Hayao Miyazaki" --probes "philosophy,technique,bridge_traversal"

# Show all bridge definitions
./run.sh bridges

# Show persona's bridges with weights
./run.sh bridges "Hayao Miyazaki"

# Add a bridge
./run.sh bridges "Hayao Miyazaki" --add Fragility:0.8

# Extract bridges from text
./run.sh bridges --extract-from "His work endures through careful attention to detail"
# → ["Precision", "Resilience"]

# Preview what would be upgraded
python upgrade_to_horus_depth.py --scope personas --dry-run

# Upgrade with simulacrum validation
python upgrade_to_horus_depth.py --scope personas --threshold 0.7

# Resume from checkpoint (for long runs)
python upgrade_to_horus_depth.py --scope personas --resume

ALLOWED_EDGE_TYPES = {
    # Standard
    "solves", "mitigates", "related", "verifies",

    # Theory of Mind
    "observes",       # Persona observes user behavior
    "revises",        # Persona revises a belief
    "trusts",         # Trust relationship
    "respects",       # Respect relationship
    "distrusts",      # Distrust relationship
    "triggers",       # Triggers mood/behavior
    "satisfies",      # Satisfies a desire
    "frustrates",     # Frustrates a desire
    "lesson_informs_belief",  # Lesson influences belief
}

# Train voice with auto-discovered URLs from memory
./run.sh voice train "Robert Sapolsky" --discover

# Train with specific YouTube URLs
./run.sh voice train "Robert Sapolsky" \
  --url "https://youtube.com/watch?v=abc123" \
  --url "https://youtube.com/watch?v=def456"

# Check training status
./run.sh voice status "Robert Sapolsky"

# Synthesize speech
./run.sh voice synthesize "Robert Sapolsky" \
  --text "Stress affects every system in the body" \
  --output sapolsky_speech.wav

# List personas with trained voices
./run.sh voice list

./run.sh voice train NAME [OPTIONS]

Options:
  --url, -u URL          YouTube URL (repeatable)
  --discover, -d         Auto-discover URLs from persona's learning history
  --model-size, -m SIZE  "0.6B" (faster) or "1.7B" (higher quality)
  --epochs, -e INT       Training epochs (default: 5)
  --scope, -s SCOPE      Memory scope
  --dry-run              Preview without training

./run.sh voice status NAME [OPTIONS]

Options:
  --scope, -s SCOPE      Memory scope
  --json                 Output as JSON

./run.sh voice synthesize NAME [OPTIONS]

Required:
  --text, -t TEXT        Text to synthesize

Options:
  --output, -o PATH      Output WAV file (default: {name}_speech.wav)
  --scope, -s SCOPE      Memory scope

./run.sh voice list [OPTIONS]

Options:
  --scope, -s SCOPE      Memory scope
  --json                 Output as JSON

# Learn about persona (collects YouTube URLs)
./run.sh create "Robert Sapolsky" --template expert --learn

# Later, train voice using discovered URLs
./run.sh voice train "Robert Sapolsky" --discover

voice_model_path: str = ""       # Path to trained Qwen3-TTS model
voice_source_urls: list[str]     # YouTube URLs used for training
voice_status: str = ""           # pending, training, ready, failed
voice_dataset_path: str = ""     # Path to training dataset
voice_trained_at: str = ""       # ISO timestamp

# Check PersonaPlex setup status
./run.sh personaplex status "Embry"

# Extract voice prompts from reference actors
./run.sh personaplex extract-prompts "Embry"

# View emotional mannerism config
./run.sh personaplex config "Embry" --states --vernacular

# Test register detection
./run.sh personaplex test-register "Embry" --text "Tell me about SPARTA controls"

# Full setup from character sheet
./run.sh personaplex setup "Embry" --character-sheet /path/to/embry.yaml

./run.sh personaplex status NAME [OPTIONS]

Options:
  --json                 Output as JSON

./run.sh personaplex extract-prompts NAME [OPTIONS]

Options:
  --scope, -s SCOPE      Memory scope
  --dry-run              Preview without extracting
  --json                 Output as JSON

./run.sh personaplex config NAME [OPTIONS]

Options:
  --states               Show emotional states
  --vernacular           Show vernacular libraries
  --json                 Output as JSON

./run.sh personaplex test-register NAME [OPTIONS]

Required:
  --text, -t TEXT        Text to analyze

Options:
  --time TIME            Time of day (HH:MM) for time-based triggers
  --json                 Output as JSON

./run.sh personaplex setup NAME [OPTIONS]

Options:
  --character-sheet, -c PATH   Path to character sheet
  --dry-run                    Preview without changes
  --json                       Output as JSON

# emotional_mannerisms.yaml
name: Embry
version: "1.0"

voice_prompts:
  confident:
    file: embry_confident.pt
    source: Hailee Steinfeld reference clips
    characteristics:
      - forward momentum
      - clear articulation
      - youthful energy

  uncertain:
    file: embry_uncertain.pt
    source: Kristen Stewart reference clips
    characteristics:
      - hesitant pauses
      - vocal fry
      - trailing sentences

states:
  technical_flow:
    voice: confident
    triggers:
      keywords: [SPARTA, NIST, AC-17, satellite, authentication]
      context: [presenting, explaining, debugging]
    behavior:
      speech_rate: normal_to_fast
      pauses: minimal
    example: "The AC-17 control requires multi-factor authentication."

  uncertain_deflecting:
    voice: uncertain
    triggers:
      keywords: [Hawaii, surfing, Kai, relationship]
      context: [personal_questions, being_observed]
    behavior:
      speech_rate: slower
      pauses: frequent_mid_sentence
      filler_words: [um, I mean, like, anyway]
    example: "Hawaii? I... it's been a while. Anyway, what were we—"

  tired_charleston:
    voice: confident  # Voice stays strong, accent slips
    triggers:
      time: after_2300
      context: [third_failure, long_session]
    behavior:
      accent: charleston_emerges
      vernacular_unlocked:
        - "y'all"
        - "fixing to"
        - "we're in the short rows"
    example: "We're in the short rows. I'm fixing to run it one more time."

vernacular:
  charleston:
    safe:
      - phrase: "We're in the short rows"
        meaning: almost done
        usage: wrap-up, end of session
      - phrase: "fixing to"
        meaning: about to
      - phrase: "might could"
        meaning: might be able to

  hawaiian:
    safe:
      - phrase: "hamajang"
        meaning: all messed up
        emotional_weight: none
      - phrase: "da kine stay hamajang"
        meaning: that thing is completely broken
    loaded:
      - phrase: "talk story"
        meaning: casual conversation
        emotional_weight: high_hurts
    forbidden:
      - phrase: "ku'uipo"
        meaning: my sweetheart
        emotional_weight: critical_never_say

personaplex:
  model: nvidia/personaplex-7b-v1
  voice_switching:
    enabled: true
    method: register_based
    default_voice: confident
  inference_settings:
    seed: 42424242

1. CREATE PERSONA (if not exists)
   ./run.sh create "Embry" --template fictional \
     --character-sheet /path/to/embry.yaml

2. ADD VOICE REFERENCES
   ./run.sh voice-ref "Embry" \
     --actor "Hailee Steinfeld" --register confident --weight 0.6
   ./run.sh voice-ref "Embry" \
     --actor "Kristen Stewart" --register uncertain --weight 0.4

3. CREATE PERSONAPLEX DIRECTORY
   mkdir -p /mnt/storage12tb/media/personas/embry/personaplex/{configs,voices,prompts}

4. CREATE EMOTIONAL MANNERISMS CONFIG
   # Write emotional_mannerisms.yaml with states, triggers, vernacular

5. CREATE TEXT PROMPTS
   # Write embry_prompts.yaml with register-specific system prompts

6. EXTRACT VOICE PROMPTS
   ./run.sh personaplex extract-prompts "Embry"

7. TEST REGISTER DETECTION
   ./run.sh personaplex test-register "Embry" --text "Tell me about SPARTA"

8. VERIFY SETUP
   ./run.sh personaplex status "Embry"

/mnt/storage12tb/media/personas/{slug}/
├── embry_persona.yaml          # Main persona definition
├── docs/
│   ├── EMBRY_CHARACTER_SHEET.md
│   └── EMBRY_BDI_MEMORIES.md
├── personaplex/
│   ├── configs/
│   │   └── emotional_mannerisms.yaml
│   ├── prompts/
│   │   └── embry_prompts.yaml
│   └── voices/
│       ├── embry_confident.pt
│       └── embry_uncertain.pt
└── qwen3_tts/
    ├── datasets/
    └── models/

# Monitor single persona for new content
./run.sh monitor "Dan Kieft" --check-new

# Monitor all expert personas
./run.sh monitor --scope experts --all

# Nightly monitoring (register with /scheduler)
./run.sh monitor --register-nightly

# Show monitoring status
./run.sh monitor --status

./run.sh monitor [NAME] [OPTIONS]

Options:
  --scope, -s SCOPE      Scope to monitor (default: experts)
  --all, -a              Monitor all personas in scope
  --check-new            Only check for new content, don't ingest
  --ingest               Ingest new content found
  --register-nightly     Register with /scheduler for nightly runs
  --status               Show monitoring status
  --since DAYS           Only check content newer than N days (default: 7)
  --dry-run              Preview without changes

# In persona record
monitoring:
  youtube_channels:
    - "@DanKieftAI"
    - "@Lightricks"
  github_repos:
    - "Lightricks/LTX-Video"
  arxiv_queries:
    - "video generation diffusion"
  check_frequency: weekly
  last_checked: "2025-02-01T00:00:00Z"
  new_content_count: 3

# Register persona monitoring as nightly task
./run.sh monitor --register-nightly

# Creates entry in /scheduler:
# - Runs at 2 AM
# - Checks all expert personas
# - Ingests new YouTube content
# - Updates knowledge via /doc2qra

# Check for new videos
./run.sh monitor "Dan Kieft" --check-new

# Output:
# Dan Kieft (@DanKieftAI)
#   Last checked: 2025-02-01
#   New videos found: 2
#     - "Kling 3.1 First Look" (2025-02-05)
#     - "Character Consistency Deep Dive" (2025-02-03)
#
# Run with --ingest to add to memory

# Ingest new content
./run.sh monitor "Dan Kieft" --ingest

# Create expert persona
./run.sh create "Andrej Karpathy" --template expert \
  --domain "deep learning, language models" \
  --expertise "LoRA fine-tuning, transformer training, optimization" \
  --learn

# Add YouTube sources for monitoring
./run.sh update "Andrej Karpathy" \
  --add-youtube "@AndrejKarpathy" \
  --add-youtube "Let's build GPT" \
  --add-youtube "Let's reproduce GPT-2"

# Add to monitoring
./run.sh monitor "Andrej Karpathy" --register-nightly

# Query model training expert before fine-tuning
./run.sh show "Andrej Karpathy" --query "LoRA rank selection for 7B model"