@dragonflymcp/plugin 1.0.0

package/templates/commands/feature.md.template

@@ -0,0 +1,216 @@
+Create a new feature using the Story concept, then automatically evaluate synchronizations.
+
+When the user runs this command, you should:
+
+1. **Recall Relevant Memories** (automatic, fast)
+   - Extract keywords from the feature description
+   - Use `memory_recall` to search for relevant memories:
+     - Architecture patterns that match keywords
+     - Conventions related to the feature area
+     - Past patterns from similar features
+   - Display relevant memories (if any) before proceeding:
+     ```
+     📚 Relevant memories found:
+     - [architecture] "Authentication uses JWT with RS256" (high confidence)
+     - [patterns] "API endpoints follow /api/v1/{resource} convention"
+     ```
+   - If no relevant memories, proceed silently
+
+2. **Invoke Story Concept**
+   - Extract title from user input
+   - Use the Task tool with subagent_type matching the story concept
+   - Explicitly request model="sonnet" for cost efficiency
+   - Include relevant memories as context for the story concept
+   - The concept will prompt for additional details if needed
+
+3. **Read Story Output**
+   - Use `zen_story_get` with the story ID to retrieve the story
+   - Check the status field
+
+4. **Evaluate Synchronizations Automatically**
+   - Read `.claude/synchronizations/feature-development.yaml`
+   - Check `story-to-arch` rule:
+     - when: story.create completed
+     - where: story.status == 'ready' AND criteria.length > 0
+     - then: architecture.design
+
+5. **Continue Workflow**
+   - If rule matches, automatically invoke Architecture concept
+   - Show progress to user
+   - Offer to continue full workflow
+
+## Usage
+
+```
+/feature "Add dark mode support"
+```
+
+## Process Flow
+
+```
+User provides feature description
+  ↓
+Recall relevant memories (fast, ~5ms cached)
+  ↓
+Display relevant context (if any)
+  ↓
+Invoke Story concept (Sonnet) with memory context
+  ↓
+Story saved via zen_story_save
+  ↓
+Read story output and sync rules
+  ↓
+Evaluate story-to-arch rule
+  ↓ (if matched)
+Ask user: Continue with architecture? (y/n)
+  ↓ (if yes)
+Invoke Architecture concept (Sonnet)
+  ↓
+Auto-remember architecture decisions
+  ↓
+Evaluate arch-to-impl rule
+  ↓
+Continue automatically...
+```
+
+## Example: Automatic Workflow
+
+```
+User: /feature "Add user authentication"
+
+You: I'll create a new feature story for user authentication.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Recalling Relevant Memories
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📚 Found 2 relevant memories:
+- [architecture] "API uses JWT tokens with 24h expiry" (high)
+- [conventions] "Auth middleware at src/middleware/auth.ts" (medium)
+
+These will be included as context for story capture.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Phase 1: Story Capture
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+[Invoke Task tool → story concept → model: sonnet]
+
+✓ Story created: story-042
+  Status: ready
+  Acceptance criteria: 5 defined
+  Memory context: 2 items applied
+  Cost: $0.000175
+
+Evaluating synchronizations...
+
+✓ Matched rule: story-to-arch
+  Condition: status=='ready' AND criteria.length>0
+  Next step: architecture.design (Sonnet, ~$0.015)
+
+Continue with architecture design? (y/n)
+
+User: y
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Phase 2: Architecture Design
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+[Invoke Task tool → architecture concept → model: sonnet]
+
+✓ Architecture created: arch-042
+  Approach: OAuth2 with Passport.js
+  Decisions: 4 documented
+  Risks: 2 (both mitigated)
+  Cost: $0.015
+
+💾 Auto-remembered 2 architecture decisions:
+- "OAuth2 with Passport.js for authentication"
+- "Session tokens stored in httpOnly cookies"
+
+Evaluating synchronizations...
+
+✓ Matched rule: arch-to-impl
+  Next step: implementation.generate (Sonnet, ~$0.000175)
+
+Continue with implementation? (y/n)
+
+User: y
+
+[Workflow continues...]
+
+Total workflow cost: $0.0165
+Use /trace story-042 to see complete flow.
+```
+
+## Example: Story Only (No Auto-Continue)
+
+```
+User: /feature "Add dark mode support"
+
+You: I'll create a new feature story.
+
+[Invoke Task tool → story concept → model: sonnet]
+
+✓ Story created: story-001
+  Status: ready
+  Acceptance criteria: 4 defined
+  Cost: $0.000175
+
+Evaluating synchronizations...
+
+✓ Matched rule: story-to-arch
+  Next step: architecture.design (Sonnet, ~$0.015)
+
+Continue with architecture design? (y/n)
+
+User: n
+
+Story created. You can continue later with:
+- /sync --execute (continue workflow)
+- /workflow "story-001" (run full workflow)
+- /trace story-001 (see current state)
+```
+
+## User Control
+
+After story creation, you can:
+- **Continue automatically**: Say "yes" when prompted
+- **Stop and review**: Say "no" to pause workflow
+- **Resume later**: Use `/sync --execute`
+- **Full automation**: Use `/workflow` instead of `/feature`
+
+## Options
+
+The `/feature` command has different modes:
+
+**Interactive (default)**:
+```
+/feature "Add OAuth"
+# Prompts after each step
+```
+
+**Automatic**:
+```
+/feature "Add OAuth" --auto
+# Runs complete workflow without prompts
+```
+
+**Story only**:
+```
+/feature "Add OAuth" --story-only
+# Creates story, stops (no sync evaluation)
+```
+
+## Remember
+
+- The Story concept captures requirements (the "what" and "why")
+- Story does NOT design or implement (that's Architecture and Implementation)
+- Synchronizations orchestrate the workflow automatically
+- User maintains control with prompts
+
+## Related Commands
+
+- `/workflow` - Full automatic workflow (no prompts)
+- `/sync` - Manual sync evaluation
+- `/trace` - See workflow progress

package/templates/commands/forget.md.template

@@ -0,0 +1,104 @@
+---
+name: forget
+description: Remove a memory from semantic storage
+---
+
+# Forget Command
+
+Remove memories from semantic storage.
+
+## Usage
+
+```
+/forget mem-001              # Remove specific memory by ID
+/forget --tag deprecated     # Remove all memories with a tag
+/forget --older-than 90d     # Remove memories older than 90 days
+```
+
+## Arguments
+
+| Argument | Description |
+|----------|-------------|
+| `<memory-id>` | ID of the specific memory to remove |
+| `--tag <tag>` | Remove all memories with this tag |
+| `--older-than <duration>` | Remove memories older than duration (e.g., 30d, 6m, 1y) |
+| `--dry-run` | Show what would be removed without actually removing |
+
+## Implementation
+
+When invoked, I:
+
+1. Parse the arguments to determine what to forget
+2. Find matching memories in `koan/memory/`
+3. If `--dry-run`, show what would be removed
+4. Otherwise, remove the matching memories
+5. Log the removal in provenance
+
+## Examples
+
+### Remove a specific memory
+
+```
+/forget mem-architecture-001
+```
+
+Output:
+```
+Removed memory: mem-architecture-001
+  Content: "Use OAuth2 for authentication"
+  Category: architecture
+  Created: 2026-01-05T10:30:00Z
+```
+
+### Remove by tag
+
+```
+/forget --tag temporary
+```
+
+Output:
+```
+Removed 3 memories with tag 'temporary':
+  - mem-debug-001: "Temporary fix for..."
+  - mem-debug-002: "Debug logging for..."
+  - mem-experiment-001: "Testing approach..."
+```
+
+### Preview removal
+
+```
+/forget --older-than 30d --dry-run
+```
+
+Output:
+```
+Would remove 5 memories older than 30 days:
+  - mem-001: Created 2025-12-01
+  - mem-002: Created 2025-12-05
+  ...
+
+Use without --dry-run to actually remove.
+```
+
+## Memory Locations
+
+Memories are stored in:
+
+| Category | Location |
+|----------|----------|
+| Architecture | `koan/memory/semantic/architecture.yaml` |
+| Patterns | `koan/memory/semantic/patterns.yaml` |
+| Preferences | `koan/memory/semantic/preferences.yaml` |
+| Conventions | `koan/memory/semantic/conventions.yaml` |
+
+## Safety
+
+- **No cascade deletion**: Forgetting a memory doesn't affect related provenance
+- **Provenance preserved**: The forget action is logged in provenance
+- **Recovery possible**: Memories can be restored from git history if needed
+
+## Related Commands
+
+- `/remember` - Store new memories
+- `/recall` - Retrieve stored memories
+- `/checkpoint` - Save session state

package/templates/commands/global-recall.md.template

@@ -0,0 +1,250 @@
+# Global Recall Command
+
+Retrieve knowledge from global memory across all categories.
+
+## Usage
+
+```
+/global-recall "<query>" [options]
+```
+
+## Options
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `--category` | Filter by category | `preferences`, `patterns`, `technologies`, `learnings`, `workflows` |
+| `--tech` | Filter by technology | `postgresql`, `typescript`, `react` |
+| `--tag` | Filter by tag | `error-handling`, `performance` |
+| `--all` | Show all matches | Default shows top 5 |
+
+## Process
+
+When you run this command:
+
+1. **Search Global Memory**
+   - Search all categories (or filtered)
+   - Match query against content and metadata
+   - Rank by relevance
+
+2. **Display Results**
+   - Show matching memories with context
+   - Include source and date added
+   - Highlight relevant portions
+
+3. **Apply to Context**
+   - Relevant memories are available for current session
+   - Can be referenced in subsequent prompts
+
+## Examples
+
+### Search by Query
+
+```
+/global-recall "error handling"
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Global Memory: "error handling"
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Found 3 matches:
+
+1. [Pattern] Result Type Pattern
+   Category: patterns/error-handling
+   Added: 2025-01-15
+
+   Use Result type for error handling in TypeScript:
+   ```typescript
+   type Result<T, E = Error> =
+     | { success: true; value: T }
+     | { success: false; error: E };
+   ```
+
+2. [Learning] GL001 - Error Types in Stories
+   Category: learnings/requirements
+   Added: 2025-01-10
+   Source: project-a
+
+   Always specify error types explicitly in acceptance criteria
+
+3. [Pattern] AppError Class
+   Category: patterns/error-handling
+   Added: 2025-01-05
+
+   Consistent error class with code and statusCode properties
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Filter by Category
+
+```
+/global-recall --category=technologies --tech=postgresql
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Global Memory: PostgreSQL Knowledge
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Technology: PostgreSQL
+Version: 14+
+
+Gotchas:
+• Connection pooling: Default 100 connections
+  → Use PgBouncer for high-traffic
+
+• JSON vs JSONB: JSON is text, JSONB is binary
+  → Always use JSONB unless preserving whitespace
+
+• Foreign key indexes: Not auto-created
+  → Always create indexes for FK columns
+
+Best Practices:
+• Always use parameterized queries
+• Use EXPLAIN ANALYZE for optimization
+• Prefer BIGINT for IDs
+
+Common Queries:
+• Upsert pattern available
+• Cursor pagination pattern available
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Get Preferences
+
+```
+/global-recall --category=preferences
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Global Preferences
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Coding Style:
+• Indentation: 2 spaces
+• Quotes: single
+• Semicolons: false
+• Trailing commas: ES5
+
+Documentation:
+• Style: JSDoc
+• Detail level: moderate
+• Include examples: yes
+
+Testing:
+• Framework: Vitest
+• Coverage target: 80%
+• Style: Arrange-Act-Assert
+
+Git:
+• Commit style: Conventional
+• Branch naming: feature/issue-description
+• Squash preference: yes
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+These preferences will be applied to code generation.
+Override in project with koan/memory/preferences.yaml
+```
+
+### Search Learnings
+
+```
+/global-recall "API" --category=learnings
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Global Learnings: API
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+GL001: Always version APIs from the start
+       Source: project-a (2024-06)
+       → Use /v1/ prefix even for initial release
+
+GL002: Rate limiting should be per-user AND per-endpoint
+       Source: project-b (2024-09)
+       → One user was able to DOS specific endpoints
+
+GL003: Use cursor-based pagination, not offset
+       Source: project-b (2024-09)
+       → Offset caused performance issues at scale
+
+GL004: Validate webhook signatures before processing
+       Source: project-c (2025-01)
+       → Security best practice
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Browse Workflows
+
+```
+/global-recall --category=workflows
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Global Workflow Optimizations
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Debugging Workflow:
+1. Capture exact input that caused error
+2. Check error logs for stack trace
+3. Write failing test FIRST
+4. Fix and verify test passes
+
+Performance Investigation:
+1. Profile in production-like environment
+2. Identify top 3 bottlenecks
+3. Address largest first
+4. Re-profile after each change
+
+Code Review Workflow:
+1. Run automated checks first
+2. Review architecture/design choices
+3. Check for security issues
+4. Verify test coverage
+5. Style/formatting last
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Automatic Context Loading
+
+When starting a new task, relevant global memories may be automatically suggested:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Relevant Global Memories
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Based on your task "Add API authentication", these memories may help:
+
+• GL001: Always version APIs from the start
+• Pattern: JWT Authentication Pattern
+• Tech: Rate limiting best practices
+
+Apply to current context? [Y/n]
+```
+
+## Storage Location
+
+Global memory is read from:
+```
+~/.zen/global-memory/
+├── preferences.yaml
+├── patterns/
+├── technologies/
+├── learnings/
+└── workflows/
+```