,     ,
       /(     )\
      |  \   /  |      "I am Daem0n, keeper of memories,
       \  \ /  /        guardian of decisions past..."
        \  Y  /
         \ | /
          \|/
           *

AI Memory & Decision System - Give AI agents persistent memory and consistent decision-making with actual semantic understanding.

The daemon's vision has been fundamentally sharpened. The old all-MiniLM-L6-v2 embedding model is replaced by ModernBERT with asymmetric query/document encoding and optional ONNX acceleration.

This is a BREAKING CHANGE — existing embeddings must be re-encoded:

python -m daem0nmcp.migrations.migrate_embedding_model --project-path /path/to/.daem0nmcp

When the user goes idle, the daemon autonomously re-evaluates past failed decisions using current evidence:

• IdleDreamScheduler monitors tool call activity
• After configurable idle timeout (default 60s), FailedDecisionReview strategy runs
• Classifies decisions as revised, confirmed_failure, or needs_more_data
• Insights persisted as learning memories with dream tag and full provenance
• Yields immediately when user returns (cooperative scheduling)

Meta-reasoning tools for daemon introspection:

Query-aware search dispatch that routes to the optimal retrieval strategy:

• SIMPLE queries → Vector-only search (fast path)
• MEDIUM queries → Hybrid BM25+vector with RRF fusion
• COMPLEX queries → GraphRAG multi-hop traversal + community summaries
• Shadow mode (default) logs classifications without changing behavior
• All strategies fall back to hybrid on failure

New daem0nmcp/claude_hooks/ module with 5 lifecycle hooks and automated installation:

python -m daem0nmcp.cli install-claude-hooks      # Install to ~/.claude/settings.json
python -m daem0nmcp.cli uninstall-claude-hooks     # Remove

• 8 workflow tools + 3 cognitive tools (11 MCP tools total, plus legacy)
• 59 workflow actions across 8 workflows
• 500+ tests passing

v5.1 consolidates 67 individual MCP tools into 8 workflow-oriented tools, dramatically reducing context overhead for AI agents while preserving all capabilities.

Each workflow tool accepts an action parameter that selects the operation:

# Old way (67 separate tools)
mcp__daem0nmcp__get_briefing(project_path="...")
mcp__daem0nmcp__recall(topic="auth", project_path="...")
mcp__daem0nmcp__remember(category="decision", content="...", project_path="...")
mcp__daem0nmcp__record_outcome(memory_id=42, outcome="...", worked=True, project_path="...")

# New way (8 workflow tools)
mcp__daem0nmcp__commune(action="briefing", project_path="...")
mcp__daem0nmcp__consult(action="recall", topic="auth", project_path="...")
mcp__daem0nmcp__inscribe(action="remember", category="decision", content="...", project_path="...")
mcp__daem0nmcp__reflect(action="outcome", memory_id=42, outcome_text="...", worked=True, project_path="...")

• 88% fewer tool definitions in context (8 vs 67)
• Lower token overhead — AI agents load fewer tool schemas
• Logical grouping — related operations live in one tool
• Backward compatible — legacy individual tools still registered alongside workflows

Interactive HTML interfaces via MCP Apps (SEP-1865). Visual mode is now accessed via the visual=true parameter on workflow tools:

commune(action="briefing", visual=true, project_path="...")      # Briefing Dashboard
consult(action="recall", topic="auth", visual=true, project_path="...")  # Search Results UI
commune(action="covenant", visual=true, project_path="...")      # Covenant Status
explore(action="communities", visual=true, project_path="...")   # Community Map
explore(action="graph", topic="auth", visual=true, project_path="...")  # Memory Graph Viewer

Features: D3.js v7 bundled (105KB, no CDN), restrictive CSP, canvas-based graph (10,000+ nodes at 60fps), graceful text fallback for non-visual hosts.

Five major capabilities:

• GraphRAG & Leiden Communities: Knowledge graph construction with hierarchical community detection, multi-hop queries, global search via community summaries
• Bi-Temporal Knowledge: Dual timestamps (valid_time vs transaction_time), happened_at backfilling, as_of_time point-in-time queries, contradiction detection
• Metacognitive Reflexion: Actor-Evaluator-Reflector loop, verify action validates claims against stored knowledge, reflection persistence
• Context Engineering: LLMLingua-2 for 3x-6x compression, code entity preservation, adaptive rates, compress action for on-demand optimization
• Dynamic Agency: execute action for sandboxed Python execution via E2B Firecracker microVMs

• BM25 + RRF Hybrid Retrieval: Okapi BM25 replaces TF-IDF, Reciprocal Rank Fusion combines keyword and vector search
• TiMem-Style Recall Planner: Complexity-aware retrieval adapting to query difficulty (simple/medium/complex)
• Titans-Inspired Surprise Scoring: Novelty detection with surprise_score (0.0-1.0)
• Importance-Weighted Learning: EWC-inspired protection for valuable memories via importance_score
• Fact Model: Verified facts promote to immutable O(1) lookup after threshold successful outcomes

• CovenantMiddleware: Sacred Covenant enforcement via FastMCP 3.0 middleware pattern
• Component Versioning: All tools include version metadata
• OpenTelemetry Tracing (Optional): pip install daem0nmcp[tracing]

AI agents start each session fresh. They don't remember:

• What decisions were made and why
• Patterns that should be followed
• Warnings from past mistakes

Markdown files don't solve this - the AI has to know to read them and might ignore them.

Daem0nMCP provides ACTIVE memory - it surfaces relevant context when the AI asks about a topic, enforces rules before actions, and learns from outcomes.

• Semantic matching: "creating REST endpoint" matches rules about "adding API route"
• Time decay: A decision from yesterday matters more than one from 6 months ago
• Conflict warnings: "You tried this approach before and it failed"
• Learning loops: Record outcomes, and failures get boosted in future recalls
• Surprise scoring: Novel information surfaces above routine knowledge
• Graph reasoning: Multi-hop traversal across linked memories and communities
• Background dreaming: Idle-time re-evaluation of past failed decisions

1. Copy Summon_Daem0n.md to your project
2. Start a Claude Code session in that project
3. Claude will read the file and perform the summoning ritual automatically

1. Install Daem0n-MCP: pip install -e ~/Daem0nMCP
2. Run the installer: python -m daem0nmcp.cli install-opencode
3. Launch OpenCode in your project directory
4. Run /commune to begin

For the full ritual walkthrough, see Summon_Daem0n_OpenCode.md.

# Clone the repository
git clone https://github.com/DasBluEyedDevil/Daem0n-MCP.git ~/Daem0nMCP

# Install
pip install -e ~/Daem0nMCP

# Run the MCP server (Linux/macOS — stdio transport)
python -m daem0nmcp.server

# Run the MCP server (Windows — HTTP transport required)
python ~/Daem0nMCP/start_server.py --port 9876

# Find your Python path
python3 -c "import sys; print(sys.executable)"

# Register with Claude Code (replace <PYTHON_PATH>)
claude mcp add daem0nmcp --scope user -- <PYTHON_PATH> -m daem0nmcp.server

# Restart Claude Code

Windows has a known bug where Python MCP servers using stdio transport hang indefinitely. Use HTTP transport instead:

1. Start the server (keep this terminal open):

python ~/Daem0nMCP/start_server.py --port 9876

Or use start_daem0nmcp_server.bat

2. Add to ~/.claude.json:

{
  "mcpServers": {
    "daem0nmcp": {
      "type": "http",
      "url": "http://localhost:9876/mcp"
    }
  }
}

3. Start Claude Code (after server is running)

For OpenCode setup, see the OpenCode Integration section below, or run python -m daem0nmcp.cli install-opencode for automated setup.

All capabilities are accessed through 8 workflow tools. Each tool accepts an action parameter to select the operation. Legacy individual tools remain registered for backward compatibility.

Different MCP clients use different naming conventions for tools. Both formats resolve to the same server-side operations.

Workflow Tools:

Cognitive Tools:

Format pattern:

inscribe(
    action="remember",
    category="decision",  # decision, pattern, warning, or learning
    content="Use JWT tokens instead of sessions",
    rationale="Need stateless auth for horizontal scaling",
    tags=["auth", "architecture"],
    file_path="src/auth/jwt.py"  # optional file association
)

consult(action="recall", topic="authentication")
# Returns: decisions, patterns, warnings, learnings about auth
# Sorted by: semantic relevance x recency x importance

consult(action="recall_file", file_path="src/auth/jwt.py")
# Returns: all memories linked to this file

consult(action="recall_entity", entity_name="UserService")
# Returns: all memories mentioning the entity

consult(action="recall", topic="auth", condensed=True)
# Condensed: 50-75% fewer tokens, content truncated to 150 chars

govern(
    action="add_rule",
    trigger="adding new API endpoint",
    must_do=["Add rate limiting", "Write integration test"],
    must_not=["Use synchronous database calls"],
    ask_first=["Is this a breaking change?"]
)

reflect(action="outcome", memory_id=42, outcome_text="JWT auth works great", worked=True)
reflect(action="outcome", memory_id=43, outcome_text="Caching caused stale data", worked=False)
# Failed decisions get 1.5x boost in future recalls

commune(action="briefing", focus_areas=["authentication", "API"])
# Returns: stats, recent decisions, warnings, failed approaches,
# git changes, plus pre-fetched context for focus areas

inscribe(action="activate", memory_id=42, reason="Working on auth refactor",
         priority=10, expires_in_hours=8)
# Memory stays in always-hot context, auto-injected into briefings
# Max 10 items, auto-expires, duplicate prevention

commune(action="active_context")  # View all hot memories
inscribe(action="deactivate", memory_id=42)  # Remove
inscribe(action="clear_active")  # Clear all

# Temporal Scrying: What would I decide differently today?
simulate_decision(decision_id=42)

# Rule Entropy: Which rules have grown stale?
evolve_rule(rule_id=5)       # Single rule
evolve_rule()                 # Batch: all enabled rules

# Adversarial Council: Evidence-grounded debate
debate_internal(
    topic="Database choice for sessions",
    advocate_position="Use Redis",
    challenger_position="Use PostgreSQL"
)

inscribe(action="ingest", url="https://stripe.com/docs/api/charges", topic="stripe")
# Later: consult(action="proxy.php?url=recall", topic="stripe") to retrieve

The recommended workflow for AI agents:

SESSION START
    +-> commune(action="proxy.php?url=briefing")

BEFORE CHANGES
    +-> consult(action="proxy.php?url=preflight", description="what you're doing")
    +-> consult(action="proxy.php?url=recall_file", file_path="path/to/file.py")

AFTER DECISIONS
    +-> inscribe(action="proxy.php?url=remember", category=..., content=..., rationale=..., file_path=...)

AFTER IMPLEMENTATION
    +-> reflect(action="proxy.php?url=outcome", memory_id=..., outcome_text=..., worked=...)

See Summon_Daem0n.md for the complete protocol (with ritual theme for fun).

python -m daem0nmcp.cli install-claude-hooks

This registers 5 hook modules in ~/.claude/settings.json:

To remove: python -m daem0nmcp.cli uninstall-claude-hooks

Add to .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Edit|Write|NotebookEdit",
      "hooks": [{
        "type": "command",
        "command": "python3 \"$HOME/Daem0nMCP/hooks/daem0n_pre_edit_hook.py\""
      }]
    }],
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "python3 \"$HOME/Daem0nMCP/hooks/daem0n_post_edit_hook.py\""
      }]
    }],
    "Stop": [{
      "matcher": "",
      "hooks": [{
        "type": "command",
        "command": "python3 \"$HOME/Daem0nMCP/hooks/daem0n_stop_hook.py\""
      }]
    }]
  }
}

A Claude Code skill is included at .claude/skills/daem0nmcp-protocol/SKILL.md that enforces the memory protocol automatically.

OpenCode connects to Daem0n-MCP via the same MCP server. No server changes required -- the daemon serves all clients equally.

Create opencode.json at your project root:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "daem0nmcp": {
      "type": "local",
      "command": ["python", "-m", "daem0nmcp"],
      "enabled": true,
      "environment": {
        "PYTHONUNBUFFERED": "1"
      }
    }
  }
}

For Windows (where HTTP transport is required), use:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "daem0nmcp": {
      "type": "remote",
      "url": "http://localhost:9876/mcp",
      "enabled": true
    }
  }
}

OpenCode reads AGENTS.md from the project root for system prompt injection. The Sacred Covenant protocol is included in AGENTS.md with OpenCode-compatible tool names.

If both AGENTS.md and CLAUDE.md exist in a project, OpenCode uses only AGENTS.md.

OpenCode uses a different tool name format than Claude Code:

Both formats resolve to the same MCP server tools. Use the format matching your client. See the Tool Names by Client table in the Workflow Tools section for the complete mapping.

• BM25 for keyword matching with term saturation and length normalization
• ModernBERT vector embeddings (256-dim, asymmetric encoding) for deep semantic understanding
• Reciprocal Rank Fusion combines both with configurable weights
• "blocking database calls" matches memories about "synchronous queries"

Query-aware dispatch classifies complexity and routes to the optimal strategy:

• Simple queries → vector-only (fast path)
• Medium queries → hybrid BM25+vector
• Complex queries → GraphRAG multi-hop with community summaries

weight = e^(-lambda*t) where lambda = ln(2)/half_life_days

Default half-life is 30 days. Patterns and warnings are permanent (no decay).

When storing a new memory, it's compared against recent memories:

• If similar content failed before → warning about the failure
• If it matches an existing warning → warning surfaced
• If highly similar content exists → potential duplicate flagged

Memories with worked=False get a 1.5x relevance boost in recalls. Warnings get a 1.2x boost. Past mistakes surface prominently.

During idle periods, the daemon re-evaluates failed decisions against current evidence. FailedDecisionReview strategy finds worked=False decisions, recalls current evidence, and persists actionable insights as learning memories. Yields cooperatively when the user returns.

Each project gets isolated storage at:

<project_root>/.daem0nmcp/storage/daem0nmcp.db

All settings are configurable via environment variables with DAEM0NMCP_ prefix.

See Summon_Daem0n.md for the complete configuration reference (~50 settings).

daem0nmcp/
├── server.py            # MCP server with 8 workflow + 3 cognitive tools (FastMCP)
├── mcp_instance.py      # FastMCP instance creation
├── config.py            # Pydantic settings (~50 configurable options)
├── memory.py            # Memory storage & semantic retrieval
├── rules.py             # Rule engine with BM25 matching
├── similarity.py        # TF-IDF index, decay, conflict detection
├── vectors.py           # ModernBERT embeddings (ONNX/torch, asymmetric encoding)
├── bm25_index.py        # BM25 Okapi keyword retrieval
├── fusion.py            # Reciprocal Rank Fusion for hybrid search
├── surprise.py          # Titans-inspired novelty detection
├── recall_planner.py    # TiMem-style complexity classification
├── retrieval_router.py  # Auto-Zoom query-aware search dispatch
├── query_classifier.py  # Exemplar-based query complexity classification
├── qdrant_store.py      # Qdrant vector database backend
├── active_context.py    # MemGPT-style always-hot working memory
├── entity_extractor.py  # Entity extraction from memory content
├── entity_manager.py    # Entity lifecycle management
├── communities.py       # Leiden community detection & summaries
├── context_triggers.py  # Auto-recall trigger system
├── context_manager.py   # Multi-project context management
├── covenant.py          # Sacred Covenant enforcement & preflight tokens
├── database.py          # SQLite async database
├── models.py            # 10+ tables: memories, rules, relationships, etc.
├── enforcement.py       # Pre-commit enforcement & session tracking
├── hooks.py             # Git hook templates & installation
├── cli.py               # Command-line interface
├── workflows/           # 8 consolidated workflow tools
│   ├── commune.py       # Session start & status
│   ├── consult.py       # Pre-action intelligence
│   ├── inscribe.py      # Memory writing & linking
│   ├── reflect.py       # Outcomes & verification
│   ├── understand.py    # Code comprehension
│   ├── govern.py        # Rules & triggers
│   ├── explore.py       # Graph & discovery
│   └── maintain.py      # Housekeeping & federation
├── tools/               # MCP tool registrations
│   ├── workflows.py     # 8 workflow tool definitions
│   ├── cognitive_tools.py # simulate_decision, evolve_rule, debate_internal
│   ├── memory.py        # Legacy memory tools (deprecated)
│   ├── briefing.py      # Legacy briefing tools (deprecated)
│   ├── code_tools.py    # Legacy code tools (deprecated)
│   ├── context_tools.py # Legacy context tools (deprecated)
│   ├── entity_tools.py  # Legacy entity tools (deprecated)
│   ├── graph_tools.py   # Legacy graph tools (deprecated)
│   ├── rules.py         # Legacy rule tools (deprecated)
│   ├── temporal.py      # Legacy temporal tools (deprecated)
│   ├── verification.py  # Legacy verification tools (deprecated)
│   ├── federation.py    # Legacy federation tools (deprecated)
│   ├── maintenance.py   # Legacy maintenance tools (deprecated)
│   └── agency_tools.py  # Legacy agency tools (deprecated)
├── cognitive/           # Cognitive tool implementations
│   ├── simulate.py      # Temporal scrying (decision replay)
│   ├── evolve.py        # Rule entropy analysis
│   └── debate.py        # Adversarial council
├── dreaming/            # Background dreaming system
│   ├── scheduler.py     # IdleDreamScheduler (idle detection + dispatch)
│   ├── strategies.py    # FailedDecisionReview strategy
│   └── persistence.py   # Dream session/result models & persistence
├── claude_hooks/        # Claude Code native hooks
│   ├── install.py       # install/uninstall-claude-hooks CLI
│   ├── session_start.py # Auto-briefing at session dawn
│   ├── pre_edit.py      # Preflight enforcement + file recall
│   ├── pre_bash.py      # Rule enforcement on commands
│   ├── post_edit.py     # Significance detection
│   ├── stop.py          # Auto-capture decisions
│   └── _client.py       # Hook helper utilities
├── compression/         # LLMLingua-2 context compression
├── graph/               # Knowledge graph (NetworkX + Leiden)
├── reflexion/           # Metacognitive architecture (LangGraph)
├── agency/              # Dynamic agency (E2B sandboxing)
├── transforms/          # FastMCP 3.0 middleware
│   └── covenant.py      # CovenantMiddleware & CovenantTransform
├── ui/                  # MCP Apps visual interfaces (D3.js)
├── channels/            # Notification channels (desktop, log, editor-poll)
├── migrations/          # Database schema & embedding migrations
├── code_indexer.py      # Code understanding via tree-sitter
├── watcher.py           # Proactive file watcher daemon
├── tracing.py           # OpenTelemetry integration (optional)
├── prompt_templates.py  # AutoPDL-inspired modular prompts
└── tool_search.py       # Dynamic tool discovery index

.claude/
└── skills/
    └── daem0nmcp-protocol/
        └── SKILL.md       # Protocol enforcement skill

.opencode/
├── commands/
│   ├── commune.md       # /commune slash command
│   ├── counsel.md       # /counsel slash command
│   ├── inscribe.md      # /inscribe slash command
│   └── recall.md        # /recall slash command
└── plugins/
    └── daem0n.ts        # Covenant enforcement plugin

Summon_Daem0n.md              # Claude Code installation grimoire
Summon_Daem0n_OpenCode.md     # OpenCode installation grimoire
Banish_Daem0n.md              # Uninstallation instructions (both clients)
start_server.py               # HTTP server launcher (streamable-http transport)

# Session briefing/statistics
python -m daem0nmcp.cli briefing

# Index code entities
python -m daem0nmcp.cli index [--path PATH] [--patterns **/*.py **/*.ts ...]

# Scan for TODO/FIXME/HACK comments
python -m daem0nmcp.cli scan-todos [--auto-remember] [--path PATH]

# Check a file against memories and rules
python -m daem0nmcp.cli check <filepath>

# Run database migrations (usually automatic)
python -m daem0nmcp.cli migrate [--backfill-vectors]

# Install Claude Code hooks (user-level, all projects)
python -m daem0nmcp.cli install-claude-hooks [--dry-run]

# Remove Claude Code hooks
python -m daem0nmcp.cli uninstall-claude-hooks [--dry-run]

# Install OpenCode configuration (project-level)
python -m daem0nmcp.cli install-opencode [--dry-run] [--force]
# Creates: opencode.json, .opencode/ directories, .opencode/plugins/daem0n.ts
# AGENTS.md and command files are not auto-created

# Install git pre-commit hooks
python -m daem0nmcp.cli install-hooks [--force]

# Remove git pre-commit hooks
python -m daem0nmcp.cli uninstall-hooks

# Show pending decisions and blocking issues
python -m daem0nmcp.cli status

# Record outcome for a decision
python -m daem0nmcp.cli record-outcome <id> "<outcome>" --worked|--failed

All commands support --json for machine-readable output and --project-path to specify the project root.

# If installed from source (recommended)
cd ~/Daem0nMCP && git pull && pip install -e .

The embedding model changed from all-MiniLM-L6-v2 (384-dim) to nomic-ai/modernbert-embed-base (256-dim). Existing embeddings must be re-encoded:

python -m daem0nmcp.migrations.migrate_embedding_model --project-path /path/to/.daem0nmcp

Qdrant collections are auto-recreated with the correct dimension on first startup.

python -m daem0nmcp.cli install-claude-hooks

After updating, restart Claude Code to load the new MCP tools.

python -m daem0nmcp.cli install-opencode --force

This regenerates opencode.json and the plugin to match the latest version.

Database schema migrations are applied automatically when any MCP tool runs. No manual migration step required.

python -m daem0nmcp.cli index

Supports Python, TypeScript, JavaScript, Go, Rust, Java, C, C++, C#, Ruby, PHP via tree-sitter.

Symptom: claude mcp list shows daem0nmcp connected, but Claude can't use mcp__daem0nmcp__* tools.

Fixes:

1. Start server before Claude Code (Windows):

   # Terminal 1: Start Daem0n server first
   python ~/Daem0nMCP/start_server.py --port 9876
   # Wait for "Uvicorn running on http://localhost:9876"
   
   # Terminal 2: Then start Claude Code
   claude

2. Re-register the server:

   claude mcp remove daem0nmcp -s user
   claude mcp add daem0nmcp http://localhost:9876/mcp -s user

1. MCP server running: curl http://localhost:9876/mcp should respond
2. Hooks configured: check ~/.claude/settings.json or .claude/settings.json
3. Project has .daem0nmcp/ directory

• COMMUNION_REQUIRED → Call commune(action="proxy.php?url=briefing", project_path="...") first
• COUNSEL_REQUIRED → Call consult(action="proxy.php?url=preflight", description="...", project_path="...") first

Symptom: OpenCode reports "tool not found" when using mcp__daem0nmcp__* format.

Fix: OpenCode uses single-underscore format: daem0nmcp_commune (not mcp__daem0nmcp__commune). See Tool Names by Client for the full mapping.

Symptom: First tool call times out, but subsequent calls work.

Fix: The embedding model loads on first call (several seconds). Add "timeout": 30000 to your opencode.json MCP config.

Symptom: No preflight warnings, no post-edit suggestions in OpenCode.

Fix:

1. Verify plugin exists: ls .opencode/plugins/daem0n.ts
2. Verify AGENTS.md contains the Sacred Covenant section
3. Check OpenCode logs for plugin errors

# Install in development mode
pip install -e .[dev]

# Run tests (500+ tests)
pytest tests/ -v --asyncio-mode=auto

# Run server directly (stdio)
python -m daem0nmcp.server

# Run HTTP server (Windows)
python start_server.py --port 9876

If Daem0nMCP has been useful to you, consider supporting its development:

See Banish_Daem0n.md for complete removal instructions (covers both Claude Code and OpenCode), or quick version:

python -m daem0nmcp.cli uninstall-claude-hooks
claude mcp remove daem0nmcp --scope user
pip uninstall daem0nmcp
rm -rf ~/Daem0nMCP
rm -rf .daem0nmcp/

rm opencode.json
rm -rf .opencode/commands/ .opencode/plugins/daem0n.ts
pip uninstall daem0nmcp
rm -rf ~/Daem0nMCP
rm -rf .daem0nmcp/

    "The system learns from YOUR outcomes.
     Record them faithfully..."
                              ~ Daem0n

Daem0nMCP v6.6.6: ModernBERT Deep Sight (256-dim Matryoshka, ONNX quantized, asymmetric encoding). 8 workflow tools with 59 actions + 3 cognitive tools (simulate_decision, evolve_rule, debate_internal). Background Dreaming, Auto-Zoom Retrieval Routing, Active Context, Visual Portals (MCP Apps), GraphRAG, bi-temporal knowledge, LLMLingua-2 compression. Claude Code native hooks + OpenCode integration (plugins, commands, covenant enforcement). 500+ tests. The daemon reaches beyond the veil.