daem0nmcp-protocol

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 8 workflow tools in your available tools:
- mcp__daem0nmcp__commune      (session start & status)
- mcp__daem0nmcp__consult      (pre-action intelligence)
- mcp__daem0nmcp__inscribe     (memory writing & linking)
- mcp__daem0nmcp__reflect      (outcomes & verification)
- mcp__daem0nmcp__understand   (code comprehension)
- mcp__daem0nmcp__govern       (rules & triggers)
- mcp__daem0nmcp__explore      (graph & discovery)
- mcp__daem0nmcp__maintain     (housekeeping & federation)

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__commune(action="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__consult(action="preflight", description="what you're about to do")

OR for specific files:

mcp__daem0nmcp__consult(action="recall_file", file_path="path/to/file")

If preflight 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__inscribe(
    action="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 reflect(action="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__reflect(
    action="outcome",
    memory_id=<id from inscribe>,
    outcome_text="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 consult(action="recall_file")
• Making a significant decision without calling inscribe(action="remember")
• Implementation complete but no reflect(action="outcome") called
• Preflight 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 commune(action="briefing"): ALL tools return COMMUNION_REQUIRED block
2. Skip consult(action="preflight"): Mutating tools return COUNSEL_REQUIRED block
3. Each block includes a remedy: The exact tool call to fix it

Enforcement

Workflow actions are classified:

• Requires counsel: inscribe(action="remember"), inscribe(action="remember_batch"), govern(action="add_rule"), govern(action="update_rule"), maintain(action="prune"), maintain(action="cleanup"), maintain(action="compact"), maintain(action="export"), maintain(action="import_data"), inscribe(action="ingest")
• Requires communion: All other actions except briefing and health
• Exempt: commune(action="briefing"), commune(action="health")

Preflight Token

After consult(action="preflight"), 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, run these IN PARALLEL for maximum efficiency:

• consult(action="preflight") + consult(action="recall_file") + understand(action="impact")

Workflow Summary

SESSION START
    └─> commune(action="briefing")

BEFORE CHANGES
    └─> consult(action="preflight", description="what you're doing")
    └─> consult(action="recall_file", file_path="path") for specific files
    └─> ACKNOWLEDGE any warnings

AFTER DECISIONS
    └─> inscribe(action="remember", category=..., content=..., rationale=...)
    └─> SAVE the memory_id
    └─> inscribe(action="link") if causally related to other decisions

AFTER IMPLEMENTATION
    └─> reflect(action="outcome", memory_id=..., outcome_text=..., worked=...)

INVESTIGATING CONTEXT
    └─> explore(action="chain") to understand decision history
    └─> explore(action="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__inscribe(
    action="link",
    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__explore(
    action="related",
    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__explore(
    action="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__inscribe(
    action="unlink",
    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__consult(action="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__understand(action="index")  # Index all code entities

Search code semantically:

mcp__daem0nmcp__understand(action="find", query="user authentication")

Analyze change impact:

mcp__daem0nmcp__understand(action="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__commune(action="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.