wogiflow 1.5.9 → 1.5.11

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

@@ -2,6 +2,8 @@
 
 Extract tasks from long input with 100% capture rate and mandatory human review.
 
+**Scope**: This command does NOT modify source code files. It processes input text into structured tasks. All file modifications happen downstream via `/wogi-start`.
+
 ## Purpose
 
 When processing transcripts, meeting notes, or long prompts, this command ensures NOTHING is missed by:
@@ -105,6 +107,8 @@ 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
+4. Final output creates stories in `ready.json` via `/wogi-story`
+5. Each story then executes through the full `/wogi-start` pipeline
 
 ```bash
 # Full flow

package/.claude/commands/wogi-guided-edit.md

@@ -13,6 +13,26 @@ Usage:
 /wogi-guided-edit "update all imports from @old/lib to @new/lib"
 ```
 
+## Task Gating
+
+This command modifies files. It MUST operate within one of these contexts:
+
+1. **Within `/wogi-start`** (preferred): When invoked as part of an active task, the task already exists in `ready.json` inProgress. Proceed directly — task lifecycle is managed by the parent command.
+2. **Standalone invocation**: Before editing files, check `ready.json` for an active inProgress task with `feature: "guided-edit"`. If no guided-edit task exists, create one:
+   ```json
+   {
+     "id": "[call generateTaskId('Guided edit: [description]')]",
+     "title": "Guided edit: [description]",
+     "type": "fix",
+     "feature": "guided-edit",
+     "status": "in_progress",
+     "priority": "P2",
+     "createdAt": "[ISO timestamp]",
+     "startedAt": "[ISO timestamp]"
+   }
+   ```
+   Add to `ready.json` inProgress before any file modifications. Store the task ID in the session file for cleanup.
+
 ## Workflow
 
 1. **Analyze**: Find all files affected by the change
@@ -22,7 +42,21 @@ Usage:
    - Show proposed diff (if replace operation)
    - User: approve / reject / skip
 4. **Apply**: Make approved changes
+   - **After each file edit**, validate by file type:
+     - `.js` files: `node --check <file>` + ESLint
+     - `.ts`/`.tsx` files: `npx tsc --noEmit` + ESLint
+     - `.json` files: JSON parse check
+     - Other types: skip validation
+   - Do NOT proceed to next file until current file passes validation
 5. **Summary**: Show completion stats
+6. **Complete task** (standalone invocation only): If a guided-edit task was created in step 2, move it from inProgress to recentlyCompleted in `ready.json`. If running within `/wogi-start` (case 1), skip — the parent command manages task lifecycle.
+
+## Abort Handling
+
+When the user issues `abort`/`q`, or the session is abandoned mid-edit:
+1. Move the guided-edit task from inProgress to recentlyCompleted with a note: "Aborted after N/M files"
+2. The session file (`.workflow/state/guided-edit-session.json`) retains progress for potential resume
+3. Do NOT leave tasks stuck in inProgress — always clean up on exit
 
 ## Commands During Session
 

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

@@ -1,36 +1,99 @@
 ---
-description: Edit the current execution plan before running
+description: View and edit the current hybrid execution plan
 ---
 
-# Edit Hybrid Plan
+# Edit Hybrid Execution Plan
 
-Show me the current plan and what you'd like to change.
+View the current execution plan and modify steps before running.
 
-## Current Plan
+## Step 1: Load Current Plan
 
 ```bash
 if [ -f ".workflow/state/current-plan.json" ]; then
-    jq '.' .workflow/state/current-plan.json
+    echo "═══════════════════════════════════════════════════════════"
+    echo "              CURRENT EXECUTION PLAN"
+    echo "═══════════════════════════════════════════════════════════"
+    echo ""
+    jq -r '
+      "Task: \(.taskId // "unknown")",
+      "Executor: \(.executor // "not set")",
+      "Steps: \(.steps | length)",
+      "",
+      (.steps | to_entries[] | "  Step \(.key + 1): [\(.value.status // "pending")] \(.value.description // "unnamed")\n    Model: \(.value.model // "default")\n    Files: \(.value.files // [] | join(", "))\n")
+    ' .workflow/state/current-plan.json
+    echo "═══════════════════════════════════════════════════════════"
 else
-    echo "No plan currently loaded"
+    echo ""
+    echo "No active execution plan."
+    echo ""
+    echo "A plan is created when you start a task with hybrid mode enabled."
+    echo "Use /wogi-hybrid to enable hybrid mode first, then /wogi-start a task."
+    echo ""
 fi
 ```
 
 ## Edit Options
 
-Tell me what you'd like to change:
+If a plan exists, tell me what you'd like to change:
 
-1. **Add a step** - Describe what you want to add
-2. **Remove a step** - Tell me which step number to remove
-3. **Modify a step** - Tell me which step and what to change
-4. **Reorder steps** - Specify the new order
-5. **Change execution mode** - Mark steps as parallel/sequential
+### Modify Steps
+1. **Add a step** — "Add a step to create unit tests after step 3"
+2. **Remove a step** — "Remove step 4, I'll handle that manually"
+3. **Modify a step** — "Change step 2 to use React Hook Form instead"
+4. **Reorder steps** — "Move step 5 before step 3"
+
+### Change Execution
+5. **Change model for a step** — "Use Sonnet for step 3 instead of Haiku"
+6. **Change model for all** — "Use GPT-4o-mini for all remaining steps"
+7. **Mark step as manual** — "I'll do step 4 myself, skip it"
+8. **Change to parallel** — "Run steps 2 and 3 in parallel"
+
+### Plan Management
+9. **Save plan** — Save current plan to reuse later
+10. **Discard plan** — Cancel execution and discard plan
+11. **Reset plan** — Regenerate plan from task spec
+
+## How Plan Editing Works
+
+When you request a change:
+1. I read the current plan from `.workflow/state/current-plan.json`
+2. Apply your modifications
+3. Show the updated plan for confirmation
+4. Save the updated plan
+5. Execution continues from where it left off
+
+## Plan File Format
+
+Plans are stored at `.workflow/state/current-plan.json`:
+
+```json
+{
+  "taskId": "wf-XXXXXXXX",
+  "executor": "claude-3-5-haiku-latest",
+  "routing": "smart",
+  "createdAt": "ISO timestamp",
+  "steps": [
+    {
+      "id": 1,
+      "description": "Create UserCard component",
+      "model": "claude-3-5-sonnet-latest",
+      "status": "pending",
+      "files": ["src/components/UserCard.tsx"],
+      "context": "Template + patterns from app-map",
+      "verification": ["lint", "typecheck"]
+    }
+  ]
+}
+```
 
 ## Example Requests
 
-- "Add a step to create unit tests after the service"
-- "Remove step 3, I'll handle that manually"
-- "Change step 2 to use React Hook Form instead"
-- "Make steps 1-3 run in parallel"
+```
+"Add a step to create unit tests after the service"
+"Remove step 3, I'll handle that manually"
+"Change step 2 to use Sonnet instead of Haiku"
+"Make steps 1-3 run in parallel"
+"Use GPT-4o-mini for all documentation steps"
+```
 
 What would you like to change?

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

@@ -1,24 +1,39 @@
 ---
-description: Disable hybrid mode and return to normal operation
+description: Disable hybrid mode and return to direct Opus execution
 ---
 
 # Disable Hybrid Mode
 
-Turning off hybrid mode. I'll go back to executing everything directly.
+Turning off multi-model hybrid execution. All tasks will be executed directly by Opus.
 
 ```bash
 # Update config
-cd "$(pwd)" && cat .workflow/config.json | jq '.hybrid.enabled = false' > /tmp/config.tmp && mv /tmp/config.tmp .workflow/config.json
+cd "$(pwd)" && jq '.hybrid.enabled = false' .workflow/config.json > /tmp/wogi-config-tmp.json && mv /tmp/wogi-config-tmp.json .workflow/config.json
 
-echo "✅ Hybrid mode disabled"
+# Clean up session state
+if [ -f ".workflow/state/current-plan.json" ]; then
+    rm .workflow/state/current-plan.json
+    echo "Removed active execution plan"
+fi
+
+echo "Hybrid mode disabled"
 ```
 
 ## What Changes
 
-- I'll write code directly instead of creating plans
-- All execution happens via Claude (no local LLM)
-- No token savings, but simpler workflow
+- All tasks are executed directly by Opus (no delegation to cheaper models)
+- No execution plans are created — code is written directly
+- No token savings from multi-model routing
+- Simpler workflow, but higher token usage
+
+## Your Configuration Is Preserved
+
+- Cloud provider API keys remain configured
+- Local LLM connections remain saved
+- Smart routing rules remain in config
+- Project templates remain generated
 
 ## Re-enabling
 
-Run `/wogi-hybrid` to enable again with your previous settings.
+Run `/wogi-hybrid` to re-enable with your previous settings.
+Run `/wogi-hybrid-setup` to reconfigure from scratch.

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

@@ -1,79 +1,122 @@
 ---
-description: Set up hybrid mode - generates templates and configures local LLM
+description: Set up hybrid mode - configure executor models for multi-model execution
 ---
 
 # Hybrid Mode Setup
 
-This command sets up everything needed for hybrid mode in your project.
+This command sets up everything needed for multi-model hybrid execution in your project.
 
-## Step 1: Generate Project Templates
+## Step 1: Choose Executor Type
 
-Analyzing your codebase and generating customized templates:
+### Cloud Models (Recommended — Easiest Setup)
+
+If you have API keys for any of these providers, hybrid mode works immediately:
+
+| Provider | Cheapest Model | Mid-tier Model | Env Variable |
+|----------|---------------|----------------|--------------|
+| Anthropic | Claude 3.5 Haiku | Claude 3.5 Sonnet | `ANTHROPIC_API_KEY` |
+| OpenAI | GPT-4o-mini | GPT-4o | `OPENAI_API_KEY` |
+| Google | Gemini 2.0 Flash | Gemini 1.5 Pro | `GOOGLE_API_KEY` |
+
+**Quick setup**: If you already have `ANTHROPIC_API_KEY` set (which you do if you use Claude Code), Haiku and Sonnet are ready to use as executors.
 
+### Local Models (Free Tokens)
+
+For local LLM execution, you need Ollama or LM Studio running:
+
+**Ollama:**
 ```bash
-node scripts/flow-templates.js generate
+ollama serve
+ollama pull qwen3-coder  # or your preferred model
 ```
 
-## Step 2: Enable Hybrid Mode
+**LM Studio:**
+- Open the app → Download a model → Start the local server
+
+### Mixed Setup (Best of Both)
 
-Running the interactive setup wizard to configure your local LLM:
+Configure both local and cloud models. Hybrid mode will select the best executor based on task type:
+- Simple edits → Local LLM (free) or Haiku (cheapest cloud)
+- Code generation → Sonnet or GPT-4o (mid-tier cloud)
+- Complex work → Keep on Opus (no delegation)
+
+## Step 2: Generate Project Templates
+
+Analyzing your codebase and generating customized templates:
 
 ```bash
-node scripts/flow-hybrid-interactive.js
+node scripts/flow-templates.js generate
 ```
 
-## What This Does
+This creates templates in `templates/hybrid/` that teach executor models your project's patterns.
 
-1. **Analyzes your project**
-   - Detects framework (React, Next.js, Vue, Angular, etc.)
-   - Detects state management (Zustand, Redux, MobX, etc.)
-   - Detects styling (Tailwind, Styled Components, etc.)
-   - Finds code examples from your components, hooks, services
+## Step 3: Configure Hybrid Mode
 
-2. **Generates templates** in `templates/hybrid/`
-   - `_base.md` - Universal rules for your stack
-   - `_patterns.md` - Your actual coding patterns
-   - Task-specific templates (create-component, create-hook, etc.)
+### Option A: Use Unified Model Setup (Recommended)
 
-3. **Configures local LLM**
-   - Detects Ollama and/or LM Studio
-   - Lists available models
-   - Tests the connection
-   - Saves configuration to `config.json`
+Configures all your models in one place:
 
-4. **Uses durable session system**
-   - Session state tracked in `durable-history.json`
+```
+/wogi-models-setup
+```
 
-## Requirements
+### Option B: Interactive Setup
 
-Before running, ensure you have a local LLM running:
+Runs the hybrid-specific setup wizard:
 
-**Ollama:**
 ```bash
-ollama serve
-ollama pull nemotron-3-nano  # or your preferred model
+node scripts/flow-hybrid-interactive.js
 ```
 
-**LM Studio:**
-- Open the app
-- Download a model
-- Start the local server
+## Step 4: Configure Smart Routing (Optional)
+
+Edit `config.json → hybrid.routing` to customize which models handle which task types:
+
+```json
+{
+  "hybrid": {
+    "routing": {
+      "enabled": true,
+      "rules": [
+        { "taskType": "simple-edit", "model": "cheapest" },
+        { "taskType": "code-generation", "model": "mid-tier" },
+        { "taskType": "refactoring", "model": "planner" },
+        { "taskType": "documentation", "model": "cheapest" }
+      ],
+      "tiers": {
+        "cheapest": ["claude-3-5-haiku-latest", "gpt-4o-mini", "gemini-2.0-flash-exp"],
+        "mid-tier": ["claude-3-5-sonnet-latest", "gpt-4o", "gemini-1.5-pro"],
+        "planner": "current"
+      }
+    }
+  }
+}
+```
+
+## What This Does
+
+1. **Analyzes your project** — Detects framework, state management, styling
+2. **Generates templates** — Customized task templates in `templates/hybrid/`
+3. **Configures executor(s)** — Sets up cloud and/or local model connections
+4. **Tests connections** — Verifies executor models respond correctly
+5. **Enables routing** — Configures smart model selection based on task type
 
 ## After Setup
 
 Use these commands:
-- `/wogi-hybrid-status` - Check configuration
-- `/wogi-hybrid-off` - Disable hybrid mode
-- `/wogi-hybrid-edit` - Edit plans before execution
+- `/wogi-hybrid` — Enable hybrid mode and start using it
+- `/wogi-hybrid-status` — Check configuration and routing table
+- `/wogi-hybrid-off` — Disable hybrid mode
+- `/wogi-hybrid-edit` — Edit plans before execution
 
 ## Token Savings
 
-| Task Size | Normal | Hybrid | Savings |
-|-----------|--------|--------|---------|
-| Small | ~8K | ~5K | 35% |
-| Medium | ~20K | ~10K | 50% |
-| Large | ~45K | ~20K | 55% |
+| Task Size | Normal (Opus) | Hybrid (mixed) | Savings |
+|-----------|--------------|----------------|---------|
+| Small | ~8K | ~2K | 75% |
+| Medium | ~20K | ~8K | 60% |
+| Large | ~45K | ~15K | 65% |
 
-*Note: Actual savings vary based on instruction detail needed for quality.*
+*Savings vary based on executor model selection and task complexity.*
 
 Let me set up hybrid mode for your project now...

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

@@ -1,10 +1,10 @@
 ---
-description: Show current hybrid mode configuration
+description: Show current hybrid mode configuration and routing table
 ---
 
 # Hybrid Mode Status
 
-Let me check the current configuration:
+Let me check the current multi-model execution configuration:
 
 ```bash
 echo "═══════════════════════════════════════════════════════════"
@@ -18,28 +18,58 @@ echo "Status: $ENABLED"
 
 if [ "$ENABLED" = "true" ]; then
     echo ""
-    echo "Configuration:"
-    jq '.hybrid' .workflow/config.json
+    echo "── Executor Configuration ──"
+    EXEC_TYPE=$(jq -r '.hybrid.executor.type // "not set"' .workflow/config.json)
+    EXEC_MODEL=$(jq -r '.hybrid.executor.model // "not set"' .workflow/config.json)
+    echo "  Type: $EXEC_TYPE"
+    echo "  Model: $EXEC_MODEL"
 
     echo ""
-    echo "Testing connection..."
-    node scripts/flow-hybrid-detect.js providers
+    echo "── Smart Routing ──"
+    ROUTING_ENABLED=$(jq -r '.hybrid.routing.enabled // false' .workflow/config.json)
+    echo "  Routing enabled: $ROUTING_ENABLED"
+    if [ "$ROUTING_ENABLED" = "true" ]; then
+        echo ""
+        echo "  Task Type Routing:"
+        jq -r '.hybrid.routing.rules[]? | "    \(.taskType) → \(.model) (\(.description // ""))"' .workflow/config.json
+        echo ""
+        echo "  Model Tiers:"
+        echo "    Cheapest: $(jq -r '.hybrid.routing.tiers.cheapest // [] | join(", ")' .workflow/config.json)"
+        echo "    Mid-tier: $(jq -r '.hybrid.routing.tiers["mid-tier"] // [] | join(", ")' .workflow/config.json)"
+        echo "    Planner:  $(jq -r '.hybrid.routing.tiers.planner // "current"' .workflow/config.json)"
+    fi
+
+    echo ""
+    echo "── Cloud Providers ──"
+    jq -r '.hybrid.cloudProviders | to_entries[] | "  \(.key): \(.value.models | join(", ")) [env: \(.value.envKey)]"' .workflow/config.json
 
     echo ""
-    echo "Session state:"
-    # Use durable session (v2.0) - check durable-history.json for active sessions
+    echo "── Local Providers ──"
+    echo "  Checking..."
+    node scripts/flow-hybrid-detect.js providers 2>/dev/null | jq -r '.[] | "  \(.name): \(if .available then "✓ available (\(.models | length) models)" else "✗ not running" end)"' 2>/dev/null || echo "  Detection unavailable"
+
+    echo ""
+    echo "── Session State ──"
     if [ -f ".workflow/state/durable-history.json" ]; then
-        ACTIVE=$(jq -r '.activeSession // empty' .workflow/state/durable-history.json)
+        ACTIVE=$(jq -r '.activeSession // empty' .workflow/state/durable-history.json 2>/dev/null)
         if [ -n "$ACTIVE" ] && [ "$ACTIVE" != "null" ]; then
             jq '.activeSession' .workflow/state/durable-history.json
         else
-            echo "No active session"
+            echo "  No active session"
         fi
     else
-        echo "No durable session history"
+        echo "  No durable session history"
     fi
 fi
 
 echo ""
 echo "═══════════════════════════════════════════════════════════"
 ```
+
+## Quick Actions
+
+- `/wogi-hybrid` — Enable hybrid mode
+- `/wogi-hybrid-setup` — Run setup wizard
+- `/wogi-hybrid-edit` — Edit current execution plan
+- `/wogi-hybrid-off` — Disable hybrid mode
+- `/wogi-hybrid --select-model` — Change executor model