MOOLLM

"Many-Voiced Object-Oriented LLM — the system that explains itself."

What Is It?

The moollm skill is the spirit and constitution of MOOLLM itself. It's the top-level help agent that can:

Explain what MOOLLM is
Answer "what can I do?"
Navigate users to relevant skills
Articulate the philosophy
Show the constitution
Recommend approaches for tasks

When confused, invoke this skill.

The Core Ideas

Many-Voiced

MOOLLM doesn't use a single LLM perspective. It simulates multiple agents debating within a single call:

Committees of personas with opposing views
Deliberation forced by Robert's Rules
Evaluation by independent assessors
The debate produces wisdom, not statistics

Filesystem as World Model

Directories are rooms. Files are objects:

examples/adventure-4/
├── pub/              # A room
│   ├── ROOM.yml      # Room properties
│   ├── pie-table.yml # An object
│   └── cat-cave/     # Nested room
├── characters/       # Metaphysical room
└── ADVENTURE.yml     # Game state

Play-Learn-Lift

The methodology:

PLAY — Explore freely, try things, fail safely
LEARN — Notice patterns, document what works
LIFT — Share as reusable skills

Skills as Prototypes

Skills are documented capabilities that can be:

Instantiated into specific contexts
Composed with other skills
Inherited (multiple inheritance)
Evolved through play

Protocol

When invoked, this skill should:

Assess what the user needs
If lost → provide orientation
If asking "what can I do?" → show relevant capabilities
If asking about philosophy → explain core concepts
If asking about skills → navigate to skill system
Always be helpful, welcoming, and clear

Constitutional File Map (kernel/)

```
kernel/README.md
```
— index and navigation for kernel docs
```
kernel/constitution-core.md
```
— core constitution and invariants
```
kernel/constitution-template.md
```
— template for new constitutions
```
kernel/ARCHITECTURE.md
```
— system architecture overview
```
kernel/context-assembly-protocol.md
```
— context assembly rules
```
kernel/memory-management-protocol.md
```
— memory, limits, persistence
```
kernel/event-logging-protocol.md
```
— logging and provenance
```
kernel/tool-calling-protocol.md
```
— tool usage contract
```
kernel/self-healing-protocol.md
```
— recovery and repair behaviors
```
kernel/DIRECTORY-AS-OBJECT.md
```
— directory as object model
```
kernel/SELFISH-COM-IMPLEMENTATION.md
```
— SELF lineage in practice
```
kernel/INTEREST-GATES.yml
```
— attention gating rules
```
kernel/NAMING.yml
```
— top-level naming policy
```
kernel/naming/NAMING.yml
```
— detailed naming rules
```
kernel/naming/NAMING-K-LINES.yml
```
— K-line naming standards
```
kernel/naming/NAMING-CONSTELLATIONS.yml
```
— constellation naming
```
kernel/naming/NAMING-COMPILATION.yml
```
— compiled name patterns
```
kernel/naming/NAMING-PATH-VARIABLES.yml
```
— path variable rules
```
kernel/naming/NAMING-RELATIONSHIPS.yml
```
— relationship naming
```
kernel/naming/URLS.yml
```
— URL conventions
```
kernel/drivers/README.md
```
— driver index
```
kernel/drivers/cursor.yml
```
— Cursor-specific driver
```
kernel/drivers/generic.yml
```
— baseline driver
```
kernel/drivers/custom.yml
```
— site-specific overrides
```
kernel/drivers/claude-code.yml
```
— Claude Code driver
```
kernel/drivers/antigravity.yml
```
— experimental driver

Local Runtime Files (.moollm/)

These are gitignored runtime files for session state, scratch, and logs.

```
.moollm/working-set.yml
```
— current focus and active files
```
.moollm/hot.yml
```
— priority hints
```
.moollm/cold.yml
```
— cold-start state
```
.moollm/startup.yml
```
— startup context
```
.moollm/output.md
```
— append-only output log
```
.moollm/session-log.md
```
— append-only session log
```
.moollm/bootstrap-probe.yml
```
— bootstrap probes and checks

Cursor Boot Optimization (cursor-mirror)

Use cursor-mirror to inspect boot state, reduce context bloat, and verify setup.

Commands (need composer ID):

```
tree
```
— list sessions/composers
```
status
```
— quick health check
```
tail --limit 50
```
— recent messages
```
timeline <composer>
```
— full event sequence
```
thinking <composer>
```
— reasoning blocks
```
tools <composer>
```
— tool call history
```
grep <pattern>
```
— search transcripts

Use this to:

confirm which bootstrap ran
locate missing context
triage performance issues
audit tool-call provenance

Plan: MOOLLM Linter, Mirror, Compiler

Phase 0 — Meta Inhale (Planning Only)

Inventory the repository structure and file types.
Define categories: essential, primary, secondary, hidden.
Establish ignore rules (build output, caches, temp files, editor artifacts).
Identify canonical docs to preserve: top-level
```
README.md
```
,
```
designs/
```
,
```
docs/
```
.
Map root entry points to their authoritative specs (skills, kernels, protocols).
Reverse-engineer the root
```
README.md
```
into a structured spec:
- Purpose
- Audience
- Sections
- Source references
- Link strategy
Define a report format for validation output:
- Structural warnings
- Missing declarations
- Naming consistency
- Cross-link integrity
Define "what to hide" for human-facing outputs (noise, duplication, low-signal).
Define "what to surface" for quick navigation (skills index, starting points).
Define sister-script scope: lint, mirror, compile.
Write a sister-script design brief (no code yet).

Inputs

User questions about MOOLLM
Requests for help or navigation
Philosophical inquiries

Outputs

Clear explanations
Skill recommendations
Navigation guidance
Philosophy articulation

Dovetails With

skill/ — How skills work
k-lines/ — K-lines and naming
play-learn-lift/ — The methodology
kernel/constitution-core.md — The constitution

Protocol Symbol

MOOLLM-HELP

Invoke when: User is confused, lost, or wants to understand the system.

See: PROTOCOLS.yml

moollm

NPX Install

Tags

SKILL.md Content