wogiflow 1.0.22 → 1.0.24

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-compact.md

@@ -15,6 +15,21 @@ Root (overview)
     └── File changes (expandable)
 ```
 
+## CRITICAL: Task Queue Check
+
+**Before ANY compaction**, you MUST:
+
+1. Read `.workflow/state/ready.json`
+2. Note pending tasks in your summary
+3. **NEVER claim "nothing pending" without checking ready.json**
+
+If tasks exist:
+- **In Progress**: List task IDs currently being worked on
+- **Ready**: Count + list task IDs awaiting work
+- **Blocked**: Count blocked tasks
+
+This ensures task awareness survives context compaction.
+
 ## Before Compacting
 
 1. **Update progress.md** with:
@@ -48,7 +63,12 @@ Provide this information for the compaction system:
 - [Task/change 1]
 - [Task/change 2]
 
-**In Progress**:
+**Pending Tasks** (REQUIRED - from ready.json):
+- In Progress: [task IDs or "none"]
+- Ready: [count] tasks - [first 5 task IDs]
+- Blocked: [count] tasks
+
+**In Progress (Current)**:
 - TASK-XXX: [description] - [current state, what's left]
 
 **Key Decisions**:
@@ -65,6 +85,8 @@ Provide this information for the compaction system:
 
 **Context to Preserve**:
 - [Important context that should survive compaction]
+
+**ON RESUME**: Check `.workflow/state/ready.json` for pending work.
 ```
 
 ## Context Pressure Monitoring

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-init.md

@@ -509,9 +509,6 @@ This file tracks all changes made to the project.
 **Files**: .workflow/*, .claude/*
 ```
 
-**roadmap.md** (future work):
-Copy from `templates/roadmap.md` to `.workflow/roadmap.md`
-
 #### 4.4 Create Spec Files
 
 **stack.md** in `.workflow/specs/`:

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.22",
+  "version": "1.0.24",
   "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}"
         ;;

package/scripts/flow-capture.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Quick Capture
+ *
+ * Quickly capture ideas or bugs without interrupting flow.
+ * Items go to backlog in ready.json for later triage.
+ *
+ * Usage:
+ *   node scripts/flow-capture.js "<title>" [--type bug|feature] [--tags tag1,tag2] [--json]
+ */
+
+const path = require('path');
+const {
+  PATHS,
+  readJson,
+  writeJson,
+  parseFlags,
+  outputJson,
+  success,
+  error
+} = require('./flow-utils');
+
+// Try to load session state for auto-detecting current task
+let loadSessionState;
+try {
+  const sessionModule = require('./flow-session-state');
+  loadSessionState = sessionModule.loadSessionState;
+} catch (importError) {
+  if (process.env.DEBUG) {
+    console.warn(`[DEBUG] Could not load flow-session-state: ${importError.message}`);
+  }
+  loadSessionState = () => ({});
+}
+
+/**
+ * Keywords that indicate a bug report
+ */
+const BUG_KEYWORDS = [
+  'bug',
+  'fix',
+  'broken',
+  'error',
+  'crash',
+  'fails',
+  'failing',
+  'not working',
+  'doesn\'t work',
+  'issue',
+  'problem'
+];
+
+/**
+ * Auto-detect type from title
+ * @param {string} title - The captured title
+ * @returns {'bug' | 'feature'}
+ */
+function detectType(title) {
+  const lowerTitle = title.toLowerCase();
+
+  for (const keyword of BUG_KEYWORDS) {
+    if (lowerTitle.includes(keyword)) {
+      return 'bug';
+    }
+  }
+
+  return 'feature';
+}
+
+/**
+ * Generate a capture ID
+ * Format: cap-YYYYMMDD-NNN
+ * @param {Array} existingBacklog - Existing backlog items
+ * @returns {string}
+ */
+function generateCaptureId(existingBacklog) {
+  const today = new Date().toISOString().split('T')[0].replace(/-/g, '');
+
+  // Find highest number for today
+  const todayPattern = new RegExp(`^cap-${today}-(\\d{3})$`);
+  let maxNum = 0;
+
+  for (const item of existingBacklog) {
+    const match = item.id && item.id.match(todayPattern);
+    if (match) {
+      maxNum = Math.max(maxNum, parseInt(match[1], 10));
+    }
+  }
+
+  const nextNum = String(maxNum + 1).padStart(3, '0');
+  return `cap-${today}-${nextNum}`;
+}
+
+/**
+ * Get current task from session state
+ */
+function getCurrentTask() {
+  try {
+    const sessionState = loadSessionState();
+    return sessionState.currentTask || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract tags from current task context
+ * @param {Object|null} currentTask - Current task if any
+ * @returns {string[]}
+ */
+function extractContextTags(currentTask) {
+  if (!currentTask) return [];
+
+  const tags = [];
+
+  if (currentTask.feature) {
+    tags.push(`#feature:${currentTask.feature}`);
+  }
+
+  // Could also extract #screen: or #component: from task description
+  // if task has tags field
+  if (currentTask.tags && Array.isArray(currentTask.tags)) {
+    tags.push(...currentTask.tags);
+  }
+
+  return tags;
+}
+
+/**
+ * Add item to backlog in ready.json
+ * @param {Object} item - Backlog item to add
+ */
+function addToBacklog(item) {
+  const readyPath = PATHS.ready;
+
+  try {
+    const ready = readJson(readyPath, {
+      lastUpdated: new Date().toISOString(),
+      ready: [],
+      inProgress: [],
+      blocked: [],
+      recentlyCompleted: [],
+      backlog: []
+    });
+
+    // Ensure backlog is an array (not just non-null)
+    if (!Array.isArray(ready.backlog)) {
+      ready.backlog = [];
+    }
+
+    // Add item
+    ready.backlog.push(item);
+    ready.lastUpdated = new Date().toISOString();
+
+    // Write back
+    writeJson(readyPath, ready);
+  } catch (err) {
+    error(`Failed to add to backlog: ${err.message}`);
+    throw err;
+  }
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const { flags, positional } = parseFlags(process.argv.slice(2));
+
+  // Handle help
+  if (flags.help) {
+    console.log(`
+Usage: flow capture "<title>" [options]
+
+Quick capture an idea or bug without interrupting flow.
+
+Options:
+  --type <type>   Force type: bug or feature (default: auto-detect)
+  --tags <tags>   Comma-separated tags to add
+  --json          Output JSON
+
+Examples:
+  flow capture "Add dark mode toggle"
+  flow capture "Bug: login fails on Safari"
+  flow capture "Fix broken image" --type bug --tags "#screen:profile"
+`);
+    process.exit(0);
+  }
+
+  // Validate title
+  const title = positional[0];
+  if (!title) {
+    error('Title is required');
+    console.log('Usage: flow capture "<title>"');
+    process.exit(1);
+  }
+
+  // Get current task for context
+  const currentTask = getCurrentTask();
+
+  // Load existing backlog to generate ID
+  const ready = readJson(PATHS.ready, { backlog: [] });
+  const existingBacklog = ready.backlog || [];
+
+  // Generate ID
+  const id = generateCaptureId(existingBacklog);
+
+  // Determine type
+  const type = flags.type || detectType(title);
+
+  // Gather tags
+  let tags = extractContextTags(currentTask);
+  if (flags.tags) {
+    const userTags = flags.tags.split(',').map(t => t.trim()).filter(Boolean);
+    tags = [...tags, ...userTags];
+  }
+
+  // Create capture item
+  const item = {
+    id,
+    title,
+    type,
+    capturedAt: new Date().toISOString(),
+    ...(currentTask && { capturedDuring: currentTask.id }),
+    ...(tags.length > 0 && { tags })
+  };
+
+  // Add to backlog
+  addToBacklog(item);
+
+  // Output
+  if (flags.json) {
+    outputJson({
+      success: true,
+      captured: item
+    });
+  } else {
+    success(`Captured: ${title} (${type})`);
+  }
+}
+
+// Run only when executed directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main, detectType, generateCaptureId, addToBacklog };