claude-flow-novice 2.18.5 → 2.18.6

package/.claude/cfn-extras/commands/deprecated/context-curate.md

@@ -0,0 +1,200 @@
+---
+description: Run ACE curator to merge reflection deltas into adaptive context with deduplication
+tags: [context, ace, curation, merge, deduplication]
+---
+
+# Context Curation Command
+
+Spawn a `context-curator` agent to merge reflection deltas into the `adaptive_context` table using deterministic rules, semantic deduplication, and version control.
+
+**Usage:**
+```bash
+/context-curate [--reflection-id=<id>] [--auto-merge] [--similarity-threshold=0.85]
+```
+
+**What This Does:**
+1. Spawns `context-curator` agent (specialized for ACE curation)
+2. Fetches pending reflections from `context_reflections` table
+3. For each extracted lesson:
+   - **Check for duplicates** using semantic similarity (embeddings)
+   - **Merge similar bullets** if similarity > threshold
+   - **Add new bullets** if novel insight
+   - **Increment counters** for reinforced lessons
+   - **Version bullets** for significant edits
+4. Updates `adaptive_context` table with deterministic merge logic
+5. Records curation decisions in `context_merge_log` (audit trail)
+6. Updates bullet confidence scores based on reinforcement
+
+**Arguments:**
+- `--reflection-id=<id>`: Curate specific reflection (default: all pending)
+- `--auto-merge`: Skip human review, auto-merge with high confidence (≥0.8)
+- `--similarity-threshold=<0.0-1.0>`: Semantic similarity for merging (default: 0.85)
+- `--require-validation`: Flag merged bullets for human/PO validation
+- `--dry-run`: Preview merge actions without applying
+- `--category=<type>`: Filter by bullet category
+- `--min-confidence=<0.0-1.0>`: Only merge bullets above confidence threshold (default: 0.5)
+- `--output=<path>`: Save curation report to file
+
+**Merge Logic (Deterministic):**
+
+1. **New Bullet (No Similar Match):**
+   ```sql
+   INSERT INTO adaptive_context (bullet_id, category, content, confidence_score, ...)
+   VALUES ('STRAT-042', 'strategy', 'Use Redis pub/sub...', 0.85, ...);
+
+   INSERT INTO context_merge_log (merge_type, bullet_id, new_content, curator_reasoning)
+   VALUES ('new_bullet', 'STRAT-042', 'Use Redis pub/sub...', 'Novel strategy, no similar bullets found');
+   ```
+
+2. **Similar Bullet Found (Similarity > Threshold):**
+   ```sql
+   -- Increment helpful counter
+   UPDATE adaptive_context
+   SET helpful_count = helpful_count + 1,
+       confidence_score = MIN(1.0, confidence_score + 0.05),
+       usage_count = usage_count + 1,
+       last_used_at = CURRENT_TIMESTAMP
+   WHERE bullet_id = 'STRAT-001';
+
+   INSERT INTO context_merge_log (merge_type, bullet_id, similarity_score, curator_reasoning)
+   VALUES ('increment_helpful', 'STRAT-001', 0.92, 'Reinforced by new reflection');
+   ```
+
+3. **Merge Semantically Overlapping Bullets:**
+   ```sql
+   -- Create new version merging STRAT-001 + STRAT-042
+   INSERT INTO adaptive_context (bullet_id, category, content, version, parent_bullet_id, helpful_count, ...)
+   VALUES ('STRAT-001-v2', 'strategy', 'Merged content...', 2, 'STRAT-001', 15, ...);
+
+   -- Archive old bullets
+   UPDATE adaptive_context SET is_active = 0, archived_at = CURRENT_TIMESTAMP
+   WHERE bullet_id IN ('STRAT-001', 'STRAT-042');
+
+   INSERT INTO context_merge_log (merge_type, merged_from_bullet_ids, new_content)
+   VALUES ('merge_similar', '["STRAT-001", "STRAT-042"]', 'Merged content...');
+   ```
+
+4. **Archive Harmful Bullets:**
+   ```sql
+   -- Auto-archived by trigger when harmful_count >= 5 AND helpful_count < 2
+   UPDATE adaptive_context
+   SET is_active = 0, archived_at = CURRENT_TIMESTAMP
+   WHERE bullet_id = 'ANTI-013';
+
+   INSERT INTO context_merge_log (merge_type, bullet_id, curator_reasoning)
+   VALUES ('archive', 'ANTI-013', 'Harmful pattern confirmed by multiple tasks');
+   ```
+
+**Semantic Similarity (Optional):**
+If embeddings available in `embedding_vector` column:
+```javascript
+// Cosine similarity between bullet embeddings
+const similarity = cosineSimilarity(embedding1, embedding2);
+
+if (similarity > threshold) {
+  // Merge or increment counter
+} else {
+  // Add as new bullet
+}
+```
+
+**Curation Prompt Template:**
+```
+You are a Context Curator for the ACE (Adaptive Context Extension) system.
+
+**Pending Reflection:**
+{reflection_data}
+
+**Existing Bullets (Semantic Neighbors):**
+{similar_bullets}
+
+**Your Mission:**
+For each extracted lesson in the reflection:
+
+1. **Check for semantic similarity**:
+   - Compare with existing bullets
+   - Use similarity threshold: {threshold}
+
+2. **Apply merge logic**:
+   - **Similarity > {threshold}**: Increment helpful_count, boost confidence
+   - **Similarity 0.6-{threshold}**: Consider merging bullets (create new version)
+   - **Similarity < 0.6**: Add as new bullet
+
+3. **Validate quality**:
+   - Is the bullet actionable?
+   - Is it specific enough?
+   - Does it have clear conditions/context?
+   - Would it help future agents?
+
+4. **Assign priority** (1-10):
+   - High (8-10): Critical strategies, common patterns, safety rules
+   - Medium (5-7): Optimization tips, domain insights
+   - Low (1-4): Edge cases, situational patterns
+
+5. **Update counters**:
+   - Identify helpful_existing_bullets → increment their helpful_count
+   - Identify harmful_existing_bullets → increment their harmful_count
+
+**Output Format (JSON):**
+{
+  "curation_actions": [
+    {
+      "action": "new_bullet|increment_helpful|increment_harmful|merge_similar|archive",
+      "bullet_id": "STRAT-042",
+      "target_bullet_id": "STRAT-001",  // For increment/merge actions
+      "similarity_score": 0.92,
+      "reasoning": "Why this action is appropriate",
+      "merged_content": "New merged content (if merge action)"
+    }
+  ],
+  "validation_required": ["STRAT-042"],  // Bullets needing human review
+  "summary": "Curated 5 lessons: 2 new, 3 reinforced existing"
+}
+```
+
+**Post-Curation:**
+1. Update `context_reflections.curator_status = 'merged'`
+2. Record all actions in `context_merge_log`
+3. Emit metrics to `metrics` table
+4. Print summary:
+   ```
+   ✅ Curation Complete: reflection-abc123
+
+   📊 Merge Actions:
+      - STRAT-042: New bullet added (confidence: 0.85)
+      - STRAT-001: Helpful count +1 (now 16 helpful, 0 harmful)
+      - PATTERN-017: Helpful count +1 (now 10 helpful, 0 harmful)
+
+   📈 Context Stats:
+      - Total active bullets: 127
+      - Avg confidence: 0.78
+      - Bullets needing validation: 3
+
+   💡 Next: Run /context-inject --category=strategy to add top bullets to CLAUDE.md
+   ```
+
+**Periodic Maintenance:**
+Run curation with `--maintenance` flag to:
+- Deduplicate similar bullets (similarity > 0.90)
+- Archive bullets with harmful_count ≥ 5
+- Prune bullets unused for >90 days (if helpful_count < 3)
+- Merge semantically overlapping bullets
+- Rebalance priority scores
+
+**Integration with CFN Loop:**
+- **Loop 3 completion**: Auto-curate agent reflections
+- **Loop 4 approval**: PO reviews high-priority bullets
+- **Phase completion**: Periodic maintenance curation
+- **Epic completion**: Comprehensive deduplication pass
+
+**ACL & Security:**
+- Curation actions require ACL Level 4 (Project)
+- Merge log audit trail at ACL Level 5 (System)
+- Sensitive bullets flagged for validation
+- Human review required for confidence < 0.6
+
+**See Also:**
+- `/context-reflect` - Extract lessons from execution
+- `/context-query` - Search bullets by category/tags
+- `/context-inject` - Add bullets to CLAUDE.md
+- `/context-stats` - View bullet statistics and health

package/.claude/cfn-extras/commands/deprecated/context-inject.md

@@ -0,0 +1,251 @@
+---
+description: Inject adaptive context bullets into CLAUDE.md dynamically based on task/phase/tags
+tags: [context, ace, injection, claude-md, dynamic]
+---
+
+# Context Injection Command
+
+Dynamically inject relevant adaptive context bullets into CLAUDE.md (or agent-specific instructions) based on task context, phase, or tags.
+
+**Usage:**
+```bash
+/context-inject [--target=<path>] [--category=<type>] [--tags=<tag1,tag2>] [--mode=<mode>]
+```
+
+**What This Does:**
+1. Queries `adaptive_context` table with relevance filters
+2. Formats bullets for CLAUDE.md injection
+3. Inserts into CLAUDE.md under `## 📘 Adaptive Context` section
+4. Optionally injects into agent-specific instruction files
+5. Records injection in usage log for tracking
+
+**Arguments:**
+- `--target=<path>`: Target file (default: ./CLAUDE.md)
+- `--category=<type>`: Filter by category (strategy/pattern/edge_case/...)
+- `--tags=<tag1,tag2>`: Filter by tags (comma-separated)
+- `--phase=<name>`: Auto-select bullets relevant to CFN Loop phase
+- `--min-confidence=<0.0-1.0>`: Minimum confidence (default: 0.7)
+- `--min-helpful=<count>`: Minimum helpful count (default: 3)
+- `--priority-min=<1-10>`: Minimum priority (default: 6)
+- `--limit=<N>`: Max bullets to inject (default: 15)
+- `--mode=<mode>`: Injection mode (append|replace|merge) (default: merge)
+- `--section=<name>`: Section name in CLAUDE.md (default: "Adaptive Context")
+- `--agent-type=<type>`: Inject bullets for specific agent type
+- `--swarm-id=<id>`: Use swarm-specific context
+- `--dry-run`: Preview injection without writing
+
+**Injection Modes:**
+
+**1. Merge (Default):**
+- Preserves existing CLAUDE.md content
+- Adds/updates `## 📘 Adaptive Context` section
+- Updates bullets if already present (based on bullet_id)
+- Preserves custom user edits in other sections
+
+**2. Append:**
+- Adds bullets to end of CLAUDE.md
+- Never modifies existing content
+- Useful for temporary context injection
+
+**3. Replace:**
+- Replaces entire `## 📘 Adaptive Context` section
+- WARNING: Removes user edits in that section
+- Use with caution
+
+**CLAUDE.md Section Format:**
+```markdown
+## 📘 Adaptive Context (Auto-Managed by /context-inject)
+
+**Last Updated:** 2025-10-13 12:30:00 UTC
+**Bullets Injected:** 12
+**Avg Confidence:** 0.84
+**Context:** phase=phase-0-foundation, tags=cfn-loop,coordination,sqlite
+
+---
+
+### Strategies (High Priority)
+
+**[STRAT-001]** Use phone contacts as identity key when identifying relationships
+*Confidence: 0.92 | Helpful: 12 | Priority: 9*
+When implementing user identity matching, prefer phone contact data over description parsing for higher accuracy.
+**Tags:** identity, matching, contacts
+
+**[STRAT-042]** CFN Loop coordination: Redis pub/sub + SQLite persistence
+*Confidence: 0.85 | Helpful: 8 | Priority: 8*
+Use Redis pub/sub for ephemeral coordination state (heartbeats, agent signals) and SQLite for persistent audit trails and cross-loop data storage.
+**Tags:** cfn-loop, coordination, redis, sqlite, persistence
+
+---
+
+### Patterns (Proven)
+
+**[PATTERN-017]** API pagination with `while true` until empty page
+*Confidence: 0.88 | Helpful: 9 | Priority: 7*
+Implement paginated API fetching using infinite loop with break condition on empty response.
+**Tags:** api, pagination, rest
+
+---
+
+### Edge Cases (Caution)
+
+**[EDGE-044]** SQLite ACL permission boundary with nested swarms
+*Confidence: 0.75 | Helpful: 5 | Priority: 6*
+When nesting swarms, ensure ACL inheritance is explicitly set to avoid permission leakage across swarm boundaries.
+**Tags:** sqlite, acl, security, swarms
+
+---
+
+### Anti-Patterns (Avoid)
+
+**[ANTI-013]** Using file-based coordination without locks
+*Confidence: 0.70 | Helpful: 2 | Harmful: 4 | Priority: 8*
+Avoid coordinating agents via direct file writes without proper locking mechanisms. Use Redis pub/sub or SQLite transactions instead.
+**Tags:** coordination, anti-pattern, race-condition
+
+---
+
+*📊 Context Health:*
+- Total active bullets: 127
+- Avg confidence: 0.78
+- Bullets updated this session: 5
+- Next curation: 2025-10-14 00:00 UTC
+
+*💡 Tip:* Run `/context-query --tags=<your-task-tags>` to explore more relevant bullets.
+```
+
+**Phase-Aware Injection:**
+Auto-select bullets based on CFN Loop phase:
+
+```bash
+# Phase 0: Foundation
+/context-inject --phase=phase-0-foundation
+# Tags: architecture, foundation, setup, infrastructure
+
+# Phase 1: Core Implementation
+/context-inject --phase=phase-1-implementation
+# Tags: coding, patterns, testing, best-practices
+
+# Phase 2: Security & Optimization
+/context-inject --phase=phase-2-security
+# Tags: security, acl, validation, performance
+
+# Phase 3: Integration & Deployment
+/context-inject --phase=phase-3-deployment
+# Tags: deployment, integration, monitoring, ci-cd
+```
+
+**Agent-Specific Injection:**
+Inject bullets relevant to specific agent types:
+
+```bash
+# For security specialist agents
+/context-inject --agent-type=security-specialist --target=./.claude/agents/security-specialist.md
+
+# For coder agents
+/context-inject --agent-type=coder --category=pattern --min-helpful=5
+
+# For architect agents
+/context-inject --agent-type=architect --category=strategy --priority-min=8
+```
+
+**Pre-Spawn Context Injection:**
+Use with pre-agent-spawn hook:
+
+```bash
+# config/hooks/pre-agent-spawn-context.js
+async function preAgentSpawnContext(agentType, taskContext) {
+  // Query relevant bullets
+  const bullets = await queryContext({
+    agentType,
+    tags: taskContext.tags,
+    minConfidence: 0.7
+  });
+
+  // Inject into agent's instruction file
+  const agentFile = `./.claude/agents/${agentType}.md`;
+  await injectBullets(agentFile, bullets, { mode: 'merge' });
+
+  // Log usage
+  bullets.forEach(bullet => {
+    logContextUsage(bullet.bullet_id, taskContext.task_id, agentType);
+  });
+}
+```
+
+**Dynamic Injection During Execution:**
+
+```javascript
+// During CFN Loop 3, inject relevant optimization bullets
+Task("coder-1", `
+  Implement authentication system.
+
+  Before you start, check these adaptive context bullets:
+  ${await contextInject({ tags: 'auth,security', limit: 5, format: 'inline' })}
+
+  Follow these proven patterns to avoid common pitfalls.
+`, "coder");
+```
+
+**Validation & Safety:**
+- Validates bullet confidence before injection (default min: 0.7)
+- Checks helpful/harmful ratio (default: harmful_count < 3)
+- Respects ACL permissions (only injects bullets agent can access)
+- Sanitizes content (removes sensitive data)
+- Preserves user edits outside managed section
+
+**Automatic Injection Triggers:**
+Configure automatic injection via hooks:
+
+```yaml
+# config/hooks/auto-inject-rules.yaml
+rules:
+  - trigger: cfn-loop-phase-start
+    action: context-inject
+    params:
+      phase: ${phase_name}
+      target: ./CLAUDE.md
+      min-confidence: 0.75
+
+  - trigger: agent-spawn
+    action: context-inject
+    params:
+      agent-type: ${agent_type}
+      target: ./.claude/agents/${agent_type}.md
+      limit: 10
+
+  - trigger: task-start
+    action: context-inject
+    params:
+      tags: ${task_tags}
+      mode: append
+      limit: 5
+```
+
+**Rollback & Cleanup:**
+```bash
+# Remove injected section
+/context-inject --mode=remove --section="Adaptive Context"
+
+# Restore from backup
+/context-inject --restore-backup=./CLAUDE.md.backup-20251013
+```
+
+**Metrics & Monitoring:**
+Track injection effectiveness:
+```sql
+SELECT
+    bullet_id,
+    content,
+    COUNT(*) as injection_count,
+    AVG(CASE WHEN usage_outcome = 'helpful' THEN 1.0 ELSE 0.0 END) as helpfulness_rate
+FROM context_usage_log
+WHERE created_at > datetime('now', '-7 days')
+GROUP BY bullet_id
+ORDER BY helpfulness_rate DESC;
+```
+
+**See Also:**
+- `/context-query` - Search bullets before injection
+- `/context-reflect` - Extract lessons from execution
+- `/context-curate` - Merge reflections into context
+- `/context-stats` - View bullet statistics and health

package/.claude/cfn-extras/commands/deprecated/context-query.md

@@ -0,0 +1,210 @@
+---
+description: Query adaptive context bullets by category, tags, confidence, or semantic similarity
+tags: [context, ace, query, search, retrieval]
+---
+
+# Context Query Command
+
+Search the `adaptive_context` table to retrieve relevant bullets for task execution, agent spawning, or CLAUDE.md injection.
+
+**Usage:**
+```bash
+/context-query [--category=<type>] [--tags=<tag1,tag2>] [--min-confidence=<0.0-1.0>]
+```
+
+**What This Does:**
+1. Queries `adaptive_context` table with filters
+2. Ranks bullets by relevance (priority, confidence, usage_count)
+3. Optionally uses semantic similarity if embeddings available
+4. Returns formatted bullets ready for injection
+
+**Arguments:**
+- `--category=<type>`: Filter by category (strategy/pattern/edge_case/domain_insight/anti_pattern/optimization)
+- `--tags=<tag1,tag2>`: Filter by tags (comma-separated)
+- `--min-confidence=<0.0-1.0>`: Minimum confidence score (default: 0.6)
+- `--min-helpful=<count>`: Minimum helpful_count (default: 0)
+- `--max-harmful=<count>`: Maximum harmful_count (default: 2)
+- `--priority-min=<1-10>`: Minimum priority (default: 5)
+- `--limit=<N>`: Max results to return (default: 20)
+- `--sort-by=<field>`: Sort by confidence|helpful_count|priority|last_used_at (default: priority)
+- `--semantic-query=<text>`: Find bullets semantically similar to query text (requires embeddings)
+- `--related-to=<bullet-id>`: Find bullets related to specific bullet
+- `--swarm-id=<id>`: Filter by swarm context
+- `--project-id=<id>`: Filter by project context
+- `--output=<format>`: Output format (json|markdown|claude-md) (default: markdown)
+- `--inject`: Automatically inject results into CLAUDE.md
+
+**Query Examples:**
+
+```bash
+# Get top strategy bullets
+/context-query --category=strategy --min-confidence=0.8 --limit=10
+
+# Find CFN Loop coordination patterns
+/context-query --tags=cfn-loop,coordination --min-helpful=3
+
+# Get all high-priority optimization tips
+/context-query --category=optimization --priority-min=7 --sort-by=confidence
+
+# Semantic search for Redis patterns
+/context-query --semantic-query="Redis pub/sub coordination patterns"
+
+# Get bullets related to specific bullet
+/context-query --related-to=STRAT-001 --limit=5
+
+# Get project-specific domain insights
+/context-query --category=domain_insight --project-id=proj-auth --min-helpful=5
+```
+
+**Output Formats:**
+
+**1. Markdown (Default):**
+```markdown
+## Query Results: 10 bullets (category=strategy, min-confidence=0.8)
+
+### [STRAT-001] Use Phone Contacts as Identity Key ⭐
+When identifying relationships (roommates, contacts), prefer phone contact matching instead of description parsing.
+
+**Metadata:**
+- Confidence: 0.92 | Helpful: 12 | Harmful: 0 | Priority: 9
+- Tags: identity, matching, contacts
+- Last used: 2025-10-12 | Source: task-roomsync-v2
+- Category: strategy
+
+---
+
+### [STRAT-042] CFN Loop Coordination Strategy ⭐
+Use Redis pub/sub for ephemeral coordination state (heartbeats, signals) and SQLite for persistent audit trails and cross-loop data.
+
+**Metadata:**
+- Confidence: 0.85 | Helpful: 8 | Harmful: 0 | Priority: 8
+- Tags: cfn-loop, coordination, redis, sqlite, persistence
+- Last used: 2025-10-13 | Source: phase-0-foundation
+- Category: strategy
+
+...
+```
+
+**2. CLAUDE.md Format:**
+```markdown
+## 📘 Adaptive Context Bullets (Auto-Injected)
+
+### Strategies
+
+**[STRAT-001]** Use phone contacts as identity key when identifying relationships
+(Confidence: 0.92 | Helpful: 12 | Source: task-roomsync-v2)
+
+**[STRAT-042]** Use Redis pub/sub for ephemeral state + SQLite for persistent audit trails in CFN Loop
+(Confidence: 0.85 | Helpful: 8 | Source: phase-0-foundation)
+
+### Patterns
+
+**[PATTERN-017]** API pagination via `while true` until empty page
+(Confidence: 0.88 | Helpful: 9 | Source: task-api-pagination)
+
+...
+```
+
+**3. JSON:**
+```json
+{
+  "query": {
+    "category": "strategy",
+    "min_confidence": 0.8,
+    "limit": 10
+  },
+  "results": [
+    {
+      "bullet_id": "STRAT-001",
+      "category": "strategy",
+      "content": "Use phone contacts as identity key when identifying relationships",
+      "confidence_score": 0.92,
+      "helpful_count": 12,
+      "harmful_count": 0,
+      "priority": 9,
+      "tags": ["identity", "matching", "contacts"],
+      "source_context": "task-roomsync-v2",
+      "last_used_at": "2025-10-12T10:30:00Z",
+      "usage_count": 15
+    }
+  ],
+  "total_results": 10,
+  "avg_confidence": 0.86
+}
+```
+
+**Semantic Search (Optional):**
+If embeddings available:
+```sql
+SELECT
+    bullet_id,
+    content,
+    confidence_score,
+    helpful_count,
+    COSINE_SIMILARITY(embedding_vector, query_embedding) AS similarity
+FROM adaptive_context
+WHERE is_active = 1
+    AND similarity > 0.75
+ORDER BY similarity DESC, confidence_score DESC
+LIMIT 10;
+```
+
+**Usage Patterns:**
+
+**1. Pre-Agent Spawn Context Injection:**
+```bash
+# Get relevant bullets for agent spawn
+/context-query --tags=cfn-loop,coordination --min-confidence=0.7 --output=claude-md --inject
+
+# This injects bullets into agent's CLAUDE.md context:
+Task("coder", "Implement CFN Loop coordinator with context: [STRAT-042, PATTERN-017, ...]")
+```
+
+**2. Task-Specific Context:**
+```bash
+# Get security patterns before security audit
+/context-query --category=pattern --tags=security,acl --min-helpful=5
+
+# Get optimization tips before performance work
+/context-query --category=optimization --priority-min=7 --sort-by=helpful_count
+```
+
+**3. Debugging & Investigation:**
+```bash
+# Find related edge cases
+/context-query --category=edge_case --tags=sqlite,acl
+
+# Check anti-patterns to avoid
+/context-query --category=anti_pattern --min-harmful=3
+```
+
+**4. Learning & Documentation:**
+```bash
+# Get domain insights for documentation
+/context-query --category=domain_insight --project-id=proj-auth --output=markdown
+```
+
+**Usage Tracking:**
+When bullets are retrieved and used in task execution:
+```sql
+INSERT INTO context_usage_log (bullet_id, task_id, agent_id, usage_outcome, outcome_reason)
+VALUES ('STRAT-001', 'task-xyz', 'agent-abc', 'helpful', 'Identity matching strategy worked perfectly');
+```
+This automatically increments `helpful_count` via trigger.
+
+**Performance:**
+- Indexed queries: <5ms for tag/category filters
+- Semantic search: <50ms with embeddings (SQLite-vec extension)
+- Results cached in Redis for 5 minutes
+
+**ACL Enforcement:**
+- Respects bullet ACL levels
+- Filters results based on agent/swarm/project permissions
+- Private bullets (ACL 1) only visible to owning agent
+- Project bullets (ACL 4) visible to all project agents
+
+**See Also:**
+- `/context-reflect` - Extract lessons from execution
+- `/context-curate` - Merge reflections into context
+- `/context-inject` - Add bullets to CLAUDE.md
+- `/context-stats` - View bullet statistics