wogiflow 1.0.31 → 1.0.32

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

@@ -14,14 +14,40 @@ Let me check what's available on your system:
 node scripts/flow-hybrid-detect.js providers
 ```
 
-## Step 2: Interactive Setup
+## Step 2: Choose Setup Method
 
-Running the interactive setup wizard:
+### Option A: Use Unified Model Setup (Recommended)
+
+If you want to configure multiple providers at once (for both hybrid and peer review):
+
+```
+/wogi-models-setup
+```
+
+This configures all your models in one place.
+
+### Option B: Hybrid-Specific Setup
+
+For hybrid-specific configuration only:
 
 ```bash
 node scripts/flow-hybrid-interactive.js
 ```
 
+### Model Selection
+
+If models are already configured (via `/wogi-models-setup`), you can select which one to use:
+
+```javascript
+const modelConfig = require('./scripts/flow-model-config');
+const models = modelConfig.getEnabledModels();
+
+// Show selection if multiple models available
+if (models.length > 1) {
+  // Use AskUserQuestion to let user select
+}
+```
+
 ## How Hybrid Mode Works
 
 1. **You give me a task** - "Add user authentication"

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

@@ -0,0 +1,254 @@
+Configure external models for WogiFlow features (peer review, hybrid mode).
+
+## Overview
+
+This wizard helps you set up external LLM providers:
+- **OpenAI** (GPT-4o, o1)
+- **Google** (Gemini)
+- **Anthropic** (Claude - for peer review)
+- **Local LLM** (Ollama, LM Studio)
+
+Configured models are shared between:
+- `/wogi-peer-review` - Multi-model code review
+- `/wogi-hybrid` - Local/cloud execution mode
+
+## Setup Flow
+
+### Step 1: Provider Selection
+
+Use AskUserQuestion to let user select which providers to configure:
+
+```javascript
+{
+  question: "Which AI providers do you want to configure?",
+  header: "Providers",
+  multiSelect: true,
+  options: [
+    { label: "OpenAI", description: "GPT-4o, GPT-4o-mini, o1 models" },
+    { label: "Google (Gemini)", description: "Gemini 2.0 Flash, Gemini Pro" },
+    { label: "Anthropic", description: "Claude models (for peer review comparison)" },
+    { label: "Local LLM", description: "Ollama or LM Studio (free, runs on your machine)" }
+  ]
+}
+```
+
+### Step 2: Configure Each Selected Provider
+
+For each selected provider, run the appropriate setup:
+
+#### OpenAI Setup
+
+1. Ask for API key:
+   ```
+   Please paste your OpenAI API key (starts with sk-):
+   ```
+
+2. Test connection:
+   ```bash
+   node -e "require('./scripts/flow-model-config').testProviderConnection('openai').then(r => console.log(JSON.stringify(r)))"
+   ```
+
+3. If successful, ask which models to enable:
+   ```javascript
+   {
+     question: "Which OpenAI models do you want to enable?",
+     header: "OpenAI Models",
+     multiSelect: true,
+     options: [
+       { label: "gpt-4o (Recommended)", description: "Best quality, good speed" },
+       { label: "gpt-4o-mini", description: "Faster, cheaper, still capable" },
+       { label: "o1-mini", description: "Advanced reasoning, slower" }
+     ]
+   }
+   ```
+
+4. Save configuration:
+   ```javascript
+   const modelConfig = require('./scripts/flow-model-config');
+   modelConfig.addProvider('openai', {
+     apiKey: userProvidedKey,
+     models: selectedModels
+   });
+   ```
+
+#### Google (Gemini) Setup
+
+1. Ask for API key:
+   ```
+   Please paste your Google AI API key (get one at https://aistudio.google.com/apikey):
+   ```
+
+2. Test and select models (similar to OpenAI):
+   - gemini-2.0-flash-exp (Recommended)
+   - gemini-1.5-flash
+   - gemini-1.5-pro
+
+#### Anthropic Setup
+
+1. Ask for API key:
+   ```
+   Please paste your Anthropic API key (starts with sk-ant-):
+   ```
+
+2. Select models:
+   - claude-sonnet-4 (Recommended)
+   - claude-3-5-haiku
+   - claude-opus-4
+
+Note: Anthropic models are mainly useful for peer review to get different perspectives.
+
+#### Local LLM Setup
+
+1. Auto-detect local providers:
+   ```bash
+   # Test Ollama
+   curl -s http://localhost:11434/api/tags 2>/dev/null | head -1
+
+   # Test LM Studio
+   curl -s http://localhost:1234/v1/models 2>/dev/null | head -1
+   ```
+
+2. If detected, list available models and let user select.
+
+3. If not detected, show instructions:
+   ```
+   No local LLM detected. To use local models:
+
+   Option 1: Install Ollama
+     1. Visit https://ollama.ai
+     2. Install and run: ollama pull qwen2.5-coder:7b
+     3. Re-run /wogi-models-setup
+
+   Option 2: Install LM Studio
+     1. Visit https://lmstudio.ai
+     2. Download and load a model
+     3. Start the server
+     4. Re-run /wogi-models-setup
+   ```
+
+### Step 3: Set Defaults (Optional)
+
+Ask user about default preferences:
+
+```javascript
+{
+  question: "Which models should be used by default for peer review?",
+  header: "Peer Review Default",
+  multiSelect: true,
+  options: [
+    // Show only configured models
+    { label: "openai:gpt-4o", description: "..." },
+    { label: "google:gemini-2.0-flash", description: "..." }
+  ]
+}
+```
+
+### Step 4: Summary
+
+Display configuration summary:
+
+```
+╔══════════════════════════════════════════════════════════╗
+║  Model Configuration Complete                             ║
+╚══════════════════════════════════════════════════════════╝
+
+Configured Providers:
+  ✓ OpenAI: gpt-4o, gpt-4o-mini
+  ✓ Google: gemini-2.0-flash
+  ✓ Local: qwen2.5-coder (via Ollama)
+
+API Keys stored in: .env
+Config saved to: .workflow/config.json
+
+Default for peer review: gpt-4o, gemini-2.0-flash
+Default for hybrid mode: local:qwen2.5-coder
+
+You can now use:
+  /wogi-review      - Multi-model code review
+  /wogi-hybrid      - Hybrid execution mode
+  /wogi-peer-review - Same as /wogi-review
+```
+
+## Implementation Details
+
+### Config Storage
+
+API keys are stored as environment variable names (not values) in config:
+```json
+{
+  "models": {
+    "providers": {
+      "openai": {
+        "apiKeyEnv": "OPENAI_API_KEY",
+        "enabled": true,
+        "models": ["gpt-4o", "gpt-4o-mini"]
+      }
+    }
+  }
+}
+```
+
+Actual keys go in `.env`:
+```
+OPENAI_API_KEY=sk-proj-...
+GOOGLE_API_KEY=AIza...
+```
+
+### Migration
+
+If old config exists (hybrid.executor or peerReview.apiKeys), migrate automatically:
+```javascript
+const modelConfig = require('./scripts/flow-model-config');
+modelConfig.migrateOldConfig();
+```
+
+### Testing
+
+Test any provider connection:
+```bash
+node scripts/flow-model-config.js test openai
+node scripts/flow-model-config.js test local
+```
+
+## Error Handling
+
+### Invalid API Key
+
+```
+✗ OpenAI connection failed: Invalid API key
+
+Please check your API key and try again.
+You can get a new key at: https://platform.openai.com/api-keys
+```
+
+### No Local LLM
+
+```
+✗ No local LLM detected
+
+Install Ollama (recommended): https://ollama.ai
+Then run: ollama pull qwen2.5-coder:7b
+```
+
+### Network Error
+
+```
+✗ Connection failed: Network error
+
+Please check your internet connection and try again.
+```
+
+## Quick Setup (Non-Interactive)
+
+For users who already have API keys set in environment:
+
+```bash
+# If OPENAI_API_KEY is already in environment
+node -e "
+const mc = require('./scripts/flow-model-config');
+if (process.env.OPENAI_API_KEY) {
+  mc.addProvider('openai', { models: ['gpt-4o'] });
+  console.log('OpenAI configured');
+}
+"
+```

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

@@ -1,5 +1,74 @@
 Run a multi-model peer review where different AI models review the same code.
 
+## Step 0: Model Selection (Every Run)
+
+**Before starting the review, check for configured models and let user select:**
+
+### Check Configuration
+
+```javascript
+const modelConfig = require('./scripts/flow-model-config');
+
+// Run migration if needed (handles old config formats)
+modelConfig.migrateOldConfig();
+
+// Get enabled models
+const models = modelConfig.getEnabledModels();
+```
+
+### If No Models Configured
+
+If `models.length === 0`:
+
+```
+No external models configured for peer review.
+
+Run /wogi-models-setup to configure:
+- OpenAI (GPT-4o)
+- Google (Gemini)
+- Local LLM (Ollama)
+
+Or use --manual flag for manual mode.
+```
+
+Then either:
+- Auto-launch `/wogi-models-setup` wizard
+- Or use `--manual` mode if user prefers
+
+### Model Selection Dialog
+
+If models are configured, show selection dialog using AskUserQuestion:
+
+```javascript
+{
+  question: "Select models for peer review (multiple allowed):",
+  header: "Models",
+  multiSelect: true,
+  options: [
+    // Dynamically populated from configured models
+    { label: "openai:gpt-4o", description: "Best quality reasoning" },
+    { label: "openai:gpt-4o-mini", description: "Faster, cheaper" },
+    { label: "google:gemini-2.0-flash", description: "Fast, good at code" },
+    { label: "local:qwen2.5-coder", description: "Free, runs locally" }
+    // ... other configured models
+  ]
+}
+```
+
+**Show only models that:**
+1. Are configured in `models.providers`
+2. Have `enabled: true`
+3. Have API key set (check `process.env[apiKeyEnv]`) or are local
+
+### After Selection
+
+Save the selection for future runs (optional):
+```javascript
+modelConfig.setDefaultModels('peerReview', selectedModels);
+```
+
+Then proceed with the review using selected models.
+
 ## How It Works
 
 1. **Primary model (Claude)** reviews the changes for improvements
@@ -37,41 +106,73 @@ Run a multi-model peer review where different AI models review the same code.
 
 ## Provider Configuration
 
-Configure in `.workflow/config.json` under `peerReview`:
+### Recommended: Use `/wogi-models-setup`
 
-### 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}"
-  }
-}
+The easiest way to configure models is the setup wizard:
+```
+/wogi-models-setup
 ```
 
-### Option B: MCP Integration
+This creates a unified configuration used by both peer review and hybrid mode.
+
+### Config Location
+
+Models are configured in `.workflow/config.json` under `models`:
+
 ```json
-"peerReview": {
-  "enabled": true,
-  "provider": "mcp",
-  "mcpServers": {
-    "openai": "mcp-openai",
-    "google": "mcp-gemini"
+{
+  "models": {
+    "providers": {
+      "openai": {
+        "apiKeyEnv": "OPENAI_API_KEY",
+        "enabled": true,
+        "models": ["gpt-4o", "gpt-4o-mini"]
+      },
+      "google": {
+        "apiKeyEnv": "GOOGLE_API_KEY",
+        "enabled": true,
+        "models": ["gemini-2.0-flash"]
+      },
+      "local": {
+        "endpoint": "http://localhost:11434",
+        "provider": "ollama",
+        "enabled": true,
+        "models": ["qwen2.5-coder"]
+      }
+    },
+    "defaults": {
+      "peerReview": ["openai:gpt-4o", "google:gemini-2.0-flash"]
+    }
   }
 }
 ```
 
-### Option C: Manual Mode
+API keys are stored in `.env` (not in config):
+```
+OPENAI_API_KEY=sk-proj-...
+GOOGLE_API_KEY=AIza...
+```
+
+### Legacy Config (Auto-Migrated)
+
+Old format configs are automatically migrated on first use:
 ```json
+// Old format (still supported, auto-migrates)
 "peerReview": {
-  "enabled": true,
-  "provider": "manual"
+  "apiKeys": {
+    "openai": "${OPENAI_API_KEY}"
+  },
+  "models": ["openai:gpt-4o"]
 }
 ```
 
+### Manual Mode
+
+For manual review (no API keys needed):
+```
+/wogi-peer-review --manual
+```
+
 When manual:
 1. Outputs the review prompt
 2. User runs in Cursor/other tool

package/package.json

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

package/scripts/flow-model-caller.js

@@ -260,9 +260,34 @@ async function callModel(modelString, prompt, options = {}) {
 
 /**
  * Get list of configured models for peer review
+ * Checks unified config first, falls back to legacy peerReview config
  */
 function getConfiguredModels() {
   const config = getConfig();
+
+  // Check unified models config first (new format)
+  if (config.models?.providers) {
+    const models = [];
+    for (const [provider, providerConfig] of Object.entries(config.models.providers)) {
+      if (providerConfig.enabled !== false && providerConfig.models?.length > 0) {
+        // Check if API key is available (or local provider)
+        const apiKeyEnv = providerConfig.apiKeyEnv;
+        const hasApiKey = !apiKeyEnv || process.env[apiKeyEnv];
+
+        if (hasApiKey || provider === 'local') {
+          for (const model of providerConfig.models) {
+            models.push(`${provider}:${model}`);
+          }
+        }
+      }
+    }
+
+    if (models.length > 0) {
+      return models;
+    }
+  }
+
+  // Fall back to legacy peerReview config
   const peerReviewConfig = config.peerReview || {};
 
   if (peerReviewConfig.models && Array.isArray(peerReviewConfig.models)) {
@@ -274,6 +299,7 @@ function getConfiguredModels() {
 
 /**
  * Check if model calling is available
+ * Checks unified config first, falls back to legacy peerReview config
  */
 function isModelCallingAvailable() {
   const config = getConfig();
@@ -284,7 +310,25 @@ function isModelCallingAvailable() {
     return { available: false, reason: 'Manual mode configured' };
   }
 
-  // Check for at least one API key
+  // Check unified config first
+  if (config.models?.providers) {
+    for (const [provider, providerConfig] of Object.entries(config.models.providers)) {
+      if (providerConfig.enabled !== false) {
+        // Local providers don't need API keys
+        if (provider === 'local') {
+          return { available: true };
+        }
+
+        // Cloud providers need API keys
+        const apiKeyEnv = providerConfig.apiKeyEnv;
+        if (apiKeyEnv && process.env[apiKeyEnv]) {
+          return { available: true };
+        }
+      }
+    }
+  }
+
+  // Fall back to legacy peerReview config
   const models = getConfiguredModels();
 
   for (const modelStr of models) {
@@ -301,7 +345,7 @@ function isModelCallingAvailable() {
 
   return {
     available: false,
-    reason: 'No API keys configured. Set environment variables or configure in peerReview.apiKeys'
+    reason: 'No models configured. Run /wogi-models-setup to configure external models.'
   };
 }
 

package/scripts/flow-model-config.js

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Unified Model Configuration
+ *
+ * Centralized model and API key management for all WogiFlow features:
+ * - Hybrid mode (local LLM execution)
+ * - Peer review (multi-model code review)
+ * - Model routing (task-based model selection)
+ *
+ * Config structure in .workflow/config.json:
+ * {
+ *   "models": {
+ *     "providers": {
+ *       "openai": { "apiKeyEnv": "OPENAI_API_KEY", "enabled": true, "models": ["gpt-4o"] },
+ *       "google": { "apiKeyEnv": "GOOGLE_API_KEY", "enabled": true, "models": ["gemini-2.0-flash"] },
+ *       ...
+ *     },
+ *     "defaults": {
+ *       "hybrid": "local:qwen2.5-coder",
+ *       "peerReview": ["openai:gpt-4o", "google:gemini-2.0-flash"]
+ *     }
+ *   }
+ * }
+ *
+ * Usage:
+ *   const modelConfig = require('./flow-model-config');
+ *   const models = modelConfig.getEnabledModels();
+ *   await modelConfig.addProvider('openai', { apiKey: 'sk-...' });
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getProjectRoot, safeJsonParse, colors: c } = require('./flow-utils');
+
+const PROJECT_ROOT = getProjectRoot();
+const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
+const CONFIG_PATH = path.join(WORKFLOW_DIR, 'config.json');
+const ENV_PATH = path.join(PROJECT_ROOT, '.env');
+
+/**
+ * Known provider configurations
+ */
+const KNOWN_PROVIDERS = {
+  openai: {
+    displayName: 'OpenAI',
+    envKey: 'OPENAI_API_KEY',
+    endpoint: 'https://api.openai.com/v1',
+    testEndpoint: '/models',
+    models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-mini', 'o1-preview'],
+    defaultModel: 'gpt-4o'
+  },
+  google: {
+    displayName: 'Google (Gemini)',
+    envKey: 'GOOGLE_API_KEY',
+    endpoint: 'https://generativelanguage.googleapis.com/v1beta',
+    testEndpoint: '/models',
+    models: ['gemini-2.0-flash-exp', 'gemini-1.5-flash', 'gemini-1.5-pro', 'gemini-pro'],
+    defaultModel: 'gemini-2.0-flash-exp'
+  },
+  anthropic: {
+    displayName: 'Anthropic',
+    envKey: 'ANTHROPIC_API_KEY',
+    endpoint: 'https://api.anthropic.com/v1',
+    testEndpoint: '/messages',
+    models: ['claude-sonnet-4-20250514', 'claude-3-5-haiku-20241022', 'claude-opus-4-20250514'],
+    defaultModel: 'claude-sonnet-4-20250514'
+  },
+  local: {
+    displayName: 'Local LLM',
+    envKey: null, // No API key needed
+    endpoint: 'http://localhost:11434',
+    testEndpoint: '/api/tags',
+    models: [], // Detected at runtime
+    defaultModel: null,
+    subProviders: ['ollama', 'lmstudio']
+  }
+};
+
+/**
+ * Read config file
+ * @returns {Object} Config object
+ */
+function readConfig() {
+  return safeJsonParse(CONFIG_PATH, {});
+}
+
+/**
+ * Write config file
+ * @param {Object} config - Config to write
+ */
+function writeConfig(config) {
+  fs.mkdirSync(WORKFLOW_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Get the models configuration section
+ * @returns {Object} Models config or empty structure
+ */
+function getModelsConfig() {
+  const config = readConfig();
+  return config.models || { providers: {}, defaults: {} };
+}
+
+/**
+ * Update models configuration
+ * @param {Object} modelsConfig - New models config
+ */
+function updateModelsConfig(modelsConfig) {
+  const config = readConfig();
+  config.models = modelsConfig;
+  writeConfig(config);
+}
+
+/**
+ * Get all configured providers
+ * @returns {Array<{name: string, displayName: string, enabled: boolean, models: string[], apiKeySet: boolean}>}
+ */
+function getConfiguredProviders() {
+  const modelsConfig = getModelsConfig();
+  const providers = [];
+
+  for (const [name, providerConfig] of Object.entries(modelsConfig.providers || {})) {
+    const knownProvider = KNOWN_PROVIDERS[name] || {};
+    const apiKeyEnv = providerConfig.apiKeyEnv || knownProvider.envKey;
+    const apiKeySet = apiKeyEnv ? !!process.env[apiKeyEnv] : true;
+
+    providers.push({
+      name,
+      displayName: knownProvider.displayName || name,
+      enabled: providerConfig.enabled !== false,
+      models: providerConfig.models || [],
+      apiKeyEnv,
+      apiKeySet,
+      endpoint: providerConfig.endpoint || knownProvider.endpoint
+    });
+  }
+
+  return providers;
+}
+
+/**
+ * Get all enabled models in provider:model format
+ * @returns {string[]} Array of "provider:model" strings
+ */
+function getEnabledModels() {
+  const providers = getConfiguredProviders();
+  const models = [];
+
+  for (const provider of providers) {
+    if (provider.enabled && provider.apiKeySet) {
+      for (const model of provider.models) {
+        models.push(`${provider.name}:${model}`);
+      }
+    }
+  }
+
+  return models;
+}
+
+/**
+ * Add or update a provider configuration
+ * @param {string} providerName - Provider name (openai, google, anthropic, local)
+ * @param {Object} options - Provider options
+ * @param {string} [options.apiKey] - API key (will be stored in .env)
+ * @param {string[]} [options.models] - Models to enable
+ * @param {string} [options.endpoint] - Custom endpoint
+ * @param {boolean} [options.enabled] - Enable/disable provider
+ */
+function addProvider(providerName, options = {}) {
+  const modelsConfig = getModelsConfig();
+  const knownProvider = KNOWN_PROVIDERS[providerName];
+
+  if (!modelsConfig.providers) {
+    modelsConfig.providers = {};
+  }
+
+  // Merge with existing config
+  const existingConfig = modelsConfig.providers[providerName] || {};
+  const newConfig = {
+    ...existingConfig,
+    enabled: options.enabled !== undefined ? options.enabled : true,
+    models: options.models || existingConfig.models || (knownProvider?.models?.slice(0, 2) || []),
+    apiKeyEnv: knownProvider?.envKey || existingConfig.apiKeyEnv
+  };
+
+  if (options.endpoint) {
+    newConfig.endpoint = options.endpoint;
+  }
+
+  // Store API key in .env if provided
+  if (options.apiKey && knownProvider?.envKey) {
+    updateEnvFile(knownProvider.envKey, options.apiKey);
+  }
+
+  modelsConfig.providers[providerName] = newConfig;
+  updateModelsConfig(modelsConfig);
+
+  return newConfig;
+}
+
+/**
+ * Remove/disable a provider
+ * @param {string} providerName - Provider name
+ */
+function removeProvider(providerName) {
+  const modelsConfig = getModelsConfig();
+
+  if (modelsConfig.providers && modelsConfig.providers[providerName]) {
+    modelsConfig.providers[providerName].enabled = false;
+    updateModelsConfig(modelsConfig);
+  }
+}
+
+/**
+ * Update .env file with API key
+ * @param {string} keyName - Environment variable name
+ * @param {string} keyValue - API key value
+ */
+function updateEnvFile(keyName, keyValue) {
+  let envContent = '';
+
+  try {
+    envContent = fs.readFileSync(ENV_PATH, 'utf-8');
+  } catch (err) {
+    // .env doesn't exist, will create
+  }
+
+  // Parse existing env vars
+  const lines = envContent.split('\n');
+  const envVars = {};
+  const comments = [];
+
+  for (const line of lines) {
+    if (line.startsWith('#') || line.trim() === '') {
+      comments.push(line);
+    } else {
+      const [key, ...valueParts] = line.split('=');
+      if (key) {
+        envVars[key.trim()] = valueParts.join('=').trim();
+      }
+    }
+  }
+
+  // Update or add the key
+  envVars[keyName] = keyValue;
+
+  // Rebuild .env content
+  let newContent = '';
+
+  // Add header comment if new file
+  if (!envContent) {
+    newContent = '# WogiFlow API Keys\n# Generated by /wogi-models-setup\n\n';
+  } else if (comments.length > 0) {
+    newContent = comments.join('\n') + '\n';
+  }
+
+  // Add env vars
+  for (const [key, value] of Object.entries(envVars)) {
+    newContent += `${key}=${value}\n`;
+  }
+
+  fs.writeFileSync(ENV_PATH, newContent);
+
+  // Also set in current process
+  process.env[keyName] = keyValue;
+}
+
+/**
+ * Test connection to a provider
+ * @param {string} providerName - Provider name
+ * @returns {Promise<{success: boolean, message: string, models?: string[]}>}
+ */
+async function testProviderConnection(providerName) {
+  const modelsConfig = getModelsConfig();
+  const providerConfig = modelsConfig.providers?.[providerName] || {};
+  const knownProvider = KNOWN_PROVIDERS[providerName];
+
+  if (!knownProvider) {
+    return { success: false, message: `Unknown provider: ${providerName}` };
+  }
+
+  const endpoint = providerConfig.endpoint || knownProvider.endpoint;
+  const apiKeyEnv = providerConfig.apiKeyEnv || knownProvider.envKey;
+  const apiKey = apiKeyEnv ? process.env[apiKeyEnv] : null;
+
+  // Local provider detection
+  if (providerName === 'local') {
+    return testLocalProvider(endpoint);
+  }
+
+  // Cloud provider test
+  if (!apiKey) {
+    return { success: false, message: `API key not set (${apiKeyEnv})` };
+  }
+
+  try {
+    const result = await testCloudProvider(providerName, endpoint, apiKey);
+    return result;
+  } catch (err) {
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Test local LLM provider (Ollama/LM Studio)
+ */
+async function testLocalProvider(endpoint) {
+  const https = require('https');
+  const http = require('http');
+
+  return new Promise((resolve) => {
+    const url = new URL('/api/tags', endpoint);
+    const client = url.protocol === 'https:' ? https : http;
+
+    const req = client.request(url, { method: 'GET', timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          const models = parsed.models?.map(m => m.name) || [];
+          resolve({
+            success: true,
+            message: `Connected to Ollama. Found ${models.length} models.`,
+            models
+          });
+        } catch (err) {
+          resolve({ success: false, message: 'Invalid response from local LLM' });
+        }
+      });
+    });
+
+    req.on('error', () => {
+      // Try LM Studio endpoint
+      testLMStudio(endpoint).then(resolve);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ success: false, message: 'Connection timeout' });
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * Test LM Studio provider
+ */
+async function testLMStudio(baseEndpoint) {
+  const http = require('http');
+
+  return new Promise((resolve) => {
+    // LM Studio uses OpenAI-compatible endpoint
+    const endpoint = baseEndpoint.replace(':11434', ':1234');
+    const url = new URL('/v1/models', endpoint);
+
+    const req = http.request(url, { method: 'GET', timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          const models = parsed.data?.map(m => m.id) || [];
+          resolve({
+            success: true,
+            message: `Connected to LM Studio. Found ${models.length} models.`,
+            models,
+            provider: 'lmstudio'
+          });
+        } catch (err) {
+          resolve({ success: false, message: 'No local LLM detected' });
+        }
+      });
+    });
+
+    req.on('error', () => {
+      resolve({ success: false, message: 'No local LLM detected at localhost:11434 or :1234' });
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * Test cloud provider connection
+ */
+async function testCloudProvider(providerName, endpoint, apiKey) {
+  const https = require('https');
+
+  return new Promise((resolve, reject) => {
+    let url, headers;
+
+    switch (providerName) {
+      case 'openai':
+        url = new URL('/v1/models', endpoint);
+        headers = { 'Authorization': `Bearer ${apiKey}` };
+        break;
+      case 'google':
+        url = new URL(`/v1beta/models?key=${apiKey}`, endpoint);
+        headers = {};
+        break;
+      case 'anthropic':
+        // Anthropic doesn't have a models list endpoint, just test with a simple check
+        resolve({ success: true, message: 'API key format valid (Anthropic)' });
+        return;
+      default:
+        reject(new Error(`Unknown cloud provider: ${providerName}`));
+        return;
+    }
+
+    const req = https.request(url, { method: 'GET', headers, timeout: 10000 }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          try {
+            const parsed = JSON.parse(data);
+            let models = [];
+
+            if (providerName === 'openai') {
+              models = parsed.data?.map(m => m.id).filter(id =>
+                id.startsWith('gpt-4') || id.startsWith('o1')
+              ).slice(0, 10) || [];
+            } else if (providerName === 'google') {
+              models = parsed.models?.map(m => m.name.replace('models/', '')) || [];
+            }
+
+            resolve({
+              success: true,
+              message: `Connected to ${providerName}. Found ${models.length} models.`,
+              models
+            });
+          } catch (err) {
+            resolve({ success: true, message: `Connected to ${providerName}` });
+          }
+        } else if (res.statusCode === 401) {
+          resolve({ success: false, message: 'Invalid API key' });
+        } else {
+          resolve({ success: false, message: `API error: ${res.statusCode}` });
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(err));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Connection timeout'));
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * Migrate old config formats to new unified structure
+ * - hybrid.executor → models.providers
+ * - peerReview.apiKeys → models.providers
+ */
+function migrateOldConfig() {
+  const config = readConfig();
+  let migrated = false;
+
+  // Initialize models section if needed
+  if (!config.models) {
+    config.models = { providers: {}, defaults: {} };
+  }
+  if (!config.models.providers) {
+    config.models.providers = {};
+  }
+
+  // Migrate hybrid.executor config
+  if (config.hybrid?.executor) {
+    const executor = config.hybrid.executor;
+    const provider = executor.provider;
+
+    if (provider && !config.models.providers[provider]) {
+      config.models.providers[provider] = {
+        enabled: true,
+        apiKeyEnv: executor.apiKeyEnv || KNOWN_PROVIDERS[provider]?.envKey,
+        models: executor.model ? [executor.model] : [],
+        endpoint: executor.providerEndpoint
+      };
+
+      // Set as hybrid default
+      if (executor.model) {
+        config.models.defaults = config.models.defaults || {};
+        config.models.defaults.hybrid = `${provider}:${executor.model}`;
+      }
+
+      migrated = true;
+      console.log(`${c.cyan}[model-config]${c.reset} Migrated hybrid.executor to models.providers.${provider}`);
+    }
+  }
+
+  // Migrate peerReview.apiKeys config
+  if (config.peerReview?.apiKeys) {
+    for (const [provider, keyRef] of Object.entries(config.peerReview.apiKeys)) {
+      if (!config.models.providers[provider]) {
+        // Extract env var name from ${VAR_NAME} format
+        const envKey = keyRef.replace(/^\$\{|\}$/g, '');
+
+        config.models.providers[provider] = {
+          enabled: true,
+          apiKeyEnv: envKey,
+          models: KNOWN_PROVIDERS[provider]?.models?.slice(0, 2) || []
+        };
+
+        migrated = true;
+        console.log(`${c.cyan}[model-config]${c.reset} Migrated peerReview.apiKeys.${provider} to models.providers`);
+      }
+    }
+
+    // Migrate peer review model defaults
+    if (config.peerReview.models && !config.models.defaults?.peerReview) {
+      config.models.defaults = config.models.defaults || {};
+      config.models.defaults.peerReview = config.peerReview.models;
+      migrated = true;
+    }
+  }
+
+  if (migrated) {
+    writeConfig(config);
+    console.log(`${c.green}[model-config]${c.reset} Migration complete. Config saved.`);
+  }
+
+  return migrated;
+}
+
+/**
+ * Get default models for a feature
+ * @param {string} feature - 'hybrid' or 'peerReview'
+ * @returns {string|string[]} Default model(s)
+ */
+function getDefaultModels(feature) {
+  const modelsConfig = getModelsConfig();
+  return modelsConfig.defaults?.[feature] || null;
+}
+
+/**
+ * Set default models for a feature
+ * @param {string} feature - 'hybrid' or 'peerReview'
+ * @param {string|string[]} models - Model(s) to set as default
+ */
+function setDefaultModels(feature, models) {
+  const modelsConfig = getModelsConfig();
+  if (!modelsConfig.defaults) {
+    modelsConfig.defaults = {};
+  }
+  modelsConfig.defaults[feature] = models;
+  updateModelsConfig(modelsConfig);
+}
+
+/**
+ * Check if any models are configured
+ * @returns {boolean}
+ */
+function hasConfiguredModels() {
+  const providers = getConfiguredProviders();
+  return providers.some(p => p.enabled && p.apiKeySet && p.models.length > 0);
+}
+
+// CLI interface
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case 'list':
+      const providers = getConfiguredProviders();
+      console.log('\nConfigured Providers:');
+      for (const p of providers) {
+        const status = p.enabled && p.apiKeySet ? c.green + '✓' + c.reset : c.red + '✗' + c.reset;
+        console.log(`  ${status} ${p.displayName}: ${p.models.join(', ') || '(no models)'}`);
+      }
+      console.log('\nEnabled Models:');
+      const models = getEnabledModels();
+      for (const m of models) {
+        console.log(`  - ${m}`);
+      }
+      break;
+
+    case 'migrate':
+      migrateOldConfig();
+      break;
+
+    case 'test':
+      const providerName = args[1];
+      if (!providerName) {
+        console.error('Usage: flow-model-config test <provider>');
+        process.exit(1);
+      }
+      testProviderConnection(providerName).then(result => {
+        if (result.success) {
+          console.log(`${c.green}✓${c.reset} ${result.message}`);
+          if (result.models) {
+            console.log('  Models:', result.models.slice(0, 5).join(', '));
+          }
+        } else {
+          console.log(`${c.red}✗${c.reset} ${result.message}`);
+        }
+      });
+      break;
+
+    default:
+      console.log(`
+Wogi Flow - Model Configuration
+
+Commands:
+  list              List configured providers and models
+  migrate           Migrate old config format to new unified format
+  test <provider>   Test connection to a provider
+
+Examples:
+  node flow-model-config.js list
+  node flow-model-config.js test openai
+  node flow-model-config.js migrate
+`);
+  }
+}
+
+module.exports = {
+  // Core functions
+  getModelsConfig,
+  updateModelsConfig,
+  getConfiguredProviders,
+  getEnabledModels,
+  hasConfiguredModels,
+
+  // Provider management
+  addProvider,
+  removeProvider,
+  testProviderConnection,
+
+  // Defaults
+  getDefaultModels,
+  setDefaultModels,
+
+  // Migration
+  migrateOldConfig,
+
+  // Constants
+  KNOWN_PROVIDERS,
+
+  // Utility
+  updateEnvFile
+};

package/scripts/hooks/core/implementation-gate.js

@@ -79,6 +79,20 @@ const WOGI_COMMAND_PATTERNS = [
   /\brun\s+(\/)?wogi-/i
 ];
 
+// Maximum length for prompt display (DRY helper)
+const MAX_DISPLAY_LENGTH = 80;
+
+/**
+ * Truncate prompt for display in messages
+ * @param {string} prompt - The prompt to truncate
+ * @param {number} maxLength - Maximum length (default: 80)
+ * @returns {string} Truncated prompt with ellipsis if needed
+ */
+function truncatePrompt(prompt, maxLength = MAX_DISPLAY_LENGTH) {
+  if (!prompt || typeof prompt !== 'string') return '';
+  return prompt.length > maxLength ? prompt.slice(0, maxLength) + '...' : prompt;
+}
+
 /**
  * Check if implementation gate should be enforced
  * @returns {boolean}
@@ -159,17 +173,9 @@ function detectImplementationIntent(prompt) {
     return { isImplementation: false, confidence: 'low', matches: [] };
   }
 
-  // Determine confidence based on number and quality of matches
-  let confidence = 'low';
-  if (matches.length >= 3) {
-    confidence = 'high';
-  } else if (matches.length >= 1) {
-    // Check for strong signals
-    const hasStrongSignal = matches.some(m =>
-      /\b(add|create|implement|fix|build)\b/i.test(m)
-    );
-    confidence = hasStrongSignal ? 'high' : 'medium';
-  }
+  // Determine confidence based on number of matches
+  // Simplified: any match from IMPLEMENTATION_PATTERNS is a strong signal
+  const confidence = matches.length >= 2 ? 'high' : 'medium';
 
   return { isImplementation: true, confidence, matches };
 }
@@ -183,7 +189,7 @@ function detectImplementationIntent(prompt) {
  * @returns {Object} Result: { allowed, blocked, message, reason, confidence, suggestedAction }
  */
 function checkImplementationGate(options = {}) {
-  const { prompt, source: _source } = options;
+  const { prompt } = options;
 
   // Empty or invalid prompt - allow
   if (!prompt || typeof prompt !== 'string' || prompt.trim().length === 0) {
@@ -264,7 +270,7 @@ function checkImplementationGate(options = {}) {
     return {
       allowed: true,
       blocked: false,
-      message: generateWarningMessage(prompt, confidence, matches),
+      message: generateWarningMessage(prompt),
       reason: 'warn_only',
       confidence,
       suggestedAction: 'create-story',
@@ -276,7 +282,7 @@ function checkImplementationGate(options = {}) {
   return {
     allowed: false,
     blocked: true,
-    message: generateBlockMessage(prompt, confidence, matches),
+    message: generateBlockMessage(prompt),
     reason: 'no_active_task',
     confidence,
     suggestedAction: 'create-story',
@@ -287,11 +293,10 @@ function checkImplementationGate(options = {}) {
 /**
  * Generate warning message (soft mode)
  */
-function generateWarningMessage(prompt, confidence, matches) {
-  const truncatedPrompt = prompt.length > 80 ? prompt.slice(0, 80) + '...' : prompt;
+function generateWarningMessage(prompt) {
   return `Warning: No active WogiFlow task.
 
-Consider: /wogi-start "${truncatedPrompt}"
+Consider: /wogi-start "${truncatePrompt(prompt)}"
 
 This will execute directly (git/npm/deploy) or create a story first (features/fixes).`;
 }
@@ -299,13 +304,11 @@ This will execute directly (git/npm/deploy) or create a story first (features/fi
 /**
  * Generate block message (hard mode)
  */
-function generateBlockMessage(prompt, confidence, matches) {
-  const truncatedPrompt = prompt.length > 80 ? prompt.slice(0, 80) + '...' : prompt;
-
+function generateBlockMessage(prompt) {
   return `BLOCKED: No active WogiFlow task.
 
 To proceed, run:
-  /wogi-start "${truncatedPrompt}"
+  /wogi-start "${truncatePrompt(prompt)}"
 
 This will either:
 - Execute directly (if operational: git, npm, deploy, build)
@@ -323,6 +326,7 @@ module.exports = {
   checkImplementationGate,
   generateWarningMessage,
   generateBlockMessage,
+  truncatePrompt,
   IMPLEMENTATION_PATTERNS,
   EXPLORATION_PATTERNS
 };