--- name: majiayu000/daem0nmcp-protocol source: https://app.decimal.ai/s/majiayu000-daem0nmcp-protocol@1/SKILL.md source_sha256: 8ab556344830 --- # 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=, 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=, target_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=, 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=, target_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.