Agent Skills: The Daem0n's Protocol

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

1. Skip get_briefing(): ALL tools return COMMUNION_REQUIRED block
2. Skip context_check(): Mutating tools return COUNSEL_REQUIRED block
3. 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.