wogiflow 1.0.21 → 1.0.22

package/.claude/docs/knowledge-base/03-self-improvement/README.md

@@ -0,0 +1,199 @@
+# Self-Improvement & Learning
+
+How WogiFlow learns and improves over time through feedback, corrections, and pattern recognition.
+
+---
+
+## The Learning System
+
+WogiFlow learns at four levels:
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                        LEARNING HIERARCHY                           │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│   ┌───────────────┐                                                │
+│   │ 4. Team Level │ ← Cross-project patterns, shared knowledge     │
+│   └───────┬───────┘                                                │
+│           │                                                         │
+│   ┌───────▼───────┐                                                │
+│   │ 3. Model Level│ ← Per-model optimizations, error patterns      │
+│   └───────┬───────┘                                                │
+│           │                                                         │
+│   ┌───────▼───────┐                                                │
+│   │ 2. Skill Level│ ← Framework patterns, anti-patterns           │
+│   └───────┬───────┘                                                │
+│           │                                                         │
+│   ┌───────▼───────┐                                                │
+│   │1. Project Level│ ← decisions.md, feedback patterns             │
+│   └───────────────┘                                                │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Why Learning Matters
+
+**The Problem**: AI makes the same mistakes repeatedly because it doesn't remember corrections.
+
+**The Solution**: WogiFlow captures corrections and patterns, then applies them to future work:
+- Corrections update decisions.md
+- Patterns are extracted into skills
+- Model-specific behaviors are adapted
+- Team knowledge is shared
+
+---
+
+## Quick Start
+
+### Enable Learning
+
+```json
+{
+  "skillLearning": {
+    "enabled": true,
+    "autoExtract": true,
+    "autoCreateSkills": "ask"
+  }
+}
+```
+
+### Trigger Learning
+
+- **Automatic**: On task completion, commits, compaction
+- **Manual**: Correction reports, feedback patterns
+
+### View Learnings
+
+```bash
+# View current decisions
+cat .workflow/state/decisions.md
+
+# View feedback patterns
+cat .workflow/state/feedback-patterns.md
+
+# View skill learnings
+cat .claude/skills/*/knowledge/patterns.md
+```
+
+---
+
+## Features in This Category
+
+| Feature | Purpose |
+|---------|---------|
+| [Project Learning](./project-learning.md) | decisions.md updates, feedback patterns |
+| [Skill Learning](./skill-learning.md) | Framework patterns, skill creation |
+| [Model Learning](./model-learning.md) | Per-model optimization, adapters |
+| [Team Learning](./team-learning.md) | Knowledge routing, promotion |
+
+---
+
+## Key Configuration
+
+```json
+{
+  "skillLearning": {
+    "enabled": true,
+    "autoExtract": true,
+    "triggers": {
+      "onCommit": true,
+      "onTaskComplete": true,
+      "onCompact": true
+    },
+    "minCorrectionsToLearn": 1,
+    "autoCreateSkills": "ask"
+  },
+  "modelAdapters": {
+    "enabled": true,
+    "autoLearn": true
+  },
+  "knowledgeRouting": {
+    "autoDetect": true,
+    "confirmWithUser": true,
+    "defaultScope": "local"
+  }
+}
+```
+
+---
+
+## The Feedback Loop
+
+```
+User Corrects AI
+      ↓
+┌─────────────────────────────────────────┐
+│ 1. Fix the immediate issue              │
+├─────────────────────────────────────────┤
+│ 2. Offer to persist correction          │
+│    - decisions.md (project)             │
+│    - agents/*.md (personas)             │
+│    - config.json (behavior)             │
+│    - .claude/skills/*/patterns.md (framework)   │
+├─────────────────────────────────────────┤
+│ 3. Update selected location             │
+├─────────────────────────────────────────┤
+│ 4. Log to feedback-patterns.md          │
+├─────────────────────────────────────────┤
+│ 5. Commit learning                      │
+└─────────────────────────────────────────┘
+      ↓
+Future work uses new knowledge
+```
+
+---
+
+## Learning Locations
+
+| What | Where | Updated By |
+|------|-------|------------|
+| Coding patterns | `decisions.md` | AI + User |
+| Agent behaviors | `agents/*.md` | AI + User |
+| Config settings | `config.json` | AI + User |
+| Framework patterns | `.claude/skills/*/patterns.md` | AI |
+| Model behaviors | `model-adapters/*.md` | System |
+| Feedback history | `feedback-patterns.md` | System |
+
+---
+
+## Correction Types
+
+| Type | Example | Persists To |
+|------|---------|-------------|
+| Pattern | "Always use axios wrapper" | decisions.md |
+| Style | "Don't use semicolons" | decisions.md |
+| Architecture | "Services go in /services" | decisions.md |
+| Framework | "NestJS uses decorators" | .claude/skills/nestjs/patterns.md |
+| Behavior | "Ask before deleting files" | config.json |
+| Agent | "Tester should mock external APIs" | agents/tester.md |
+
+---
+
+## Commands
+
+| Command | Purpose |
+|---------|---------|
+| `/wogi-skill-learn` | Trigger learning extraction |
+| `/wogi-correction` | Create detailed correction report |
+| `/wogi-rules` | View and manage project rules |
+
+---
+
+## Best Practices
+
+1. **Correct Once, Persist Forever**: Always choose to persist corrections
+2. **Be Specific**: "Use axios from lib/api" not just "use axios"
+3. **Review Learnings**: Periodically check decisions.md for accuracy
+4. **Share Team Patterns**: Promote valuable patterns to team level
+5. **Clean Up Outdated**: Remove patterns that no longer apply
+
+---
+
+## Related
+
+- [Task Execution](../02-task-execution/) - Where learnings are applied
+- [Memory & Context](../04-memory-context/) - How learnings are stored
+- [Configuration](../configuration/all-options.md) - Learning settings

package/.claude/docs/knowledge-base/03-self-improvement/long-input-processing.md

@@ -0,0 +1,160 @@
+# Long Input Processing
+
+<!-- PINS: overview, gate-system, content-classification, processing-modes -->
+
+A smart gate system for processing large inputs (transcripts, specs, requirements) with automatic content classification.
+
+---
+
+## Overview
+<!-- PIN: overview -->
+
+The Long Input Processing system automatically detects and handles large inputs using a gate mechanism that:
+
+1. **Checks input size** against configurable thresholds
+2. **Classifies content type** (transcript, spec, requirements, code)
+3. **Recommends processing mode** based on content type
+4. **Triggers appropriate extraction** when needed
+
+This replaces the old `/transcript-digestion` skill with a more flexible, automatic approach.
+
+---
+
+## The Gate System
+<!-- PIN: gate-system -->
+
+```
+User Input → Long Input Gate → Content Classification → Processing Mode
+                  ↓                      ↓                    ↓
+            Check thresholds      Detect type          full|quick|skip|ask
+```
+
+### Thresholds
+
+| Metric | Default | Description |
+|--------|---------|-------------|
+| `charThreshold` | 2000 | Characters to trigger gate |
+| `lineThreshold` | 50 | Lines to trigger gate |
+
+### When Gate Triggers
+
+The gate activates when input exceeds **either** threshold, then classifies content to determine action.
+
+---
+
+## Content Classification
+<!-- PIN: content-classification -->
+
+The system auto-detects content type using pattern matching:
+
+| Type | Patterns Detected |
+|------|-------------------|
+| `transcript` | Meeting notes, speaker labels, timestamps |
+| `spec` | PRD language, "must/shall/should", acceptance criteria |
+| `requirements` | Feature requests, user stories, "as a...I want..." |
+| `code` | Import statements, syntax patterns, file extensions |
+
+---
+
+## Processing Modes
+<!-- PIN: processing-modes -->
+
+| Mode | Description | When Used |
+|------|-------------|-----------|
+| `full` | Complete 4-pass extraction with clarifications | Transcripts, specs, requirements |
+| `quick` | Fast single-pass scan | Unknown content types |
+| `skip` | No extraction | Code content |
+| `ask` | Prompt user to choose | When `smartDefault` is disabled |
+
+### The 4-Pass Algorithm (Full Mode)
+
+1. **Pass 1: Topic Extraction** - Identify distinct features/themes
+2. **Pass 2: Statement Association** - Map every statement to a topic
+3. **Pass 3: Orphan Check** - Find unmapped statements, ensure 100% coverage
+4. **Pass 4: Contradiction Resolution** - Detect mind-changes, ask for clarification
+
+---
+
+## Configuration
+
+```json
+{
+  "longInputGate": {
+    "enabled": true,
+    "charThreshold": 2000,
+    "lineThreshold": 50,
+    "smartDefault": true,
+    "contentRules": {
+      "transcript": "full",
+      "spec": "full",
+      "requirements": "full",
+      "code": "skip",
+      "default": "quick"
+    },
+    "supportedLanguages": ["en", "uk", "ru", "he"]
+  }
+}
+```
+
+---
+
+## Integration with Voice Input
+
+Voice recordings flow through the system as:
+
+```
+Voice Recording → Task Creation → Long Input Gate → Processing
+```
+
+Not directly to processing - the gate decides based on content.
+
+---
+
+## Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `flow-long-input.js` | Main processing logic |
+| `flow-long-input-chunking.js` | Handle large inputs via chunking |
+| `flow-long-input-language.js` | Multi-language support |
+| `flow-long-input-parsing.js` | VTT/SRT/transcript parsing |
+| `flow-long-input-stories.js` | Story generation from extracted requirements |
+| `hooks/core/long-input-gate.js` | Gate hook for automatic detection |
+
+---
+
+## Migration from transcript-digestion
+<!-- PIN: migration -->
+
+The old `/transcript-digestion` skill has been replaced with automatic detection:
+
+| Old | New |
+|-----|-----|
+| `/transcript-digestion` command | Automatic via long-input-gate |
+| `transcriptDigestion` config | `longInputGate` config |
+| Skill-based invocation | Hook-based detection |
+| `.claude/skills/transcript-digestion/` | (deleted) |
+
+### Migration Steps
+
+If upgrading from an older version:
+
+1. **Update config**: Rename `transcriptDigestion` → `longInputGate` in `.workflow/config.json`
+2. **Remove old skill**: Delete `.claude/skills/transcript-digestion/` if it exists
+3. **Remove from installed**: Remove `transcript-digestion` from `skills.installed` array
+4. **No action needed**: The new system is automatic - no slash command needed
+
+### Backward Compatibility
+
+The system will recognize the old `transcriptDigestion` config key and warn about migration, but new installations should use `longInputGate`.
+
+---
+
+## Related
+
+- [Voice Input](../05-development-tools/voice-input.md) - Recording transcripts
+- [Task Execution](../02-task-execution/02-execution-loop.md) - How tasks flow through gates
+
+---
+
+Last updated: 2026-01-14

package/.claude/docs/knowledge-base/03-self-improvement/model-learning.md

@@ -0,0 +1,334 @@
+# Model-Level Learning
+
+Per-model optimization, adapters, and error pattern learning.
+
+---
+
+## Overview
+
+Different LLMs have different behaviors:
+- Claude excels at reasoning
+- Local models may struggle with complex types
+- Some models output markdown when code is expected
+
+Model adapters learn these behaviors and optimize prompts accordingly.
+
+---
+
+## Configuration
+
+```json
+{
+  "modelAdapters": {
+    "enabled": true,
+    "autoLearn": true,
+    "directory": ".workflow/model-adapters"
+  }
+}
+```
+
+---
+
+## Model Adapter Structure
+
+```
+.workflow/model-adapters/
+├── claude-sonnet.json
+├── qwen3-coder.json
+├── gpt-4o-mini.json
+└── llama-3.json
+```
+
+### Adapter Content
+
+```json
+{
+  "modelId": "qwen3-coder",
+  "lastUpdated": "2024-01-15T10:30:00Z",
+  "stats": {
+    "totalRequests": 150,
+    "successRate": 0.87,
+    "avgRetries": 1.3
+  },
+  "behaviors": {
+    "outputFormat": {
+      "tendency": "markdown-wrapped",
+      "adjustment": "Specify: Output ONLY code, no markdown"
+    },
+    "typeHandling": {
+      "tendency": "struggles-with-generics",
+      "adjustment": "Simplify complex types in prompt"
+    }
+  },
+  "errorPatterns": [
+    {
+      "signature": "unexpected-markdown",
+      "frequency": 23,
+      "recovery": "strip-markdown-fences"
+    },
+    {
+      "signature": "import-not-found",
+      "frequency": 15,
+      "recovery": "provide-import-paths"
+    }
+  ],
+  "promptAdjustments": {
+    "prefix": "Output ONLY TypeScript code. No explanations.",
+    "suffix": "",
+    "temperature": 0.5
+  }
+}
+```
+
+---
+
+## Auto-Learning
+
+When `autoLearn` is enabled:
+
+```
+Request to LLM
+      ↓
+Success/Failure recorded
+      ↓
+┌─────────────────────────────────────────┐
+│ Analyze error patterns                  │
+│ - Same error 3+ times?                 │
+│ - Known fix available?                  │
+│ - Prompt adjustment helps?              │
+└─────────────────────────────────────────┘
+      ↓
+Update model adapter
+      ↓
+Apply learnings to future requests
+```
+
+---
+
+## Error Categories
+
+| Category | Description | Recovery |
+|----------|-------------|----------|
+| `import` | Import path errors | Provide explicit paths |
+| `type` | Type mismatches | Simplify types |
+| `syntax` | Markdown in output | Strip formatting |
+| `runtime` | Logic errors | Add validation |
+| `unknown` | Unclassified | Log for analysis |
+
+---
+
+## Adaptive Learning
+
+From `flow-adaptive-learning.js`:
+
+### Error Analysis
+
+```javascript
+analyzeFailure(error, context) {
+  // Categorize the error
+  // Extract signature
+  // Check against known patterns
+  // Suggest recovery strategy
+}
+```
+
+### Prompt Refinement
+
+```javascript
+refinePromptForRetry(originalPrompt, errorHistory) {
+  // Learn from failure pattern
+  // Adjust prompt for retry
+  // Apply model-specific fixes
+}
+```
+
+### Success Recording
+
+```javascript
+recordSuccessfulRecovery(modelId, errorSignature, recoveryStrategy) {
+  // Track what worked
+  // Update adapter with learning
+  // Improve future success rate
+}
+```
+
+---
+
+## Prompt Adjustments
+
+Model adapters can modify prompts:
+
+### Prefix Adjustments
+
+```json
+{
+  "promptAdjustments": {
+    "prefix": "You are a code generator. Output ONLY valid TypeScript code."
+  }
+}
+```
+
+### Temperature Adjustments
+
+```json
+{
+  "promptAdjustments": {
+    "temperature": 0.3    // Lower for more deterministic output
+  }
+}
+```
+
+### Context Window
+
+```json
+{
+  "promptAdjustments": {
+    "maxContextTokens": 4096    // Limit for smaller models
+  }
+}
+```
+
+---
+
+## Recovery Strategies
+
+When errors occur, adapters suggest recovery:
+
+### Markdown Stripping
+
+For models that wrap code in markdown:
+```javascript
+if (errorCategory === 'syntax' && signature === 'unexpected-markdown') {
+  // Strip ```typescript and ``` fences
+  code = code.replace(/```\w*\n?/g, '');
+}
+```
+
+### Import Path Resolution
+
+For import errors:
+```javascript
+if (errorCategory === 'import') {
+  // Provide explicit import map in retry prompt
+  prompt += `\n\nAvailable imports:\n${formatImportMap()}`;
+}
+```
+
+### Type Simplification
+
+For type errors:
+```javascript
+if (errorCategory === 'type') {
+  // Simplify generic types in prompt
+  prompt = simplifyTypes(prompt);
+}
+```
+
+---
+
+## Hybrid Mode Integration
+
+Model adapters are crucial for hybrid mode:
+
+```json
+{
+  "hybrid": {
+    "planner": {
+      "adaptToExecutor": true,         // Use adapter knowledge
+      "useAdapterKnowledge": true
+    }
+  }
+}
+```
+
+### How It Works
+
+1. **Plan Creation**: Claude creates detailed plan
+2. **Adapter Lookup**: Find adapter for executor model
+3. **Prompt Adjustment**: Apply model-specific modifications
+4. **Execution**: Send optimized prompt to local LLM
+5. **Error Handling**: Use adapter's recovery strategies
+6. **Learning**: Record outcomes for future improvement
+
+---
+
+## Statistics Tracking
+
+```json
+{
+  "stats": {
+    "totalRequests": 150,
+    "successRate": 0.87,
+    "avgRetries": 1.3,
+    "errorBreakdown": {
+      "import": 15,
+      "type": 8,
+      "syntax": 23,
+      "runtime": 4
+    }
+  }
+}
+```
+
+Used for:
+- Identifying problematic patterns
+- Measuring improvement over time
+- Choosing best model for task type
+
+---
+
+## Manual Adapter Configuration
+
+Create custom adapter:
+
+```bash
+cat > .workflow/model-adapters/custom-model.json << 'EOF'
+{
+  "modelId": "custom-model",
+  "behaviors": {
+    "outputFormat": {
+      "tendency": "verbose-explanations",
+      "adjustment": "Be concise. Code only."
+    }
+  },
+  "promptAdjustments": {
+    "prefix": "You are a TypeScript expert. Output clean, typed code.",
+    "temperature": 0.4
+  }
+}
+EOF
+```
+
+---
+
+## Viewing Model Performance
+
+```bash
+# Check adapter stats
+cat .workflow/model-adapters/qwen3-coder.json | jq '.stats'
+
+# Output:
+# {
+#   "totalRequests": 150,
+#   "successRate": 0.87,
+#   "avgRetries": 1.3
+# }
+```
+
+---
+
+## Best Practices
+
+1. **Let Auto-Learn Work**: Don't manually edit adapters frequently
+2. **Review Error Patterns**: Check what's failing most
+3. **Test Different Models**: Some models work better for certain tasks
+4. **Lower Temperature**: For code generation, 0.3-0.5 is often better
+5. **Provide Clear Examples**: Models learn from explicit patterns
+
+---
+
+## Related
+
+- [Project Learning](./project-learning.md) - Project-specific patterns
+- [Skill Learning](./skill-learning.md) - Framework patterns
+- [Hybrid Mode](../02-task-execution/02-execution-loop.md#hybrid-mode)