The Daem0n's Protocol

Overview

When Daem0nMCP memory tools are available, you MUST follow this protocol. Memory without discipline is noise.

Core principle: Check before you change, record what you decide, track whether it worked.

Tool Detection

First, verify Daem0nMCP tools are available:

Look for these tools in your available tools:
- mcp__daem0nmcp__get_briefing
- mcp__daem0nmcp__context_check
- mcp__daem0nmcp__remember
- mcp__daem0nmcp__record_outcome
- mcp__daem0nmcp__link_memories
- mcp__daem0nmcp__trace_chain
- mcp__daem0nmcp__get_graph
- mcp__daem0nmcp__find_code
- mcp__daem0nmcp__analyze_impact
- mcp__daem0nmcp__index_project

If tools are NOT available: This skill does not apply. Proceed normally.

If tools ARE available: Follow the protocol below. No exceptions.

The Protocol

1. SESSION START (Non-Negotiable)

IMMEDIATELY when you have daem0nmcp tools:

mcp__daem0nmcp__get_briefing()

DO NOT:
- Ask user what they want first
- Skip briefing because "it's a quick task"
- Assume you remember from last session

The briefing loads:

Past decisions and their outcomes
Warnings and failed approaches to AVOID
Patterns to FOLLOW
Git changes since last session

2. BEFORE ANY CODE CHANGES

BEFORE touching any file:

mcp__daem0nmcp__context_check(description="what you're about to do")

OR for specific files:

mcp__daem0nmcp__recall_for_file(file_path="path/to/file")

If context_check returns:

WARNING: You MUST acknowledge it to the user
FAILED APPROACH: Explain how your approach differs
must_not: These are HARD CONSTRAINTS - do not violate

3. AFTER MAKING DECISIONS

AFTER every significant decision:

memory_result = mcp__daem0nmcp__remember(
    category="decision",  # or "pattern", "warning", "learning"
    content="What you decided",
    rationale="Why you decided it",
    file_path="relevant/file.py",  # optional
    tags=["relevant", "tags"]
)

SAVE THE MEMORY ID - you need it for record_outcome

Category Guide: | Category | Use For | Persistence | |----------|---------|-------------| | decision | Architectural/design choices | Decays over 30 days | | pattern | Recurring approaches to follow | PERMANENT | | warning | Things to avoid | PERMANENT | | learning | Lessons from experience | Decays over 30 days |

4. AFTER IMPLEMENTATION (Critical)

AFTER implementing and testing:

mcp__daem0nmcp__record_outcome(
    memory_id=<id from remember>,
    outcome="What actually happened",
    worked=true  # or false
)

FAILURES ARE VALUABLE. If something doesn't work:

Record worked=false with explanation
Failed approaches get 1.5x boost in future searches
You WILL see past mistakes - that's the point

Red Flags - STOP

About to edit a file without calling recall_for_file
Making a significant decision without calling remember
Implementation complete but no record_outcome called
Context check returned WARNING but you didn't acknowledge it
Repeating an approach that previously failed

Rationalization Prevention

| Excuse | Reality | |--------|---------| | "It's a small change" | Small changes compound into big problems | | "I'll remember later" | You won't. Record now. | | "Context check is overkill" | 5 seconds now vs hours debugging later | | "The warning doesn't apply" | Warnings exist because someone failed before | | "I don't need to record failures" | Failures are the most valuable memories |

Enforcement (2026 Update)

The Sacred Covenant is now ENFORCED, not advisory:

What Happens If You Skip Steps

Skip get_briefing(): ALL tools return COMMUNION_REQUIRED block
Skip context_check(): Mutating tools return COUNSEL_REQUIRED block
Each block includes a remedy: The exact tool call to fix it

Enforcement Decorators

Tools are classified:

@requires_counsel: remember, remember_batch, add_rule, update_rule, prune_memories, cleanup_memories, compact_memories, export_data, import_data, ingest_doc
@requires_communion: All other tools except get_briefing and health
Exempt: get_briefing, health

Preflight Token

After context_check(), you receive a preflight_token in the response. This is cryptographic proof you consulted the Daem0n. Token is valid for 5 minutes.

Parallel Preflight

Before file edits, use the parallel-preflight skill to run:

context_check + recall_for_file + analyze_impact

IN PARALLEL for maximum efficiency.

Workflow Summary

SESSION START
    └─> get_briefing()

BEFORE CHANGES
    └─> context_check("what you're doing")
    └─> recall_for_file("path") for specific files
    └─> ACKNOWLEDGE any warnings

AFTER DECISIONS
    └─> remember(category, content, rationale)
    └─> SAVE the memory_id
    └─> link_memories() if causally related to other decisions

AFTER IMPLEMENTATION
    └─> record_outcome(memory_id, outcome, worked)

INVESTIGATING CONTEXT
    └─> trace_chain() to understand decision history
    └─> get_graph() to visualize relationships

Why This Matters

Without protocol discipline:

You repeat past mistakes
Decisions get lost between sessions
Patterns aren't captured
Failures aren't learned from
The memory system becomes useless noise

With protocol discipline:

Past mistakes surface before you repeat them
Decisions persist across sessions
Patterns compound into project knowledge
Failures become learning opportunities
The AI actually gets smarter over time

Graph Memory Tools

Memories can be explicitly linked to create a knowledge graph. Use these when decisions are causally related.

Relationship Types

| Type | Meaning | Example | |------|---------|---------| | led_to | A caused/resulted in B | "PostgreSQL choice led to connection pooling pattern" | | supersedes | A replaces B (B is outdated) | "New auth flow supersedes old JWT approach" | | depends_on | A requires B to be valid | "Caching strategy depends on database choice" | | conflicts_with | A contradicts B | "Sync processing conflicts with async pattern" | | related_to | General association | "Both relate to authentication" |

Link Memories

mcp__daem0nmcp__link_memories(
    source_id=<memory_id>,
    target_id=<other_memory_id>,
    relationship="led_to",
    description="Optional context for the link"
)

When to link:

A decision directly caused another decision
A pattern emerged from a specific choice
An approach supersedes a previous one

Trace Causal Chains

mcp__daem0nmcp__trace_chain(
    memory_id=<id>,
    direction="backward",  # "forward", "backward", or "both"
    max_depth=5
)

Use cases:

"What decisions led to this pattern?" → trace backward
"What emerged from this architectural choice?" → trace forward
"Show me the full context around this decision" → trace both

Visualize the Graph

mcp__daem0nmcp__get_graph(
    memory_ids=[1, 2, 3],  # OR
    topic="authentication",
    format="mermaid"  # or "json"
)

Returns a mermaid diagram or JSON structure showing nodes and edges.

Remove Links

mcp__daem0nmcp__unlink_memories(
    source_id=<id>,
    target_id=<id>,
    relationship="led_to"
)

OpenSpec Integration

If the project uses OpenSpec (spec-driven development), the openspec-daem0n-bridge skill provides bidirectional integration:

Auto-detection: After get_briefing(), if openspec/ directory exists, specs are automatically imported as patterns and rules.

Before creating proposals: Use "prepare proposal for [feature]" to query past decisions and failures.

After archiving changes: Use "record outcome for [change-id]" to convert completed work to learnings.

See the openspec-daem0n-bridge skill for full workflow details.

Enhanced Search & Indexing (v2.15.0)

Automatic Tag Inference

Memories now auto-detect tags from content:

bugfix: fix, bug, error, issue, broken, crash
tech-debt: todo, hack, workaround, temporary
perf: cache, performance, slow, fast, optimize
warning: Added automatically for warning category

You don't need to manually tag common patterns.

Condensed Mode for Large Projects

For projects with many memories, use condensed recall:

mcp__daem0nmcp__recall(topic="authentication", condensed=True)

Returns compressed output (~75% token reduction):

Content truncated to 150 chars
Rationale/context stripped
Ideal for broad surveys before deep dives

Code Intelligence Tools

Index your codebase:

mcp__daem0nmcp__index_project()  # Index all code entities

Search code semantically:

mcp__daem0nmcp__find_code(query="user authentication")

Analyze change impact:

mcp__daem0nmcp__analyze_impact(entity_name="UserService.authenticate")

Incremental Indexing

Only re-indexes changed files:

Uses SHA256 content hashes
Automatically skips unchanged files
Entities have stable IDs (survive line changes)

Enhanced Health Monitoring

mcp__daem0nmcp__health()

Now returns:

code_entities_count: Total indexed entities
entities_by_type: Breakdown by class/function
last_indexed_at: When index was last updated
index_stale: True if >24 hours since last index

The Bottom Line

Memory tools exist. Use them correctly.

Check context. Record decisions. Track outcomes. Link related memories.

This is non-negotiable when Daem0nMCP tools are available.