name: audit description: Review and maintain EC memories. List all memories, find duplicates, prune stale entries, and organize by type. Use when memories need cleanup, when user says "audit memories", "clean up EC", "review what's stored", or periodically for hygiene.

Audit EC Memories

Review, clean, and organize stored memories.

Announce: "I'm using the audit skill to review EC memories."

The Flow

List All → Analyze → Present → Clean → Verify

Step 1: List All Memories

Pull everything by type:

ec_list:
  limit: 100
  type: decision

ec_list:
  limit: 100
  type: learning

ec_list:
  limit: 100
  type: pattern

ec_list:
  limit: 100
  type: config

Also check for invalidated entries:

ec_list:
  limit: 50
  include_invalid: true

Step 2: Analyze

Check for Issues

1. Duplicates - Same or very similar content
2. Stale - References outdated code/patterns
3. Vague - Content too generic to be useful
4. Miscategorized - Wrong type for the content

Group by Area

Organize memories by their area tag to see coverage:

• Which areas have many memories?
• Which areas are sparse?
• Any orphaned areas (code deleted)?

Step 3: Present Summary

## EC Memory Audit

**Total Memories:** N (D decisions, L learnings, P patterns, C config)
**Invalidated:** N

### By Area
| Area | Decisions | Learnings | Patterns |
|------|-----------|-----------|----------|
| auth | 3 | 2 | 1 |
| api  | 1 | 4 | 2 |
| ...  | ... | ... | ... |

### Issues Found
- **Duplicates (N):** [list IDs]
- **Potentially stale (N):** [list with reason]
- **Vague entries (N):** [list IDs]

Step 4: Clean Up

Use AskUserQuestion for each category:

{
  "questions": [{
    "question": "How should I handle the N duplicate memories?",
    "header": "Duplicates",
    "options": [
      { "label": "Merge", "description": "Keep best version, invalidate others" },
      { "label": "Keep all", "description": "They might have nuance" },
      { "label": "Review each", "description": "Show me one by one" }
    ],
    "multiSelect": false
  }]
}

Invalidating Memories

When removing a memory, use ec_invalidate with optional superseding:

ec_invalidate:
  id: <old_memory_id>
  superseded_by: <new_memory_id>  # Optional: link to replacement

Merging Duplicates

1. Create new consolidated memory with ec_add
2. Invalidate old entries with ec_invalidate, pointing to new ID

Step 5: Verify

After cleanup, show the delta:

## Cleanup Complete

**Before:** N memories
**After:** M memories
**Invalidated:** X entries

### Changes
- Merged N duplicates
- Invalidated M stale entries
- Recategorized P entries

Audit Checklist

When to Audit

• Periodically - Every few weeks on active projects
• After major refactors - Code changed, memories may be stale
• Before onboarding - Clean slate for new team members
• When searches return noise - Too many irrelevant results

Red Flags

Stop and ask if:

• About to invalidate >10 memories
• Unsure if memory is still valid
• Memory references code you can't find