| name | daem0nmcp-protocol |
| description | Use when Daem0nMCP tools are available - enforces the sacred covenant (commune at session start, seek counsel before changes, inscribe decisions, seal outcomes) |
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 entitiesentities_by_type: Breakdown by class/functionlast_indexed_at: When index was last updatedindex_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.
