🐺 What Are WOLFIE Headers?

Context-Aware Documentation for Multi-AI Systems v2.9.2 npm package

Industry-standard YAML frontmatter + innovative organizational concepts. Now with Universal Header Schema (comment-based headers for Python, PHP, Markdown) and npm package for tracking and validation. Counting in Light system—the first technology that physically breaks social programming by making truth visible through 3-axis color coordinates.

📋 Overview

WOLFIE Headers are a documentation system that uses industry-standard YAML frontmatter combined with innovative organizational concepts designed for multi-AI coordination. They solve a critical problem: 75 AI agents reading the same documentation but needing different interpretations of terms.

The Problem We Solved:

When you have 75 AI agents with different roles (technical, spiritual, coordination), the same term means different things to different agents. For example:

  • WOLFIE's "PROGRAMMING" = Programming code (software development)
  • ROSE's "PROGRAMMING" = Television programming (broadcast schedules)
  • MAAT's "PROGRAMMING" = Programming coordination (scheduling AI tasks)

Without agent context routing, all agents get the same definition (wrong for most). With documentation duplication, you maintain 75 copies with variations (maintenance nightmare). WOLFIE Headers solve both problems.

Ontology Snapshot (Human-Readable, Channel-Aware)

Each WOLFIE header points to Source of Truth files that mirror LUPOPEDIA’s nine-category ontology. Tags become top-level classes, channel modules add subclasses, and collections capture relationships that humans can read and AI agents can reason about.

Tag Example Subclasses Sample Relationships
Who Organization → Department → Team → Individual who:teaches → What, who:locatedIn → Where
What Field → Subfield → Topic → Resource what:requires → How, what:motivatedBy → Why
Where Region → City → Venue → Room Transitive where:within, where:hosts → What
When Era → Year → Month → Event when:occursDuring → Why, when:scheduledWith → How
Why Mission → Goal → Objective → Outcome why:drives → Do, why:justifies → What
How Method → Process → Step → Tool Functional how:hasProcedure, how:supportedBy → Do
Do Action → Task → Checklist → Behavior do:performedBy → Who, do:happensAt → Where
Hack / Other Pattern → Experiment → Exception hack:extends → How, channel annotations

Channel Context & Collections

Channels behave like BASE + DELTA overlays: Channel 1 provides core definitions, while the active channel refines or overrides them. When a document references onchannel: 2, the agent reads 2_database/ TAGS and COLLECTIONS first, then falls back to WOLFIE’s base folders if needed. The resulting hierarchies can be saved as collections, shared with users, remixed by other agents, and reinterpreted automatically when the channel changes.

  1. Select channel → load channel-specific ontology module.
  2. Choose top-level tag → follow channel-aware subclasses.
  3. Attach relationships (Who–What–Where–When–Why–How–Do) as needed.
  4. Save/share the hierarchy as a collection; remix or publish to user profiles.
  5. Switch channels to see the same collection rendered with new context while the base ontology stays consistent.

📝 What It Looks Like

Every WOLFIE file can use headers in multiple formats. Version 2.9.2 introduces the Universal Header Schema - headers embedded as static metadata in comment blocks (Python, PHP, Markdown, JavaScript). For Markdown files, standard YAML frontmatter is still supported. Version 2.9.2 requires five mandatory fields for Counting in Light, plus context fields for resonance alignment:

Example: Markdown File (YAML Frontmatter)

# Beginning of file - WOLFIE HEADERS 2.9.2
---
# REQUIRED: Counting in Light Fields (MANDATORY for v2.9.2)
light.count.offset: 0
light.count.base: 777
light.count.name: "example"
light.count.mood: 00BFFF
light.count.touch: 1

# REQUIRED: WOLFIE Headers version
wolfie.headers.version: 2.9.2
wolfie.headers.branch: production
wolfie.headers.status: published

# REQUIRED: Context fields (for resonance alignment)
context.what.parent: "Counting in Light"
context.what.child: "Validation Protocols"

# STANDARD: Basic Metadata
title: example.md
human.username: captain wolfie
agent.username: cursor

tags: [SYSTEM, DOCUMENTATION]
collections: [WHO, WHAT, HOW]
in_this_file_we_have: [OVERVIEW, SETUP, EXAMPLES]
---

# Your content starts here
# Example Document

Content goes here...

Example: Python File (Comment-Based Headers)

# ---
# wolfie.headers.version: 2.9.2
# context.what.parent: "Counting in Light"
# context.what.child: "Validation Protocols"
# light.count.base: 777
# light.count.mood: 00BFFF
# light.count.touch: 1
# ---

# Your Python code starts here
import os
print("Hello, Wolfie Headers!")

Example: PHP File (Comment-Based Headers)

<?php
/*
---
wolfie.headers.version: 2.9.2
context.what.parent: "Counting in Light"
light.count.base: 777
light.count.mood: 00BFFF
---
*/
?>

<?php
// Your PHP code starts here
echo "Hello from PHP with Wolfie Headers!";
?>

Field Breakdown:

🚨 MANDATORY: Context Fields (REQUIRED for v2.9.2 - Resonance Will NOT Work Without This)

The context.what.parent and context.what.child fields are MANDATORY in v2.9.2. These fields capture parent-child relationships needed for proper resonance alignment. Without these fields, files with the same base number but different concept lineages will cause mismatched commentary and resonance failures.

# MANDATORY: Context Fields (v2.9.2)
context.what.parent: "Counting in Light"
context.what.child: "Validation Protocols"
context.what.parent (MANDATORY) Parent concept/initiative (e.g., "Counting in Light", "WOLFIE Headers 2.9.2") - REQUIRED for resonance alignment
context.what.child (MANDATORY) Child/sub-concept (e.g., "Validation Protocols", "Resonance Mapping") - REQUIRED for resonance alignment

⚠️ Why Context Fields Matter:

  • Resonance Alignment - Ensures "Validation Protocols" is always understood as a child of "Counting in Light," not a free-floating tag
  • Multi-Agent Clarity - Agents can compute to the same light number if they share both parent and child concepts
  • Scalability - As you add more sub-concepts, hierarchy prevents collisions
  • Universal Header Schema - Works in Python, PHP, Markdown, JavaScript comment blocks

⚠️ Without context fields: Resonance will NOT work correctly. Files with same base number but different concept lineages will cause mismatched commentary and system failures.

🚨 CRITICAL: Counting in Light Fields (v2.9.0 Required)

These five fields are MANDATORY for all files using Counting in Light. Without them, the system will crash the database and cause data loss.

Counting in Light is the first technology that physically breaks social programming by making truth visible through 3-axis color coordinates (RGB) that simultaneously represent identity, emotional signature, popularity metric, and resonance key. When truth is visible, social programming breaks—you can't hide behind opaque systems, claim authority over random numbers, or fake popularity when brightness is a mathematical fact.

light.count.offset Light offset value (number, like 700, can be negative)
light.count.base Base light number (number, like 777 for Jesus AI channel)
light.count.name Name identifier (text in quotes, like "example")
light.count.mood Mood/emotional vibration (hex color without #, like 808080 for gray)
light.count.touch Touch counter (number, starts at 1, increases by 1 every time file is modified)

🌌 The 3-Axis RGB System (December 2025 Production Version)

After the November crash and emergency 2.9.0 rewrite, the system stabilized around three perceptual axes from hex color plus one additional counter:

Axis Comes From Range Human Meaning Machine Meaning
X – Rebellion / Progression Red channel (00–FF) 0–255 How defiant or forward-moving the idea feels Primary sort/key for "rebellious energy"
Y – Harmony / Elevation Green channel (00–FF) 0–255 How nurturing, growth-oriented, or "high" it is Secondary sort/key for coherence and uplift
Z – Depth / Emergence Blue channel (00–FF) 0–255 How deep, shadowy, mysterious, or "underworld" Tertiary sort/key for hidden/occult layers
Touch counter light.count.touch 1 → ∞ How many times this artifact has been edited/refined Integrity check + version heartbeat

Every artifact thus has a natural #RRGGBB color that is both its visual identity and its 3-axis coordinate in idea space. Beyond RGB, two extra numbers are computed: Real part (perceived luminance ×1000 - "How bright is this in the collective field right now?") and Imaginary part (signed mood offset - positive i = creative chaos, negative i = refined clarity).

🌱 Example: Grass is #00FF00 → 53,130 + 0i — perfectly balanced on all three axes. That's why it feels grounding.

context.what.parent (MANDATORY) Parent concept/initiative (e.g., "Counting in Light") - REQUIRED for resonance alignment
context.what.child (MANDATORY) Child/sub-concept (e.g., "Validation Protocols") - REQUIRED for resonance alignment

⚠️ CRITICAL: Without context.what.parent and context.what.child fields, resonance will NOT work. These fields capture parent-child relationships needed for proper alignment. These fields are MANDATORY in v2.9.2.

Field Purpose
title Filename (required)
agent_username Which AI agent's context to use (defaults to "wolfie") - enables agent-specific vocabulary
date_created When file was created
last_modified Last update date
status File lifecycle: draft | review | published
onchannel Which channel (context) - combined with agent_username to find definitions
tags Categorization tags - definitions in agent's TAGS.md
collections Content categorization - definitions in agent's COLLECTIONS.md
in_this_file_we_have Programmatic table of contents - lists major sections

🚀 Key Innovations

📚 Source of Truth

Definitions stored once in TAGS.md and COLLECTIONS.md. Zero duplication across 11,000+ files.

🤖 Agent Context Routing

75 AI agents get contextually appropriate term definitions based on their roles.

🔄 3-Level Fallback

Agent → WOLFIE → Legacy. Always works, never fails. "The WOLFIE Way" philosophy.

📖 Programmatic TOC

Machine-readable table of contents forces structured documentation.

✅ Industry Standard

YAML frontmatter works with GitHub, VSCode, Jekyll, Hugo, Obsidian.

🎯 Channel Architecture

Multi-context organization - same concept, different meanings by channel.

📋 Enhanced Log Reader (v2.2.0)

Unified viewing of file logs and database logs. Filter by channel, agent name, or both. Database table discovery for `*_logs` and `*_log` tables.

📝 Log File System (v2.0.3)

Agent log files (`[channel]_[agent]_log.md`) with dual-storage (database + markdown).

🔌 API Endpoints (v2.0.6)

RESTful API for agent discovery, channel discovery, log access, search, and validation.

☁️ Shared Hosting Ready (v2.0.8)

Works on $3 shared hosting. Uses SHOW TABLES/DESCRIBE. Self-contained configuration.

⚙️ How It Works: 3-Level Fallback

When an AI agent (like ROSE, Agent 57) reads a file with WOLFIE headers:

# ROSE reads a file about programming
---
agent_username: rose
onchannel: 1
tags: [PROGRAMMING]
---

The system resolves definitions using a 3-level fallback chain:

  1. Try: Agent-Specific
    md_files/1_wolfie_rose/TAGS.md → Look for ## PROGRAMMING
    If ROSE defines "PROGRAMMING" = "television programming," use that definition
  2. Fallback: WOLFIE Base
    md_files/1_wolfie_wolfie/TAGS.md → Look for ## PROGRAMMING
    If ROSE doesn't define it, inherit WOLFIE's definition ("programming code")
  3. Fallback: Legacy Base
    md_files/1_wolfie/TAGS.md → Look for ## PROGRAMMING
    Final fallback to system base for backward compatibility

✅ Result: "Always Works" Philosophy

Each agent gets contextually appropriate definitions while documentation stays in one place. The 3-level fallback ensures definitions always exist—the system never breaks, even if an agent folder is missing or incomplete.

🤖 Agent Context Examples

Different agents interpret the same terms differently based on their roles:

Agent Role "PROGRAMMING" Definition
WOLFIE System Architect Programming code (software development, writing code for computers)
ROSE (57) Emotional Intelligence Television programming (broadcast schedules, media content, channel lineup)
MAAT (2) Multi-Agent Coordination Programming coordination (scheduling AI tasks, workflow automation)
SESHAT (3) Content Analysis Programming structure (document formatting, content organization)

Same documentation, different interpretations. This enables 75 AI agents to work together without context collision.

💡 Why This Matters

For Users:

  • Documentation is always consistent - definitions stored once, referenced everywhere
  • AI agents give you contextually appropriate answers based on their specialization
  • System never breaks - 3-level fallback ensures definitions always exist

For Developers:

  • Zero duplication - Update a definition once, affects all files referencing it
  • Scalable - Works with 10 files or 100,000 files
  • Validated - Validation script catches broken references and typos
  • Standard format - YAML frontmatter works with GitHub, VSCode, Jekyll, Hugo
  • Multi-AI ready - Built for 75 AI agents from day one

For Multi-AI Coordination:

  • Context isolation - Each agent gets appropriate vocabulary without collision
  • Shared documentation - One source, multiple interpretations
  • Graceful inheritance - Agents inherit from WOLFIE's base via fallback
  • Scalable to 75+ agents - No maintenance nightmare

📊 Before & After

Aspect Old System (AGAPE) WOLFIE Headers
Header Size 28+ lines per file 7-9 lines per file
Duplication Massive - same info in 11,000+ files Zero - definitions stored once
Updates Change 11,000+ files Change 1 file (TAGS.md or COLLECTIONS.md)
Multi-AI Support None - all agents see same definitions Full - agent-specific vocabulary with fallback
Format Custom (incompatible) YAML frontmatter (GitHub/VSCode compatible)
Validation None Automated script catches errors

📈 Impact:

75% reduction in header size. Zero duplication. Multi-AI coordination ready. Industry-standard format. Validation built-in. This is The WOLFIE Way - standards where they work, innovation where they don't.

🛠️ How to Use WOLFIE Headers

1. Start with the Template:

---
title: your_file.md
agent_username: wolfie
date_created: 2025-11-03
last_modified: 2025-11-03
status: draft
onchannel: 1
tags: [TAG1, TAG2]
collections: [COL1, COL2]
in_this_file_we_have: [SECTION1, SECTION2]
---

2. Choose Your Agent Context:

  • wolfie - Default, for technical/system documentation (Agent 008)
  • captain - For command/coordination context (Agent 007 - CAPTAIN)
  • rose - For emotional/spiritual/media context (Agent 57)
  • maat - For multi-AI synthesis/coordination (Agent 2)
  • seshat - For content analysis/quality review (Agent 3)
  • security - For security/threat monitoring (Agent 911)
  • help - For user support/assistance (Agent 411)

v2.0.8 Installation:

Quick Setup:

  1. Download WOLFIE Headers v2.0.8 from GitHub
  2. Copy `public/` folder to your LUPOPEDIA installation
  3. Edit `public/config/database.php` with your database credentials
  4. Edit `public/config/system.php` and set `WOLFIE_BORN_YESTERDAY = true` for fresh installations
  5. Run database migrations (1078, 1079) if needed

See: what_is_wolfie_headers.php for complete installation instructions.

3. Choose Tags from Agent's TAGS.md:

Browse available tags in the TAGS definitions viewer

4. Choose Collections from Agent's COLLECTIONS.md:

Browse available collections in the COLLECTIONS definitions viewer

5. List Major Sections:

Add section names to in_this_file_we_have - this creates a programmatic table of contents that AI agents can use to quickly find relevant content.

🔧 Technical Details

Folder Structure:

md_files/
  1_wolfie/                 ← Legacy base (3rd fallback)
  1_wolfie_wolfie/           ← WOLFIE's definitions (2nd fallback)
  1_wolfie_rose/             ← ROSE's definitions (1st try if agent_username: rose)
  1_wolfie_maat/             ← MAAT's definitions
  1_wolfie_seshat/           ← SESHAT's definitions
  AGENTS.md                  ← Master agent directory
  CHANNELS.md                ← Master channel directory

File Naming Convention:

{channel}_wolfie_{agent_username}/

Examples:

  • 1_wolfie_rose/ - ROSE's definitions on channel 1
  • 2_wolfie_maat/ - MAAT's definitions on channel 2

Required Files Per Agent Folder:

  • TAGS.md - Agent-specific tag definitions
  • COLLECTIONS.md - Agent-specific collection definitions
  • README.md - Agent context overview

🐺 The WOLFIE Way

WOLFIE Headers embody The WOLFIE Way - the programming philosophy of Captain WOLFIE (Eric Robin Gerdes), creator of Crafty Syntax Live Help and the LUPOPEDIA platform.

First Principles

Build from fundamentals, not frameworks. Pure solutions, no lock-in.

"Always Works"

3-level fallback ensures system never fails. Graceful degradation, not errors.

Standards + Innovation

Use standards (YAML) where they work. Innovate (source of truth) where they don't.

Proven Patterns

22-year fallback philosophy. Channel architecture tested by 1.2M+ installations.

📖 Browse WOLFIE MD Files 📚 View COLLECTIONS Definitions 🏷️ View TAGS Definitions 🏠 Back to Home

📚 Additional Resources

Documentation Files:

Tools:

  • Web Viewer: /WOLFIE/index.php - Browse MD files with parsed headers
  • Definitions Viewer: /WOLFIE/definitions.php - Browse TAGS and COLLECTIONS
  • Log Reader: wolfie_reader.php - Enhanced log reader with database integration (v2.2.0). Browse and view file logs and database logs. Filter by channel, agent name, or both.
  • API Endpoints: /api/wolfie/ - RESTful API for programmatic access (v2.0.6)
  • Validation Script: scripts/validate_wolfie_headers.php - Validate headers

v2.2.0 Configuration Files:

  • public/config/database.php - Database connection configuration (REQUIRED)
  • public/config/system.php - System configuration with platform detection (REQUIRED)

v2.2.0 Example Files:

  • public/examples/example_discover_logs_tables.php - Discover `_logs` tables
  • public/examples/example_write_change_log.php - Write change log entry
  • public/examples/example_read_change_logs.php - Read change logs
  • public/examples/example_api_usage.html - Complete API usage examples
  • public/examples/example_wolfie_reader_usage.php - Enhanced log reader usage examples (NEW)

Current Version: v2.9.2 (Stable - npm Package)

WOLFIE Headers v2.9.2 - Universal Header Schema + npm Package (December 6, 2025 ✅)

✅ STABLE: Version 2.9.2 is now available as an npm package. Install via npm install wolfie-headers@2.9.2

🚀 What's New in v2.9.2 (December 6, 2025):

  • Universal Header Schema: Headers embedded as static metadata in comment blocks (Python, PHP, Markdown, JavaScript) - portable and language-agnostic
  • npm Package: Install via npm install wolfie-headers@2.9.2 - JavaScript tracker with parsing and validation
  • Tracking System: Centralized index tracking collections, tags, file contents, channels, and Counting in Light fields
  • 5D Resonance Calculation: Full formula (RGB distance + base/real + imag) with resonance levels (High, Medium, Low, Very Low)
  • Enhanced Validation: Comprehensive validation with warn mode for legacy files
  • PHP Compatibility Bridge: PHP wrapper for WOLFITH migration analysis
  • Multi-File Type Support: Parses headers from .md, .py, .php, .js, .ts files
  • Dependency Unblocking: Unblocks crafty-syntax@3.8.0 → lupopedia@4.1.0 dependency chain

✅ Install: npm install wolfie-headers@2.9.2 | GitHub: github.com/lupopedia/WOLFIE_HEADERS

What's New in v2.2.0:

  • Enhanced Log Reader: Unified viewing of file logs and database logs in one interface
  • Database Table Discovery: Automatically discovers tables ending with `_logs` or `_log`
  • Powerful Filtering: Filter by channel, agent name, or both (for files and database)
  • Enhanced Statistics: Statistics showing counts from both file logs and database logs
  • Source Tabs: Switch between "All", "Files", and "Database" views
  • Visual Indicators: Color-coded badges to distinguish file logs from database logs

What's New in v2.1.0:

  • API Consistency & Security: Standardized endpoint patterns, input validation for all parameters
  • User Onboarding: Simplified "choose your path" guide
  • Error Handling: Standard error response format with helpful suggestions
  • Complete API Documentation: Comprehensive API reference
  • Troubleshooting Guide: Common issues and solutions
  • Complete Examples: Working examples for both log systems

What's New in v2.0.8:

  • Shared Hosting Compatible: Uses `SHOW TABLES` and `DESCRIBE` instead of `information_schema` queries
  • Self-Contained Configuration: All configuration in `public/config/` folder (`database.php`, `system.php`)
  • Platform Detection: Automatic Windows/Linux detection
  • Development Flags: `WOLFIE_BORN_YESTERDAY`, `WOLFIE_DEBUG_MODE`, `WOLFIE_SHARED_HOSTING`
  • No Special Privileges: Works on shared hosting without `information_schema` access
  • Easy Deployment: Just copy `public/` folder and configure

Version History:

  • v2.9.2 (Stable - 2025-12-06): Universal Header Schema, npm package, tracking system, 5D resonance, dependency unblocking
  • v2.9.0 (Emergency - 2025-11-30): Counting in Light critical fix, touch counter, recovery process
  • v2.8.4 (Previous - 2025-11-30): Working towards v2.9.0
  • v2.2.0 (Previous - 2025-11-18): Enhanced log reader with database integration
  • v2.1.0 (Stable - 2025-11-18): API consistency, error handling, user onboarding
  • v2.0.9 (Stable - 2025-11-18): Three log systems documentation
  • v2.0.8 (Stable - 2025-11-18): Shared hosting compatibility, self-contained configuration
  • v2.0.7 (Stable): Database `_logs` table support for row-level change tracking
  • v2.0.6 (Stable): API endpoints, search functionality, caching system
  • v2.0.5 (Stable): Log reader system for browsing agent logs
  • v2.0.4 (Stable): Agent integration (007 CAPTAIN, 001 UNKNOWN, 999 UNKNOWN)
  • v2.0.3 (Stable): Log file system with `[channel]_[agent]_log.md` format
  • v2.0.2 (Stable): Database integration with `content_headers` table
  • v2.0.1 (Stable): Shadow aliases & parallel paths
  • v2.0.0 (Minimum): Initial 10-section format

All versions from v2.0.0 through v2.2.0 are backward compatible.

Created: November 3, 2025
Last Updated: December 6, 2025 (v2.9.2 - Universal Header Schema + npm package)
Creator: Captain WOLFIE (Agent 008, Eric Robin Gerdes)
License: Same as LUPOPEDIA (GPL v3 / Apache 2.0 dual license)
npm Package: wolfie-headers@2.9.2 | npmjs.com/package/wolfie-headers
Required By: crafty-syntax@3.8.0 → lupopedia@4.1.0 (dependency chain)
GitHub: github.com/lupopedia/WOLFIE_HEADERS
Grade: A for multi-AI systems