wogiflow 1.0.34 → 1.0.36

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

@@ -89,4 +89,74 @@ Recommended models for code generation:
 - **Qwen3-Coder 30B** - Best code quality
 - **DeepSeek Coder** - Good balance
 
+## Hybrid Mode Intelligence (v2.1)
+
+Hybrid mode now includes intelligent features that learn from each execution:
+
+### Model Learning Profiles
+
+Each executor model gets its own learning profile at `.workflow/state/model-profiles/`.
+The system learns:
+- What context each model needs for success
+- Common failure patterns to avoid
+- Optimal example count and instruction richness
+
+```bash
+# View model profiles
+node scripts/flow-model-profile.js list
+
+# Get profile for specific model
+node scripts/flow-model-profile.js get qwen3-coder
+
+# Get instruction richness recommendation
+node scripts/flow-model-profile.js richness qwen3-coder create --json
+```
+
+### Task Type Classification
+
+Tasks are automatically classified as:
+- **create** - New files/components
+- **modify** - Edit existing files
+- **refactor** - Structural changes
+- **fix** - Bug fixes
+- **integrate** - Connect systems
+
+Each type loads specific context and follows learned patterns.
+
+```bash
+# Classify a task
+node scripts/flow-task-classifier.js classify "Add user authentication"
+
+# Get context for task type
+node scripts/flow-task-classifier.js context create
+```
+
+### Failure Learning
+
+When execution fails, the system:
+1. Asks the executor what information was missing
+2. Updates the model profile with learnings
+3. Retries with enhanced context
+
+```bash
+# View learning statistics
+node scripts/flow-failure-learning.js stats
+
+# View recent learnings
+node scripts/flow-failure-learning.js recent qwen3-coder
+```
+
+### Cheaper Context Generation
+
+Context is generated using the cheapest appropriate model:
+- **Scripts**: File listing, export extraction (free)
+- **Haiku**: Import mapping, PIN generation (cheap)
+- **Sonnet**: Pattern identification (moderate)
+- **Opus**: Architecture analysis (only when needed)
+
+```bash
+# Generate project context
+node scripts/flow-context-generator.js generate --verbose
+```
+
 Let me detect your local LLM setup now...

package/.claude/commands/wogi-models-setup.md

@@ -143,6 +143,39 @@ Ask user about default preferences:
 }
 ```
 
+### Step 3.5: Include Claude in Peer Reviews (Optional)
+
+Ask if Claude should also participate as a reviewer:
+
+```javascript
+{
+  question: "Include Claude as a peer reviewer?",
+  header: "Claude Review",
+  multiSelect: false,
+  options: [
+    {
+      label: "Yes (Recommended)",
+      description: "Claude also reviews alongside external models for an extra perspective"
+    },
+    {
+      label: "No",
+      description: "Only use external models for peer review"
+    }
+  ]
+}
+```
+
+Save to config:
+```javascript
+const modelConfig = require('./scripts/flow-model-config');
+modelConfig.setIncludeClaude(userSelectedYes);
+```
+
+**Why include Claude?**
+- Provides additional perspective from the orchestrating model
+- Can leverage full conversation context when reviewing
+- Catches things external models might miss due to context limitations
+
 ### Step 4: Summary
 
 Display configuration summary:
@@ -161,6 +194,7 @@ API Keys stored in: .env
 Config saved to: .workflow/config.json
 
 Default for peer review: gpt-4o, gemini-2.0-flash
+Include Claude in reviews: Yes ✓
 Default for hybrid mode: local:qwen2.5-coder
 
 You can now use:

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

@@ -12,12 +12,16 @@ const modelConfig = require('./scripts/flow-model-config');
 // Run migration if needed (handles old config formats)
 modelConfig.migrateOldConfig();
 
+// Check if Claude should also review
+const includeClaude = modelConfig.shouldIncludeClaude();
+
 // Check if models already selected this session
 const sessionModels = modelConfig.getSessionModels('peerReview');
 
 if (sessionModels && sessionModels.length > 0 && !args.includes('--select-models')) {
   // Use session models - show brief note
-  console.log(`Using models: ${sessionModels.join(', ')}`);
+  const claudeNote = includeClaude ? ' + Claude' : '';
+  console.log(`Using models: ${sessionModels.join(', ')}${claudeNote}`);
   console.log(`(Run with --select-models to change)`);
   // Proceed with review using sessionModels
 } else {
@@ -56,6 +60,8 @@ Show selection dialog when:
   header: "Models",
   multiSelect: true,
   options: [
+    // Claude option (when includeClaude is enabled in config)
+    { label: "Claude (current session)", description: "Reviews using current conversation context" },
     // Dynamically populated from configured models
     { label: "openai:gpt-4o", description: "Best quality reasoning" },
     { label: "openai:gpt-4o-mini", description: "Faster, cheaper" },
@@ -66,7 +72,11 @@ Show selection dialog when:
 }
 ```
 
-**Show only models that:**
+**Show Claude option when:**
+- `modelConfig.shouldIncludeClaude()` returns `true`
+- Claude is shown first (recommended) as it has full context
+
+**Show external models that:**
 1. Are configured in `models.providers`
 2. Have `enabled: true`
 3. Have API key set (check `process.env[apiKeyEnv]`) or are local
@@ -84,13 +94,24 @@ Then proceed with the review using selected models.
 
 ## 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:
+### When `includeClaude` is enabled (recommended):
+1. **Claude reviews first** using the same improvement-focused prompt as external models
+2. **External model(s)** review the same changes via API
+3. **All findings compared** (Claude + external models)
+4. **Claude synthesizes** all perspectives and responds to disagreements
+
+### When `includeClaude` is disabled:
+1. **External model(s)** review the changes via API
+2. **Findings are compared** across external models
+3. **Claude synthesizes** findings and responds to peer feedback:
    - Defends decisions with context
    - OR acknowledges valid alternatives
 
+**Why include Claude?**
+- Provides additional perspective alongside external models
+- Has full conversation context (knows why certain decisions were made)
+- Catches things external models might miss due to context limitations
+
 ## Key Difference from `/wogi-review`
 
 | `/wogi-review` | `/wogi-peer-review` |
@@ -156,7 +177,8 @@ Models are configured in `.workflow/config.json` under `models`:
       }
     },
     "defaults": {
-      "peerReview": ["openai:gpt-4o", "google:gemini-2.0-flash"]
+      "peerReview": ["openai:gpt-4o", "google:gemini-2.0-flash"],
+      "includeClaude": true
     }
   }
 }
@@ -202,18 +224,53 @@ When manual:
 ├─────────────────────────────────────────────────────────┤
 │  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:                    │
+│  3. If includeClaude enabled:                            │
+│     • Launch Claude review (Task agent, Explore type)   │
+│     • Claude reviews using same prompt as external       │
+│  4. External model(s) review via API                     │
+│  5. Collect all results                                  │
+│  6. Compare findings:                                    │
+│     • All agree → Strong suggestion                      │
+│     • Partial agree → Present perspectives               │
+│     • Disagree → Surface disagreement                    │
+│  7. Claude synthesizes and responds to feedback:         │
 │     • "I have more context, here's why X is better..."   │
 │     • "Valid point, Y would be an improvement..."        │
-│  7. Output final synthesis                               │
+│  8. Output final synthesis                               │
 └─────────────────────────────────────────────────────────┘
 ```
 
+### Claude Review Implementation
+
+When `includeClaude` is enabled, launch a Task agent to perform Claude's review:
+
+```javascript
+// In wogi-peer-review execution
+const modelConfig = require('./scripts/flow-model-config');
+
+if (modelConfig.shouldIncludeClaude()) {
+  // Launch Task agent with subagent_type=Explore
+  // Use the same improvement-focused prompt as external models
+  // The agent reviews the code and returns findings
+  // Add Claude's results to the comparison alongside external model results
+}
+```
+
+**Task agent prompt for Claude review:**
+```
+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 changes]
+
+Return structured findings with specific suggestions.
+```
+
 ## Review Prompt Template
 
 The peer review focuses on improvements, not correctness:
@@ -243,21 +300,30 @@ Respond with:
 🔍 Peer Review Results
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-✅ Agreement (2/2 models):
+Reviewers: Claude, GPT-4o, Gemini 2.0 Flash
+
+✅ Agreement (3/3 models):
    • Consider using early return for readability
    • Extract repeated logic to helper function
 
+⚖️ Partial Agreement (2/3 models):
+   • Claude + Gemini: Add input validation at boundary
+   • GPT-4o: Not necessary for internal function
+
 ⚖️ Disagreement:
    • Claude: Prefer inline styling for this case
-   • GPT-4: Recommend extracting to CSS module
+   • GPT-4o: Recommend extracting to CSS module
+   • Gemini: No strong opinion
    → Resolution: Context-dependent, current approach is valid
 
 💡 Unique Insights:
-   • [GPT-4] Consider memoization for expensive computation
    • [Claude] Current architecture handles edge case X well
+   • [GPT-4o] Consider memoization for expensive computation
+   • [Gemini] Similar pattern used in popular library Y
 
 📊 Summary:
-   3 actionable improvements identified
+   Reviewers: 3 (Claude + 2 external)
+   4 actionable improvements identified
    1 disagreement resolved
    Code quality: Good, with minor optimization opportunities
 ```

package/package.json

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