wogiflow 1.0.23 → 1.0.25

package/.claude/commands/wogi-capture.md

@@ -0,0 +1,57 @@
+Quick capture an idea or bug without interrupting your current work. Provide a brief title: `/wogi-capture Add dark mode toggle`
+
+## Usage
+
+```bash
+/wogi-capture "Your idea or bug here"
+/wogi-capture "Bug: login fails on Safari"
+```
+
+Just provide a brief title. That's it.
+
+## What Happens
+
+1. **Auto-detect type** from keywords:
+   - "bug", "fix", "broken", "error", "crash", "fails" → `bug`
+   - Everything else → `feature`
+
+2. **Auto-tag** from current context (if a task is in progress)
+
+3. **Add to backlog** in `ready.json` with minimal metadata
+
+4. **Minimal confirmation** - just "Captured: [title]"
+
+## Backlog Triage
+
+Items go to a `backlog` array in ready.json. Use `/wogi-ready` to see them.
+
+Later you can:
+- Promote to `ready` (use `/wogi-story` to create proper story)
+- Discard if no longer relevant
+- Convert to bug with `/wogi-bug`
+
+## Examples
+
+```
+/wogi-capture Add export to PDF
+→ Captured: Add export to PDF (feature)
+
+/wogi-capture Bug: form validation not working
+→ Captured: Bug: form validation not working (bug)
+
+/wogi-capture Broken image on profile page
+→ Captured: Broken image on profile page (bug)
+```
+
+## CLI Usage
+
+```bash
+node scripts/flow-capture.js "Add dark mode toggle"
+node scripts/flow-capture.js "Bug: login fails" --json
+```
+
+## Options
+
+- `--type <type>` - Force type (bug/feature) instead of auto-detect
+- `--tags <tags>` - Add comma-separated tags
+- `--json` - Output JSON instead of minimal confirmation

package/.claude/commands/wogi-correction.md

@@ -9,6 +9,51 @@ Based on `config.json` corrections mode:
 - **hybrid**: Use for significant/complex fixes
 - **always-detailed**: Use for every fix
 
+## Auto-Triggered Corrections (NEW)
+
+Corrections can be automatically prompted when failures are detected:
+
+**Trigger Points:**
+- Lint/TypeScript failures after file edit
+- Test failures after implementation
+- Critical review findings (severity "critical")
+- Repeated tech debt (3+ occurrences)
+
+**When triggered, you'll see:**
+```
+⚠️ TypeScript error detected:
+Property 'x' does not exist on type 'Y'
+
+Would you like to record this as a correction for future learning?
+This helps avoid similar mistakes.
+
+[Yes, record correction] [No, skip]
+```
+
+**If user selects Yes:**
+1. Create correction file with pre-filled context
+2. Update feedback-patterns.md with pattern count
+3. If pattern count >= 3, prompt for promotion to decisions.md
+
+**API for scripts:**
+```javascript
+const { promptForCorrection, createAutoCorrection } = require('./flow-correct');
+
+// Check if should prompt
+const prompt = promptForCorrection({
+  type: 'typecheck',
+  error: 'Property x does not exist',
+  files: ['src/api.ts'],
+  taskId: 'wf-abc123'
+});
+
+if (prompt.shouldPrompt) {
+  // Ask user via AskUserQuestion
+  // If yes, create correction:
+  createAutoCorrection(prompt.correctionData);
+}
+```
+
 ## Steps
 
 1. Read `config.json` to check corrections mode

package/.claude/commands/wogi-extract-review.md

@@ -0,0 +1,175 @@
+# /wogi-extract-review - Zero-Loss Task Extraction with Mandatory Review
+
+Extract tasks from long input with 100% capture rate and mandatory human review.
+
+## Purpose
+
+When processing transcripts, meeting notes, or long prompts, this command ensures NOTHING is missed by:
+1. Capturing EVERY distinct statement (no filtering)
+2. Deduplicating similar items
+3. Requiring explicit human review and confirmation
+4. Only proceeding when user confirms the list is complete
+
+## Philosophy
+
+**OLD approach (lossy):** Input → Filter → Filter → Output (70-80% lost)
+**NEW approach (zero-loss):** Input → Capture All → Dedupe → Review → Confirm → Output (100% captured)
+
+## Usage
+
+```bash
+# Start zero-loss extraction
+flow extract-zero-loss start
+
+# Or pipe content
+cat transcript.txt | flow extract-zero-loss start
+
+# Check review status
+flow extract-zero-loss status
+
+# View items by category
+flow extract-zero-loss show pending
+flow extract-zero-loss show high      # High confidence items
+flow extract-zero-loss show medium    # Medium confidence
+flow extract-zero-loss show low       # Low confidence
+flow extract-zero-loss show filler    # Potential filler
+
+# Review actions
+flow extract-zero-loss confirm <id>           # Confirm as task
+flow extract-zero-loss remove <id> "<reason>" # Remove (reason required!)
+flow extract-zero-loss merge <src> <target>   # Merge duplicate
+
+# Bulk actions
+flow extract-zero-loss confirm-high           # Confirm all high-confidence
+flow extract-zero-loss dismiss-filler         # Dismiss filler items
+
+# Complete review (MANDATORY before proceeding)
+flow extract-zero-loss complete
+
+# Get confirmed tasks
+flow extract-zero-loss tasks
+```
+
+## Review Workflow
+
+### Step 1: Start Extraction
+```
+flow extract-zero-loss start < transcript.txt
+```
+
+This extracts EVERYTHING from the input using multiple strategies:
+- Sentence boundaries
+- Line breaks
+- Speaker changes
+- List items (bullets, numbers)
+- Comma-separated items with action verbs
+
+### Step 2: Quick Review High-Confidence Items
+```
+flow extract-zero-loss show high
+```
+
+These items almost certainly contain tasks. Review and confirm or adjust.
+
+### Step 3: Review Medium-Confidence Items
+```
+flow extract-zero-loss show medium
+```
+
+Many valid tasks here. Review carefully.
+
+### Step 4: Review Low-Confidence Items
+```
+flow extract-zero-loss show low
+```
+
+Some may be tasks phrased informally. Don't skip!
+
+### Step 5: Handle Filler (Optional)
+```
+flow extract-zero-loss dismiss-filler
+```
+
+Dismiss conversational filler like "um", "okay", "thanks".
+
+### Step 6: Confirm Completeness (MANDATORY)
+```
+flow extract-zero-loss complete
+```
+
+User must explicitly confirm the task list is complete before proceeding.
+
+## Integration with Long-Input Processing
+
+After zero-loss extraction and review:
+1. Confirmed tasks become the input for topic extraction
+2. Topics are generated from the confirmed task list
+3. Standard 4-pass processing continues
+
+```bash
+# Full flow
+cat transcript.txt | flow extract-zero-loss start
+flow extract-zero-loss confirm-high
+# ... manual review ...
+flow extract-zero-loss complete
+flow long-input topics    # Now uses confirmed tasks
+flow long-input pass2
+flow long-input pass3
+flow long-input pass4
+```
+
+## Why This Matters
+
+> "When I work with my employees, when we have a meeting, even if it takes an hour or two, when I give a task, an employee will write it down, add a comment on Figma, add it to Jira, write it down in his notebook, but nothing is getting missed."
+
+This system ensures:
+- **100% capture rate** - Nothing is auto-filtered
+- **Explicit confirmation** - User reviews everything
+- **Audit trail** - Track what was confirmed vs removed
+- **Reason required** - Can't remove without explanation
+
+## Confidence Levels
+
+Items are scored (not filtered!) by confidence:
+
+**High Confidence** - Contains explicit requirement signals:
+- "We need to add..."
+- "Should display..."
+- "Must have..."
+- "I would like..."
+- "Change X to Y"
+
+**Medium Confidence** - Contains softer signals:
+- "Maybe we could..."
+- "What if we..."
+- "Going to need..."
+
+**Low Confidence** - No clear signals but may be tasks:
+- Short statements
+- Questions
+- Partial sentences
+
+**Filler** - Conversational noise (still captured!):
+- "Um", "Okay", "Thanks"
+- "Can you hear me?"
+- "Makes sense"
+
+## Files
+
+| File | Location |
+|------|----------|
+| Extraction module | `scripts/flow-zero-loss-extraction.js` |
+| Review module | `scripts/flow-extraction-review.js` |
+| Review session | `.workflow/tmp/long-input/review-session.json` |
+
+## For Claude
+
+When processing long transcripts:
+
+1. **Always use zero-loss extraction** for meeting transcripts and reviews
+2. **Present items by confidence level** to the user
+3. **Never skip low-confidence items** - user must explicitly dismiss
+4. **Require completeness confirmation** before proceeding to topic extraction
+5. **Log all confirmed tasks** for audit trail
+
+The goal is **100% task capture rate**, not 90%.

package/.claude/commands/wogi-peer-review.md

@@ -0,0 +1,164 @@
+Run a multi-model peer review where different AI models review the same code.
+
+## How It Works
+
+1. **Primary model (Claude)** reviews the changes for improvements
+2. **Secondary model(s)** review the same changes
+3. **Findings are compared** and disagreements surfaced
+4. **Primary model responds** to peer feedback:
+   - Defends decisions with context
+   - OR acknowledges valid alternatives
+
+## Key Difference from `/wogi-review`
+
+| `/wogi-review` | `/wogi-peer-review` |
+|----------------|---------------------|
+| "Is this correct, secure, working?" | "Is this the BEST approach?" |
+| Bug detection | Optimization opportunities |
+| Security vulnerabilities | Alternative implementations |
+| Architecture conflicts | Pattern suggestions |
+| Verification-focused | Improvement-focused |
+
+## What Peer Review Surfaces
+
+1. **Optimization opportunities** - "This works, but could be faster/cleaner"
+2. **Alternative approaches** - "Consider doing X instead of Y"
+3. **Cross-model disagreements** - Where different models see things differently
+4. **Pattern suggestions** - "Other codebases typically do this as..."
+5. **Missed edge cases** - Fresh eyes catch what familiarity misses
+
+## Usage
+
+```bash
+/wogi-peer-review                    # Review staged changes
+/wogi-peer-review --files src/*.ts   # Review specific files
+/wogi-peer-review --task wf-abc123   # Review task changes
+```
+
+## Provider Configuration
+
+Configure in `.workflow/config.json` under `peerReview`:
+
+### Option A: API Keys (Default)
+```json
+"peerReview": {
+  "enabled": true,
+  "provider": "api",
+  "models": ["openai:gpt-4o", "google:gemini-pro"],
+  "apiKeys": {
+    "openai": "${OPENAI_API_KEY}",
+    "google": "${GOOGLE_API_KEY}"
+  }
+}
+```
+
+### Option B: MCP Integration
+```json
+"peerReview": {
+  "enabled": true,
+  "provider": "mcp",
+  "mcpServers": {
+    "openai": "mcp-openai",
+    "google": "mcp-gemini"
+  }
+}
+```
+
+### Option C: Manual Mode
+```json
+"peerReview": {
+  "enabled": true,
+  "provider": "manual"
+}
+```
+
+When manual:
+1. Outputs the review prompt
+2. User runs in Cursor/other tool
+3. User pastes results back
+4. Claude synthesizes
+
+## Review Flow
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  /wogi-peer-review                                       │
+├─────────────────────────────────────────────────────────┤
+│  1. Collect code changes (git diff or specified files)   │
+│  2. Generate improvement-focused prompt                  │
+│  3. Claude reviews for improvements                      │
+│  4. Secondary model(s) review                            │
+│  5. Compare findings:                                    │
+│     • Both agree → Strong suggestion                     │
+│     • Disagree → Present both perspectives               │
+│  6. Claude responds to peer feedback:                    │
+│     • "I have more context, here's why X is better..."   │
+│     • "Valid point, Y would be an improvement..."        │
+│  7. Output final synthesis                               │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Review Prompt Template
+
+The peer review focuses on improvements, not correctness:
+
+```
+Review this code for IMPROVEMENT OPPORTUNITIES, not bugs:
+
+1. **Optimization**: Can this be faster/more efficient?
+2. **Alternatives**: Are there better approaches?
+3. **Patterns**: Does this follow best practices?
+4. **Readability**: Could this be clearer/simpler?
+5. **Extensibility**: Will this be easy to extend?
+
+Code:
+[code changes]
+
+Respond with:
+- Specific improvement suggestions
+- Alternative approaches considered
+- Trade-off analysis for any changes
+```
+
+## Output
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 Peer Review Results
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ Agreement (2/2 models):
+   • Consider using early return for readability
+   • Extract repeated logic to helper function
+
+⚖️ Disagreement:
+   • Claude: Prefer inline styling for this case
+   • GPT-4: Recommend extracting to CSS module
+   → Resolution: Context-dependent, current approach is valid
+
+💡 Unique Insights:
+   • [GPT-4] Consider memoization for expensive computation
+   • [Claude] Current architecture handles edge case X well
+
+📊 Summary:
+   3 actionable improvements identified
+   1 disagreement resolved
+   Code quality: Good, with minor optimization opportunities
+```
+
+## When to Use
+
+- Before merging significant changes
+- For security-sensitive code
+- When you want high confidence
+- For learning different perspectives
+- When stuck on architecture decisions
+
+## Options
+
+- `--provider <name>` - Override configured provider
+- `--model <name>` - Specify secondary model
+- `--files <glob>` - Review specific files
+- `--task <id>` - Review task changes
+- `--json` - Output JSON for automation
+- `--verbose` - Show full model responses

package/.claude/commands/wogi-start.md

@@ -96,6 +96,47 @@ This command implements a **structured execution loop**:
 5. Check `.workflow/state/app-map.md` for components mentioned
 6. Check `.workflow/state/decisions.md` for relevant patterns
 7. **Auto-invoke skills** based on task context:
+
+### Step 1.2: Clarifying Questions (NEW)
+
+**BEFORE generating specifications**, ask clarifying questions to catch assumptions early:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+❓ Clarifying Questions
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Before implementation, consider clarifying:
+
+🎯 Scope Validation
+   1. Found X related files. Should I modify all of them?
+
+💡 Assumption Surfacing
+   2. Should I assume [pattern] for this task?
+
+🔀 Edge Cases
+   3. What should happen when [error condition]?
+
+Note: You can proceed without answering, but clarification may prevent rework.
+```
+
+**Question Categories:**
+- **Scope Validation**: "Found X components. Are we changing all?"
+- **Assumption Surfacing**: "Should I assume [pattern] for this task?"
+- **Edge Cases**: "What about [similar scenario]?"
+- **Integration Points**: "This touches [component]. Dependency concerns?"
+- **Implementation Preferences**: "Any specific approach you prefer?"
+
+**Config**: Controlled by `config.clarifyingQuestions`:
+- `enabled`: true/false
+- `maxQuestions`: max questions to ask (default: 5)
+- `skipForSmallTasks`: skip for small tasks (default: true)
+- `smallTaskThreshold`: files count threshold (default: 2)
+
+**Skipped for**: Small tasks (≤2 files), bugfixes, tasks with explicit specs
+
+---
+
+**Skill Matching Output:**
    - Run skill matcher against task description
    - Load matched skills (patterns.md, anti-patterns.md, learnings.md)
    - Display matched skills with scores

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow

@@ -56,6 +56,7 @@ show_help() {
     echo "  story <title> --deep Create story with automatic decomposition"
     echo "  new-feature <n>   Create new feature"
     echo "  bug <title>          Create bug report"
+    echo "  capture <title>      Quick capture idea/bug without interrupting flow"
     echo ""
     echo "Roadmap & Planning:"
     echo "  roadmap              Show project roadmap"
@@ -363,6 +364,9 @@ case "${1:-}" in
     bug)
         node "$SCRIPT_DIR/flow-bug.js" "${@:2}"
         ;;
+    capture)
+        node "$SCRIPT_DIR/flow-capture.js" "${@:2}"
+        ;;
     status)
         node "$SCRIPT_DIR/flow-status.js" "${@:2}"
         ;;
@@ -471,6 +475,9 @@ case "${1:-}" in
     review)
         node "$SCRIPT_DIR/flow-review.js" "${@:2}"
         ;;
+    peer-review)
+        node "$SCRIPT_DIR/flow-peer-review.js" "${@:2}"
+        ;;
     correct)
         node "$SCRIPT_DIR/flow-correct.js" "${@:2}"
         ;;
@@ -489,6 +496,9 @@ case "${1:-}" in
     context)
         "$SCRIPT_DIR/flow-context" "${@:2}"
         ;;
+    clarifying-questions|clarify)
+        node "$SCRIPT_DIR/flow-clarifying-questions.js" "${@:2}"
+        ;;
     links)
         node "$SCRIPT_DIR/flow-links.js" "${@:2}"
         ;;