compound-engineering-pi 0.2.3

package/plugins/compound-engineering/commands/triage.md

@@ -0,0 +1,311 @@
+---
+name: triage
+description: Triage and categorize findings for the CLI todo system
+argument-hint: "[findings list or source type]"
+disable-model-invocation: true
+---
+
+- First set the /model to Haiku
+- Then read all pending todos in the todos/ directory
+
+Present all findings, decisions, or issues here one by one for triage. The goal is to go through each item and decide whether to add it to the CLI todo system.
+
+**IMPORTANT: DO NOT CODE ANYTHING DURING TRIAGE!**
+
+This command is for:
+
+- Triaging code review findings
+- Processing security audit results
+- Reviewing performance analysis
+- Handling any other categorized findings that need tracking
+
+## Workflow
+
+### Step 1: Present Each Finding
+
+For each finding, present in this format:
+
+```
+---
+Issue #X: [Brief Title]
+
+Severity: 🔴 P1 (CRITICAL) / 🟡 P2 (IMPORTANT) / 🔵 P3 (NICE-TO-HAVE)
+
+Category: [Security/Performance/Architecture/Bug/Feature/etc.]
+
+Description:
+[Detailed explanation of the issue or improvement]
+
+Location: [file_path:line_number]
+
+Problem Scenario:
+[Step by step what's wrong or could happen]
+
+Proposed Solution:
+[How to fix it]
+
+Estimated Effort: [Small (< 2 hours) / Medium (2-8 hours) / Large (> 8 hours)]
+
+---
+Do you want to add this to the todo list?
+1. yes - create todo file
+2. next - skip this item
+3. custom - modify before creating
+```
+
+### Step 2: Handle User Decision
+
+**When user says "yes":**
+
+1. **Update existing todo file** (if it exists) or **Create new filename:**
+
+   If todo already exists (from code review):
+
+   - Rename file from `{id}-pending-{priority}-{desc}.md` → `{id}-ready-{priority}-{desc}.md`
+   - Update YAML frontmatter: `status: pending` → `status: ready`
+   - Keep issue_id, priority, and description unchanged
+
+   If creating new todo:
+
+   ```
+   {next_id}-ready-{priority}-{brief-description}.md
+   ```
+
+   Priority mapping:
+
+   - 🔴 P1 (CRITICAL) → `p1`
+   - 🟡 P2 (IMPORTANT) → `p2`
+   - 🔵 P3 (NICE-TO-HAVE) → `p3`
+
+   Example: `042-ready-p1-transaction-boundaries.md`
+
+2. **Update YAML frontmatter:**
+
+   ```yaml
+   ---
+   status: ready # IMPORTANT: Change from "pending" to "ready"
+   priority: p1 # or p2, p3 based on severity
+   issue_id: "042"
+   tags: [category, relevant-tags]
+   dependencies: []
+   ---
+   ```
+
+3. **Populate or update the file:**
+
+   ```yaml
+   # [Issue Title]
+
+   ## Problem Statement
+   [Description from finding]
+
+   ## Findings
+   - [Key discoveries]
+   - Location: [file_path:line_number]
+   - [Scenario details]
+
+   ## Proposed Solutions
+
+   ### Option 1: [Primary solution]
+   - **Pros**: [Benefits]
+   - **Cons**: [Drawbacks if any]
+   - **Effort**: [Small/Medium/Large]
+   - **Risk**: [Low/Medium/High]
+
+   ## Recommended Action
+   [Filled during triage - specific action plan]
+
+   ## Technical Details
+   - **Affected Files**: [List files]
+   - **Related Components**: [Components affected]
+   - **Database Changes**: [Yes/No - describe if yes]
+
+   ## Resources
+   - Original finding: [Source of this issue]
+   - Related issues: [If any]
+
+   ## Acceptance Criteria
+   - [ ] [Specific success criteria]
+   - [ ] Tests pass
+   - [ ] Code reviewed
+
+   ## Work Log
+
+   ### {date} - Approved for Work
+   **By:** Claude Triage System
+   **Actions:**
+   - Issue approved during triage session
+   - Status changed from pending → ready
+   - Ready to be picked up and worked on
+
+   **Learnings:**
+   - [Context and insights]
+
+   ## Notes
+   Source: Triage session on {date}
+   ```
+
+4. **Confirm approval:** "✅ Approved: `{new_filename}` (Issue #{issue_id}) - Status: **ready** → Ready to work on"
+
+**When user says "next":**
+
+- **Delete the todo file** - Remove it from todos/ directory since it's not relevant
+- Skip to the next item
+- Track skipped items for summary
+
+**When user says "custom":**
+
+- Ask what to modify (priority, description, details)
+- Update the information
+- Present revised version
+- Ask again: yes/next/custom
+
+### Step 3: Continue Until All Processed
+
+- Process all items one by one
+- Track using TodoWrite for visibility
+- Don't wait for approval between items - keep moving
+
+### Step 4: Final Summary
+
+After all items processed:
+
+````markdown
+## Triage Complete
+
+**Total Items:** [X] **Todos Approved (ready):** [Y] **Skipped:** [Z]
+
+### Approved Todos (Ready for Work):
+
+- `042-ready-p1-transaction-boundaries.md` - Transaction boundary issue
+- `043-ready-p2-cache-optimization.md` - Cache performance improvement ...
+
+### Skipped Items (Deleted):
+
+- Item #5: [reason] - Removed from todos/
+- Item #12: [reason] - Removed from todos/
+
+### Summary of Changes Made:
+
+During triage, the following status updates occurred:
+
+- **Pending → Ready:** Filenames and frontmatter updated to reflect approved status
+- **Deleted:** Todo files for skipped findings removed from todos/ directory
+- Each approved file now has `status: ready` in YAML frontmatter
+
+### Next Steps:
+
+1. View approved todos ready for work:
+   ```bash
+   ls todos/*-ready-*.md
+   ```
+````
+
+2. Start work on approved items:
+
+   ```bash
+   /resolve_todo_parallel  # Work on multiple approved items efficiently
+   ```
+
+3. Or pick individual items to work on
+
+4. As you work, update todo status:
+   - Ready → In Progress (in your local context as you work)
+   - In Progress → Complete (rename file: ready → complete, update frontmatter)
+
+```
+
+## Example Response Format
+
+```
+
+---
+
+Issue #5: Missing Transaction Boundaries for Multi-Step Operations
+
+Severity: 🔴 P1 (CRITICAL)
+
+Category: Data Integrity / Security
+
+Description: The google_oauth2_connected callback in GoogleOauthCallbacks concern performs multiple database operations without transaction protection. If any step fails midway, the database is left in an inconsistent state.
+
+Location: app/controllers/concerns/google_oauth_callbacks.rb:13-50
+
+Problem Scenario:
+
+1. User.update succeeds (email changed)
+2. Account.save! fails (validation error)
+3. Result: User has changed email but no associated Account
+4. Next login attempt fails completely
+
+Operations Without Transaction:
+
+- User confirmation (line 13)
+- Waitlist removal (line 14)
+- User profile update (line 21-23)
+- Account creation (line 28-37)
+- Avatar attachment (line 39-45)
+- Journey creation (line 47)
+
+Proposed Solution: Wrap all operations in ApplicationRecord.transaction do ... end block
+
+Estimated Effort: Small (30 minutes)
+
+---
+
+Do you want to add this to the todo list?
+
+1. yes - create todo file
+2. next - skip this item
+3. custom - modify before creating
+
+```
+
+## Important Implementation Details
+
+### Status Transitions During Triage
+
+**When "yes" is selected:**
+1. Rename file: `{id}-pending-{priority}-{desc}.md` → `{id}-ready-{priority}-{desc}.md`
+2. Update YAML frontmatter: `status: pending` → `status: ready`
+3. Update Work Log with triage approval entry
+4. Confirm: "✅ Approved: `{filename}` (Issue #{issue_id}) - Status: **ready**"
+
+**When "next" is selected:**
+1. Delete the todo file from todos/ directory
+2. Skip to next item
+3. No file remains in the system
+
+### Progress Tracking
+
+Every time you present a todo as a header, include:
+- **Progress:** X/Y completed (e.g., "3/10 completed")
+- **Estimated time remaining:** Based on how quickly you're progressing
+- **Pacing:** Monitor time per finding and adjust estimate accordingly
+
+Example:
+```
+
+Progress: 3/10 completed | Estimated time: ~2 minutes remaining
+
+```
+
+### Do Not Code During Triage
+
+- ✅ Present findings
+- ✅ Make yes/next/custom decisions
+- ✅ Update todo files (rename, frontmatter, work log)
+- ❌ Do NOT implement fixes or write code
+- ❌ Do NOT add detailed implementation details
+- ❌ That's for /resolve_todo_parallel phase
+```
+
+When done give these options
+
+```markdown
+What would you like to do next?
+
+1. run /resolve_todo_parallel to resolve the todos
+2. commit the todos
+3. nothing, go chill
+```

package/plugins/compound-engineering/commands/workflows/brainstorm.md

@@ -0,0 +1,124 @@
+---
+name: workflows:brainstorm
+description: Explore requirements and approaches through collaborative dialogue before planning implementation
+argument-hint: "[feature idea or problem to explore]"
+---
+
+# Brainstorm a Feature or Improvement
+
+**Note: The current year is 2026.** Use this when dating brainstorm documents.
+
+Brainstorming helps answer **WHAT** to build through collaborative dialogue. It precedes `/workflows:plan`, which answers **HOW** to build it.
+
+**Process knowledge:** Load the `brainstorming` skill for detailed question techniques, approach exploration patterns, and YAGNI principles.
+
+## Feature Description
+
+<feature_description> #$ARGUMENTS </feature_description>
+
+**If the feature description above is empty, ask the user:** "What would you like to explore? Please describe the feature, problem, or improvement you're thinking about."
+
+Do not proceed until you have a feature description from the user.
+
+## Execution Flow
+
+### Phase 0: Assess Requirements Clarity
+
+Evaluate whether brainstorming is needed based on the feature description.
+
+**Clear requirements indicators:**
+- Specific acceptance criteria provided
+- Referenced existing patterns to follow
+- Described exact expected behavior
+- Constrained, well-defined scope
+
+**If requirements are already clear:**
+Use **AskUserQuestion tool** to suggest: "Your requirements seem detailed enough to proceed directly to planning. Should I run `/workflows:plan` instead, or would you like to explore the idea further?"
+
+### Phase 1: Understand the Idea
+
+#### 1.1 Repository Research (Lightweight)
+
+Run a quick repo scan to understand existing patterns:
+
+- Task repo-research-analyst("Understand existing patterns related to: <feature_description>")
+
+Focus on: similar features, established patterns, CLAUDE.md guidance.
+
+#### 1.2 Collaborative Dialogue
+
+Use the **AskUserQuestion tool** to ask questions **one at a time**.
+
+**Guidelines (see `brainstorming` skill for detailed techniques):**
+- Prefer multiple choice when natural options exist
+- Start broad (purpose, users) then narrow (constraints, edge cases)
+- Validate assumptions explicitly
+- Ask about success criteria
+
+**Exit condition:** Continue until the idea is clear OR user says "proceed"
+
+### Phase 2: Explore Approaches
+
+Propose **2-3 concrete approaches** based on research and conversation.
+
+For each approach, provide:
+- Brief description (2-3 sentences)
+- Pros and cons
+- When it's best suited
+
+Lead with your recommendation and explain why. Apply YAGNI—prefer simpler solutions.
+
+Use **AskUserQuestion tool** to ask which approach the user prefers.
+
+### Phase 3: Capture the Design
+
+Write a brainstorm document to `docs/brainstorms/YYYY-MM-DD-<topic>-brainstorm.md`.
+
+**Document structure:** See the `brainstorming` skill for the template format. Key sections: What We're Building, Why This Approach, Key Decisions, Open Questions.
+
+Ensure `docs/brainstorms/` directory exists before writing.
+
+### Phase 4: Handoff
+
+Use **AskUserQuestion tool** to present next steps:
+
+**Question:** "Brainstorm captured. What would you like to do next?"
+
+**Options:**
+1. **Review and refine** - Improve the document through structured self-review
+2. **Proceed to planning** - Run `/workflows:plan` (will auto-detect this brainstorm)
+3. **Done for now** - Return later
+
+**If user selects "Review and refine":**
+
+Load the `document-review` skill and apply it to the brainstorm document.
+
+When document-review returns "Review complete", present next steps:
+
+1. **Move to planning** - Continue to `/workflows:plan` with this document
+2. **Done for now** - Brainstorming complete. To start planning later: `/workflows:plan [document-path]`
+
+## Output Summary
+
+When complete, display:
+
+```
+Brainstorm complete!
+
+Document: docs/brainstorms/YYYY-MM-DD-<topic>-brainstorm.md
+
+Key decisions:
+- [Decision 1]
+- [Decision 2]
+
+Next: Run `/workflows:plan` when ready to implement.
+```
+
+## Important Guidelines
+
+- **Stay focused on WHAT, not HOW** - Implementation details belong in the plan
+- **Ask one question at a time** - Don't overwhelm
+- **Apply YAGNI** - Prefer simpler approaches
+- **Keep outputs concise** - 200-300 words per section max
+
+NEVER CODE! Just explore and document decisions.

package/plugins/compound-engineering/commands/workflows/compound.md

@@ -0,0 +1,239 @@
+---
+name: workflows:compound
+description: Document a recently solved problem to compound your team's knowledge
+argument-hint: "[optional: brief context about the fix]"
+---
+
+# /compound
+
+Coordinate multiple subagents working in parallel to document a recently solved problem.
+
+## Purpose
+
+Captures problem solutions while context is fresh, creating structured documentation in `docs/solutions/` with YAML frontmatter for searchability and future reference. Uses parallel subagents for maximum efficiency.
+
+**Why "compound"?** Each documented solution compounds your team's knowledge. The first time you solve a problem takes research. Document it, and the next occurrence takes minutes. Knowledge compounds.
+
+## Usage
+
+```bash
+/workflows:compound                    # Document the most recent fix
+/workflows:compound [brief context]    # Provide additional context hint
+```
+
+## Execution Strategy: Two-Phase Orchestration
+
+<critical_requirement>
+**Only ONE file gets written - the final documentation.**
+
+Phase 1 subagents return TEXT DATA to the orchestrator. They must NOT use Write, Edit, or create any files. Only the orchestrator (Phase 2) writes the final documentation file.
+</critical_requirement>
+
+### Phase 1: Parallel Research
+
+<parallel_tasks>
+
+Launch these subagents IN PARALLEL. Each returns text data to the orchestrator.
+
+#### 1. **Context Analyzer**
+   - Extracts conversation history
+   - Identifies problem type, component, symptoms
+   - Validates against schema
+   - Returns: YAML frontmatter skeleton
+
+#### 2. **Solution Extractor**
+   - Analyzes all investigation steps
+   - Identifies root cause
+   - Extracts working solution with code examples
+   - Returns: Solution content block
+
+#### 3. **Related Docs Finder**
+   - Searches `docs/solutions/` for related documentation
+   - Identifies cross-references and links
+   - Finds related GitHub issues
+   - Returns: Links and relationships
+
+#### 4. **Prevention Strategist**
+   - Develops prevention strategies
+   - Creates best practices guidance
+   - Generates test cases if applicable
+   - Returns: Prevention/testing content
+
+#### 5. **Category Classifier**
+   - Determines optimal `docs/solutions/` category
+   - Validates category against schema
+   - Suggests filename based on slug
+   - Returns: Final path and filename
+
+</parallel_tasks>
+
+### Phase 2: Assembly & Write
+
+<sequential_tasks>
+
+**WAIT for all Phase 1 subagents to complete before proceeding.**
+
+The orchestrating agent (main conversation) performs these steps:
+
+1. Collect all text results from Phase 1 subagents
+2. Assemble complete markdown file from the collected pieces
+3. Validate YAML frontmatter against schema
+4. Create directory if needed: `mkdir -p docs/solutions/[category]/`
+5. Write the SINGLE final file: `docs/solutions/[category]/[filename].md`
+
+</sequential_tasks>
+
+### Phase 3: Optional Enhancement
+
+**WAIT for Phase 2 to complete before proceeding.**
+
+<parallel_tasks>
+
+Based on problem type, optionally invoke specialized agents to review the documentation:
+
+- **performance_issue** → `performance-oracle`
+- **security_issue** → `security-sentinel`
+- **database_issue** → `data-integrity-guardian`
+- **test_failure** → `cora-test-reviewer`
+- Any code-heavy issue → `kieran-rails-reviewer` + `code-simplicity-reviewer`
+
+</parallel_tasks>
+
+## What It Captures
+
+- **Problem symptom**: Exact error messages, observable behavior
+- **Investigation steps tried**: What didn't work and why
+- **Root cause analysis**: Technical explanation
+- **Working solution**: Step-by-step fix with code examples
+- **Prevention strategies**: How to avoid in future
+- **Cross-references**: Links to related issues and docs
+
+## Preconditions
+
+<preconditions enforcement="advisory">
+  <check condition="problem_solved">
+    Problem has been solved (not in-progress)
+  </check>
+  <check condition="solution_verified">
+    Solution has been verified working
+  </check>
+  <check condition="non_trivial">
+    Non-trivial problem (not simple typo or obvious error)
+  </check>
+</preconditions>
+
+## What It Creates
+
+**Organized documentation:**
+
+- File: `docs/solutions/[category]/[filename].md`
+
+**Categories auto-detected from problem:**
+
+- build-errors/
+- test-failures/
+- runtime-errors/
+- performance-issues/
+- database-issues/
+- security-issues/
+- ui-bugs/
+- integration-issues/
+- logic-errors/
+
+## Common Mistakes to Avoid
+
+| ❌ Wrong | ✅ Correct |
+|----------|-----------|
+| Subagents write files like `context-analysis.md`, `solution-draft.md` | Subagents return text data; orchestrator writes one final file |
+| Research and assembly run in parallel | Research completes → then assembly runs |
+| Multiple files created during workflow | Single file: `docs/solutions/[category]/[filename].md` |
+
+## Success Output
+
+```
+✓ Documentation complete
+
+Subagent Results:
+  ✓ Context Analyzer: Identified performance_issue in brief_system
+  ✓ Solution Extractor: 3 code fixes
+  ✓ Related Docs Finder: 2 related issues
+  ✓ Prevention Strategist: Prevention strategies, test suggestions
+  ✓ Category Classifier: `performance-issues`
+
+Specialized Agent Reviews (Auto-Triggered):
+  ✓ performance-oracle: Validated query optimization approach
+  ✓ kieran-rails-reviewer: Code examples meet Rails standards
+  ✓ code-simplicity-reviewer: Solution is appropriately minimal
+  ✓ every-style-editor: Documentation style verified
+
+File created:
+- docs/solutions/performance-issues/n-plus-one-brief-generation.md
+
+This documentation will be searchable for future reference when similar
+issues occur in the Email Processing or Brief System modules.
+
+What's next?
+1. Continue workflow (recommended)
+2. Link related documentation
+3. Update other references
+4. View documentation
+5. Other
+```
+
+## The Compounding Philosophy
+
+This creates a compounding knowledge system:
+
+1. First time you solve "N+1 query in brief generation" → Research (30 min)
+2. Document the solution → docs/solutions/performance-issues/n-plus-one-briefs.md (5 min)
+3. Next time similar issue occurs → Quick lookup (2 min)
+4. Knowledge compounds → Team gets smarter
+
+The feedback loop:
+
+```
+Build → Test → Find Issue → Research → Improve → Document → Validate → Deploy
+    ↑                                                                      ↓
+    └──────────────────────────────────────────────────────────────────────┘
+```
+
+**Each unit of engineering work should make subsequent units of work easier—not harder.**
+
+## Auto-Invoke
+
+<auto_invoke> <trigger_phrases> - "that worked" - "it's fixed" - "working now" - "problem solved" </trigger_phrases>
+
+<manual_override> Use /workflows:compound [context] to document immediately without waiting for auto-detection. </manual_override> </auto_invoke>
+
+## Routes To
+
+`compound-docs` skill
+
+## Applicable Specialized Agents
+
+Based on problem type, these agents can enhance documentation:
+
+### Code Quality & Review
+- **kieran-rails-reviewer**: Reviews code examples for Rails best practices
+- **code-simplicity-reviewer**: Ensures solution code is minimal and clear
+- **pattern-recognition-specialist**: Identifies anti-patterns or repeating issues
+
+### Specific Domain Experts
+- **performance-oracle**: Analyzes performance_issue category solutions
+- **security-sentinel**: Reviews security_issue solutions for vulnerabilities
+- **cora-test-reviewer**: Creates test cases for prevention strategies
+- **data-integrity-guardian**: Reviews database_issue migrations and queries
+
+### Enhancement & Documentation
+- **best-practices-researcher**: Enriches solution with industry best practices
+- **every-style-editor**: Reviews documentation style and clarity
+- **framework-docs-researcher**: Links to Rails/gem documentation references
+
+### When to Invoke
+- **Auto-triggered** (optional): Agents can run post-documentation for enhancement
+- **Manual trigger**: User can invoke agents after /workflows:compound completes for deeper review
+
+## Related Commands
+
+- `/research [topic]` - Deep investigation (searches docs/solutions/ for patterns)
+- `/workflows:plan` - Planning workflow (references documented solutions)