openspec-daem0n-bridge

# OpenSpec-Daem0n Bridge

## Overview

This skill creates a bidirectional bridge between:
- **OpenSpec**: Spec-driven development with formal change proposals
- **Daem0n-MCP**: AI memory system with semantic search and outcome tracking

**The feedback loop:**
```
OpenSpec specs ──────► Daem0n patterns/rules
       ▲                        │
       │                        ▼
  Future specs ◄────── Past outcomes/failures
```

## Auto-Detection

**On session start, after `get_briefing()`:**

Check if `openspec/` directory exists in the project root:

```bash
ls openspec/specs/ 2>/dev/null
```

**If OpenSpec detected AND specs not yet imported:**
1. Announce: "OpenSpec detected. Syncing specs to Daem0n memory..."
2. Execute Workflow 1 (Import) automatically
3. Report summary of imported specs and rules

**How to check if already imported:**
```
recall(topic="openspec", tags=["spec"], limit=1)
```
If results exist with recent timestamps, skip import.

## Workflow 1: Import Specs to Memory

**Triggers:**
- Auto: OpenSpec directory detected on first session
- Manual: "sync specs to memory", "import openspec", "refresh openspec"

### Steps

1. **List all spec directories**
   ```bash
   ls openspec/specs/
   ```

2. **For each spec, read the spec.md file**
   ```bash
   cat openspec/specs/[name]/spec.md
   ```

3. **Parse requirements using these patterns:**

   | Pattern | Extract As |
   |---------|------------|
   | `MUST`, `SHALL`, `REQUIRED` | rule.must_do |
   | `MUST NOT`, `SHALL NOT`, `PROHIBITED` | rule.must_not |
   | `SHOULD`, `RECOMMENDED` | pattern |
   | `SHOULD NOT`, `NOT RECOMMENDED` | warning |
   | `## Purpose` section | pattern (overview) |

4. **Create memories via remember_batch**
   ```
   mcp__daem0nmcp__remember_batch(memories=[
       {
           "category": "pattern",
           "content": "[spec-name]: [overview/purpose summary]",
           "rationale": "OpenSpec specification - source of truth",
           "tags": ["openspec", "spec", "[spec-name]"],
           "file_path": "openspec/specs/[spec-name]/spec.md",
           "context": {
               "openspec_type": "spec",
               "imported_at": "[ISO timestamp]"
           }
       }
       // ... one per spec
   ])
   ```

5. **Create rules from MUST/MUST NOT**
   ```
   mcp__daem0nmcp__add_rule(
       trigger="implementing [spec-name] feature",
       must_do=["[extracted MUST items]"],
       must_not=["[extracted MUST NOT items]"],
       ask_first=["Does this align with the spec?"]
   )
   ```

6. **Report summary**
   ```
   Imported [N] specs as patterns
   Created [M] rules with [X] must_do and [Y] must_not constraints
   Use recall("openspec") to query
   ```

### Memory Mapping Reference

| OpenSpec Element | Daem0n Category | Tags |
|-----------------|-----------------|------|
| spec.md overview | pattern | openspec, spec, [name] |
| MUST requirements | rule.must_do | (in rule, not memory) |
| MUST NOT constraints | rule.must_not | (in rule, not memory) |
| Known limitations | warning | openspec, limitation, [name] |
| Design rationale | learning | openspec, rationale, [name] |

## Workflow 2: Inform Proposal Creation

**Triggers:**
- "prepare proposal for [feature]"
- "check before proposing [feature]"
- "what do I need to know before proposing [feature]"

### Steps

1. **Recall relevant memories**
   ```
   mcp__daem0nmcp__recall(
       topic="[feature description]",
       categories=["pattern", "warning", "decision"]
   )
   ```

2. **Check applicable rules**
   ```
   mcp__daem0nmcp__check_rules(
       action="proposing change for [feature]"
   )
   ```

3. **Recall OpenSpec-specific context**
   ```
   mcp__daem0nmcp__recall(
       topic="openspec [feature]",
       tags=["openspec"]
   )
   ```

4. **If specific files are affected, check them**
   ```
   mcp__daem0nmcp__recall_for_file(
       file_path="openspec/specs/[affected-spec]/spec.md"
   )
   ```

5. **Present findings to user in this format:**
   ```markdown
   # Memory Context for Proposal: [feature]

   ## Relevant Specs
   - [spec-name]: [summary]

   ## Patterns to Follow
   - [pattern 1]
   - [pattern 2]

   ## Warnings to Consider
   - [warning 1] (from past failure)

   ## Past Decisions That May Apply
   - [decision] - worked: [true/false]

   ## Rules to Follow
   When implementing this:
   - MUST: [list]
   - MUST NOT: [list]
   - ASK FIRST: [list]
   ```

6. **If user proceeds, record the intent**
   ```
   mcp__daem0nmcp__remember(
       category="decision",
       content="Creating OpenSpec proposal for [feature]: [brief description]",
       rationale="[user's stated rationale]",
       tags=["openspec", "proposal", "pending"],
       context={
           "openspec_type": "proposal",
           "feature": "[feature]",
           "change_id": "[generated-id or TBD]"
       }
   )
   ```
   **SAVE THE MEMORY ID** - needed for Workflow 3.

## Workflow 3: Archive to Learnings

**Triggers:**
- After `openspec archive [id]` completes
- "record outcome for [change-id]"
- "convert archived change [id] to learnings"

### Steps

1. **Read the archived change**
   ```bash
   cat openspec/changes/archive/[id]/proposal.md
   cat openspec/changes/archive/[id]/tasks.md
   ls openspec/changes/archive/[id]/specs/
   ```

2. **Find the original decision memory**
   ```
   mcp__daem0nmcp__search_memories(
       query="OpenSpec proposal [id]"
   )
   ```
   Or search by feature name if ID wasn't recorded.

3. **Record the outcome**
   ```
   mcp__daem0nmcp__record_outcome(
       memory_id=[found decision id],
       outcome="Completed and archived. [summary of what was implemented]",
       worked=true  // or false if there were issues
   )
   ```

4. **Create learnings from the completed work**
   ```
   mcp__daem0nmcp__remember_batch(memories=[
       {
           "category": "learning",
           "content": "[change-id]: [key lesson from implementation]",
           "rationale": "Extracted from completed OpenSpec change",
           "tags": ["openspec", "completed", "[feature-name]"],
           "context": {
               "openspec_type": "archived_change",
               "change_id": "[id]",
               "archived_at": "[timestamp]"
           }
       }
       // ... one learning per significant insight
   ])
   ```

5. **Link the memories to create causal chain**
   ```
   mcp__daem0nmcp__link_memories(
       source_id=[proposal decision id],
       target_id=[learning id],
       relationship="led_to",
       description="Proposal implementation led to these learnings"
   )
   ```

6. **If spec deltas were applied, update spec memories**

   For each delta in `openspec/changes/archive/[id]/specs/`:
   - ADDED requirements: Create new pattern memories
   - MODIFIED requirements: Update or supersede existing
   - REMOVED requirements: Create warning memories noting removal

## Tags Convention

| Tag | Meaning | When Used |
|-----|---------|-----------|
| `openspec` | Memory from OpenSpec integration | All OpenSpec memories |
| `spec` | From spec.md source of truth | Workflow 1 |
| `proposal` | From change proposal | Workflow 2 |
| `pending` | Proposal not yet archived | Workflow 2 |
| `completed` | From archived change | Workflow 3 |
| `limitation` | Known constraint | Workflow 1 |
| `rationale` | Design reasoning | Workflow 1 |

## Integration with Sacred Covenant

This skill respects the Daem0n's Sacred Covenant:

1. **COMMUNE** - `get_briefing()` must be called first (auto-detection happens after)
2. **SEEK COUNSEL** - Workflow 2 IS the counsel-seeking step for proposals
3. **INSCRIBE** - `remember()` records proposal decisions
4. **SEAL** - `record_outcome()` closes the loop when changes are archived

**Enforcement:**
- Workflow 1 (Import) requires communion (get_briefing called)
- Workflow 2 (Inform) calls context_check internally
- Workflow 3 (Archive) requires the original decision memory to exist

## Parsing OpenSpec Spec Files

### Spec Format Reference

```markdown
# [Spec Title]

## Purpose
[Description - extract as pattern overview]

## Requirements

### Requirement: [Name]
[Text containing MUST/MUST NOT/SHOULD]

#### Scenario: [Description]
- **GIVEN** [condition]
- **WHEN** [action]
- **THEN** [result]
```

### Extraction Regex Patterns

```
MUST requirements:     /(?:MUST|SHALL|REQUIRED):\s*(.+)/gi
MUST NOT constraints:  /(?:MUST NOT|SHALL NOT|PROHIBITED):\s*(.+)/gi
SHOULD patterns:       /(?:SHOULD|RECOMMENDED):\s*(.+)/gi
SHOULD NOT warnings:   /(?:SHOULD NOT|NOT RECOMMENDED):\s*(.+)/gi
```

### Spec Delta Format

```markdown
## ADDED
### Requirement: [New requirement]

## MODIFIED
### Requirement: [Changed requirement]

## REMOVED
- Requirement: [Removed name]

## RENAMED
FROM: ### Requirement: OldName
TO: ### Requirement: NewName
```

## Example Session

```
[Session starts]
User: Let's work on the authentication feature

Claude: [Calls get_briefing()]
        [Detects openspec/ directory]

        OpenSpec detected. Syncing specs to Daem0n memory...

        Imported 5 specs as patterns:
        - authentication (3 MUST, 2 MUST NOT)
        - api-endpoints (5 MUST, 1 MUST NOT)
        - error-handling (2 MUST)
        - ...

        Created 5 rules for spec enforcement.

User: I want to propose adding OAuth support

Claude: [Workflow 2: Inform]
        Querying memory before proposal...

        # Memory Context for Proposal: OAuth support

        ## Relevant Specs
        - authentication: "All auth must be stateless for scaling"

        ## Warnings
        - Previous session-based auth was rejected (worked=false)

        ## Rules
        MUST: Use JWT tokens, Support token refresh
        MUST NOT: Store sessions server-side

        Shall I proceed with recording this proposal intent?

User: Yes, proceed

Claude: [Records decision with openspec/proposal/pending tags]
        Recorded. Memory ID: 1847

        Now create your proposal at openspec/changes/add-oauth-support/

[Later, after implementation]

User: I've archived the OAuth change, record it

Claude: [Workflow 3: Archive]
        Reading openspec/changes/archive/add-oauth-support/...

        Recording outcome for decision #1847...
        - Outcome: Completed successfully with OAuth2 + PKCE
        - Worked: true

        Created 2 learnings:
        - OAuth2 PKCE flow works well for SPAs
        - Token refresh needs 5-minute buffer

        Linked proposal -> learnings via "led_to"

        The Daem0n will remember this for future auth work.
```

## Troubleshooting

### "No OpenSpec specs found"
Check that `openspec/specs/` directory exists and contains spec directories.

### "Already imported" but specs are stale
Use "refresh openspec" to force re-import. Old memories will be superseded.

### "Can't find proposal decision"
Search with broader terms:
```
mcp__daem0nmcp__search_memories(query="[feature keywords]", tags=["openspec"])
```

### Rules not matching
Check rule triggers match your action descriptions:
```
mcp__daem0nmcp__list_rules()
```