chati-dev 3.0.0 → 3.0.2

package/src/terminal/cli-registry.js

@@ -6,9 +6,8 @@
  * truth for multi-CLI governance (Constitution Article XIX).
  */
 
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
 import * as adapters from './adapters/index.js';
+import { parseProviderConfig, parseAgentOverride } from '../utils/config-parser.js';
 
 // ---------------------------------------------------------------------------
 // Provider Definitions
@@ -49,10 +48,10 @@ const PROVIDERS = {
   gemini: {
     name: 'gemini',
     command: 'gemini',
-    baseArgs: ['--prompt'],
+    baseArgs: [],
     modelFlag: '--model',
     stdinSupport: true,
-    hooksSupport: true,
+    hooksSupport: false,
     mcpSupport: true,
     contextFile: 'GEMINI.md',
     modelMap: {
@@ -72,7 +71,7 @@ const PROVIDERS = {
     contextFile: 'AGENTS.md',
     modelMap: {
       codex: 'gpt-5.3-codex',
-      mini: 'gpt-5.1-codex-mini',
+      mini: 'codex-mini-latest',
     },
     adapter: adapters.codex,
   },
@@ -82,12 +81,12 @@ const PROVIDERS = {
     baseArgs: ['-p'],
     modelFlag: '--model',
     stdinSupport: true,
-    hooksSupport: true,
+    hooksSupport: false,
     mcpSupport: true,
     contextFile: null,
     modelMap: {
       'claude-sonnet': 'claude-sonnet-4.5',
-      'gpt-5': 'gpt-5.1',
+      'gpt-5': 'gpt-5',
     },
     adapter: adapters.copilot,
   },
@@ -128,33 +127,7 @@ export function getAllProviders() {
  * @returns {{ primary: string, enabled: string[] }}
  */
 export function loadEnabledProviders(projectDir) {
-  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
-  if (!existsSync(configPath)) {
-    return { primary: 'claude', enabled: ['claude'] };
-  }
-
-  const raw = readFileSync(configPath, 'utf-8');
-
-  // Lightweight YAML extraction (avoid dependency in spawning path)
-  const enabled = [];
-  let primary = 'claude';
-
-  for (const name of Object.keys(PROVIDERS)) {
-    const enabledMatch = raw.match(new RegExp(`${name}:[\\s\\S]*?enabled:\\s*(true|false)`, 'm'));
-    if (enabledMatch && enabledMatch[1] === 'true') {
-      enabled.push(name);
-    }
-    const primaryMatch = raw.match(new RegExp(`${name}:[\\s\\S]*?primary:\\s*(true|false)`, 'm'));
-    if (primaryMatch && primaryMatch[1] === 'true') {
-      primary = name;
-    }
-  }
-
-  // Claude is always enabled as fallback
-  if (!enabled.includes('claude')) {
-    enabled.unshift('claude');
-  }
-
+  const { primary, enabled } = parseProviderConfig(projectDir);
   return { primary, enabled };
 }
 
@@ -170,16 +143,12 @@ export function loadEnabledProviders(projectDir) {
 export function resolveProviderForAgent(agent, projectDir, agentModels) {
   const { primary, enabled } = loadEnabledProviders(projectDir);
 
-  // Check agent_overrides in config.yaml
-  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
-  if (existsSync(configPath)) {
-    const raw = readFileSync(configPath, 'utf-8');
-    const overrideMatch = raw.match(new RegExp(`${agent}:\\s*\\{[^}]*provider:\\s*(\\w+)[^}]*model:\\s*(\\w+)`, 'm'));
-    if (overrideMatch) {
-      const overrideProvider = overrideMatch[1];
-      if (enabled.includes(overrideProvider)) {
-        return { provider: overrideProvider, model: overrideMatch[2] };
-      }
+  // Check agent_overrides in config.yaml (block-style YAML)
+  const { raw } = parseProviderConfig(projectDir);
+  if (raw) {
+    const override = parseAgentOverride(raw, agent);
+    if (override && enabled.includes(override.provider)) {
+      return override;
     }
   }
 
@@ -192,8 +161,10 @@ export function resolveProviderForAgent(agent, projectDir, agentModels) {
     }
   }
 
-  // Fallback to primary
-  return { provider: primary, model: 'sonnet' };
+  // Fallback to primary provider with its default light-tier model
+  const provider = PROVIDERS[primary];
+  const defaultModel = provider ? Object.keys(provider.modelMap)[0] : 'sonnet';
+  return { provider: primary, model: defaultModel };
 }
 
 /**
@@ -206,9 +177,10 @@ export async function isProviderAvailable(name) {
   const provider = PROVIDERS[name];
   if (!provider) return false;
 
-  const { execSync } = await import('child_process');
+  const { execFileSync } = await import('child_process');
   try {
-    execSync(`which ${provider.command}`, { stdio: 'ignore' });
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    execFileSync(cmd, [provider.command], { stdio: 'ignore' });
     return true;
   } catch {
     return false;

package/src/terminal/index.js

@@ -8,6 +8,7 @@ export {
   spawnParallelGroup,
   killTerminal,
   getTerminalStatus,
+  cleanParentEnv,
   _resetCounter,
 } from './spawner.js';
 

package/src/terminal/prompt-builder.js

@@ -14,24 +14,9 @@ import { runPrism } from '../context/engine.js';
 import { loadHandoff, formatHandoff } from '../tasks/handoff.js';
 import { getWriteScope } from './isolation.js';
 
-// Re-read at import time so the prompt builder always uses the correct map
-// without circular dependency issues (the hook file runs main() on import
-// which writes to stdout — we only need the data, so we inline the map).
-const AGENT_MODELS = {
-  orchestrator: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
-  'greenfield-wu': { provider: 'claude', model: 'haiku', tier: 'haiku' },
-  'brownfield-wu': { provider: 'claude', model: 'opus', tier: 'opus' },
-  brief: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
-  detail: { provider: 'claude', model: 'opus', tier: 'opus' },
-  architect: { provider: 'claude', model: 'opus', tier: 'opus' },
-  ux: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
-  phases: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
-  tasks: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
-  'qa-planning': { provider: 'claude', model: 'opus', tier: 'opus' },
-  'qa-implementation': { provider: 'claude', model: 'opus', tier: 'opus' },
-  dev: { provider: 'claude', model: 'opus', tier: 'opus' },
-  devops: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
-};
+// Import AGENT_MODELS from model-governance (safe — named export,
+// does not trigger main() which is guarded by fileURLToPath check).
+import { AGENT_MODELS } from '../../framework/hooks/model-governance.js';
 
 /**
  * Map of agent names to their definition file paths (relative to project root).

package/src/terminal/run-agent.js

@@ -160,7 +160,8 @@ async function main() {
 function waitForExit(handle, timeout) {
   return new Promise((resolve, reject) => {
     if (handle.status === 'exited') {
-      return resolve();
+      resolve();
+      return;
     }
 
     const timer = setTimeout(() => {

package/src/terminal/spawner.js

@@ -35,6 +35,48 @@ export function _resetCounter() {
   _counter = 0;
 }
 
+// ---------------------------------------------------------------------------
+// Environment cleaning
+// ---------------------------------------------------------------------------
+
+/**
+ * Environment variable prefixes injected by Claude Code that must NOT
+ * leak into spawned CLI processes.  A spawned `claude --print` that
+ * inherits `CLAUDECODE=1` will refuse to start ("cannot be launched
+ * inside another Claude Code session").
+ *
+ * @type {string[]}
+ */
+const BLOCKED_ENV_PREFIXES = ['CLAUDE_CODE_', 'CLAUDE_AGENT_SDK_'];
+
+/**
+ * Exact environment variable names to strip (no prefix match needed).
+ * @type {string[]}
+ */
+const BLOCKED_ENV_EXACT = ['CLAUDECODE'];
+
+/**
+ * Return a copy of the given environment with Claude Code-specific
+ * variables removed.  This prevents "nested session" errors when
+ * spawning `claude --print` from inside a Claude Code session.
+ *
+ * The function is intentionally conservative — it only removes vars
+ * that are known to be injected by the Claude Code host process.
+ * User-configured vars like CLAUDE_API_KEY are preserved.
+ *
+ * @param {Record<string, string>} env - Source environment (typically process.env)
+ * @returns {Record<string, string>} Cleaned environment (new object)
+ */
+export function cleanParentEnv(env) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (BLOCKED_ENV_EXACT.includes(key)) continue;
+    if (BLOCKED_ENV_PREFIXES.some(prefix => key.startsWith(prefix))) continue;
+    cleaned[key] = value;
+  }
+  return cleaned;
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -43,7 +85,8 @@ export function _resetCounter() {
  * @typedef {object} SpawnConfig
  * @property {string} agent           - Agent name (e.g. "architect")
  * @property {string} taskId          - Task identifier
- * @property {string} [model]         - LLM model (haiku/sonnet/opus)
+ * @property {string} [model]         - LLM model tier name (e.g. opus, pro, codex, claude-sonnet)
+ * @property {string} [provider]      - CLI provider name (claude, gemini, codex, copilot)
  * @property {string} [prompt]        - Full prompt string (from prompt-builder, piped via stdin)
  * @property {object} [contextPayload] - Context to inject via env var
  * @property {string[]} [writeScope]   - Override write scope
@@ -114,12 +157,15 @@ export function buildSpawnCommand(config) {
     command = adapterResult.command;
     args = adapterResult.args;
     prompt = adapterResult.stdinPrompt;
-  } catch {
+  } catch (err) {
     // Fallback to claude if provider resolution fails (backwards compatibility)
+    console.error(`[chati] Provider "${providerName}" resolution failed: ${err.message}. Falling back to claude.`);
     command = 'claude';
     args = ['--print', '--dangerously-skip-permissions'];
     if (config.model) {
-      args.push('--model', config.model);
+      const claudeProvider = getProvider('claude');
+      const resolvedModel = claudeProvider.modelMap[config.model] || config.model;
+      args.push('--model', resolvedModel);
     }
     prompt = config.prompt || null;
   }
@@ -141,7 +187,7 @@ export function spawnTerminal(config) {
 
   const child = spawn(command, args, {
     cwd,
-    env: { ...process.env, ...env },
+    env: { ...cleanParentEnv(process.env), ...env },
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
@@ -157,7 +203,7 @@ export function spawnTerminal(config) {
     process: child,
     agent: config.agent,
     taskId: config.taskId,
-    model: config.model || 'sonnet',
+    model: config.model || 'unknown',
     startedAt: new Date().toISOString(),
     status: 'running',
     exitCode: null,
@@ -166,15 +212,20 @@ export function spawnTerminal(config) {
     timeout,
   };
 
-  // Capture output
+  // Capture output (capped at ~10MB to prevent unbounded memory growth)
+  const MAX_BUFFER_CHUNKS = 10_000;
   if (child.stdout) {
     child.stdout.on('data', (chunk) => {
-      handle.stdout.push(chunk.toString());
+      if (handle.stdout.length < MAX_BUFFER_CHUNKS) {
+        handle.stdout.push(chunk.toString());
+      }
     });
   }
   if (child.stderr) {
     child.stderr.on('data', (chunk) => {
-      handle.stderr.push(chunk.toString());
+      if (handle.stderr.length < MAX_BUFFER_CHUNKS) {
+        handle.stderr.push(chunk.toString());
+      }
     });
   }
 
@@ -189,6 +240,17 @@ export function spawnTerminal(config) {
     handle.stderr.push(`spawn error: ${err.message}`);
   });
 
+  // Enforce timeout — kill process if it exceeds max execution time
+  const timeoutTimer = setTimeout(() => {
+    if (handle.status === 'running') {
+      handle.stderr.push(`timeout: process exceeded ${timeout}ms limit`);
+      killTerminal(handle);
+    }
+  }, timeout);
+
+  // Clear timer when process exits normally
+  child.on('exit', () => clearTimeout(timeoutTimer));
+
   return handle;
 }
 

package/src/terminal/wave-analyzer.js

@@ -59,7 +59,7 @@ export function analyzeWaves(tasks) {
 
   // Kahn's algorithm with wave grouping
   const waves = [];
-  let remaining = new Set(tasks.map((t) => t.id));
+  const remaining = new Set(tasks.map((t) => t.id));
 
   while (remaining.size > 0) {
     // Find all tasks with no pending dependencies (in-degree 0)

package/src/utils/config-parser.js

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview Shared YAML config parser for provider configuration.
+ *
+ * Extracts provider enabled/primary status and agent overrides from
+ * config.yaml using lightweight regex-based parsing. Used by
+ * cli-registry.js, context-file-generator.js, and health/engine.js.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Parse provider configuration from config.yaml.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {{ primary: string, enabled: string[], raw: string|null }}
+ */
+export function parseProviderConfig(projectDir) {
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) {
+    return { primary: 'claude', enabled: ['claude'], raw: null };
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  const providers = ['claude', 'gemini', 'codex', 'copilot'];
+  const enabled = [];
+  let primary = 'claude';
+
+  for (const name of providers) {
+    const enabledMatch = raw.match(new RegExp(`${name}:[\\s\\S]*?enabled:\\s*(true|false)`, 'm'));
+    if (enabledMatch && enabledMatch[1] === 'true') {
+      enabled.push(name);
+    }
+    const primaryMatch = raw.match(new RegExp(`${name}:[\\s\\S]*?primary:\\s*(true|false)`, 'm'));
+    if (primaryMatch && primaryMatch[1] === 'true') {
+      primary = name;
+    }
+  }
+
+  // Claude is always enabled as fallback
+  if (!enabled.includes('claude')) {
+    enabled.unshift('claude');
+  }
+
+  return { primary, enabled, raw };
+}
+
+/**
+ * Parse agent override block from config.yaml.
+ *
+ * @param {string} raw - Raw config.yaml content
+ * @param {string} agent - Agent name
+ * @returns {{ provider: string, model: string }|null}
+ */
+export function parseAgentOverride(raw, agent) {
+  const escaped = agent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const overrideBlock = raw.match(new RegExp(`^\\s+${escaped}:\\s*\\n((?:\\s+\\w+:.*\\n?)*)`, 'm'));
+  if (!overrideBlock) return null;
+
+  const block = overrideBlock[1];
+  const providerMatch = block.match(/provider:\s*(\S+)/);
+  const modelMatch = block.match(/model:\s*(\S+)/);
+
+  if (providerMatch && modelMatch) {
+    return { provider: providerMatch[1], model: modelMatch[1] };
+  }
+  return null;
+}
+
+/**
+ * Get list of enabled non-Claude providers.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {string[]} List of enabled provider names (excludes claude)
+ */
+export function getEnabledNonClaudeProviders(projectDir) {
+  const { enabled } = parseProviderConfig(projectDir);
+  return enabled.filter(p => p !== 'claude');
+}
+
+/**
+ * Check if a CLI command is available on the system.
+ * Cross-platform: uses 'which' on Unix, 'where' on Windows.
+ *
+ * @param {string} command - CLI command name
+ * @returns {Promise<boolean>}
+ */
+export async function isCommandAvailable(command) {
+  const { execFileSync } = await import('child_process');
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    execFileSync(cmd, [command], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/wizard/feedback.js

@@ -60,7 +60,7 @@ export function showQuickStart(title, steps) {
 export function showSummary(data) {
   console.log();
   for (const [label, value] of Object.entries(data)) {
-    const paddedLabel = label.padEnd(12);
+    const paddedLabel = label.padEnd(16);
     console.log(`  ${dim(paddedLabel)} ${value}`);
   }
 }

package/src/wizard/i18n.js

@@ -20,19 +20,26 @@ const FALLBACK_EN = {
     language_label: 'Language',
     ides_label: 'IDEs',
     mcps_label: 'MCPs',
+    llm_provider_title: 'Select your default AI provider:',
+    llm_provider_claude: 'Claude (Anthropic) — Best for structured reasoning',
+    llm_provider_gemini: 'Gemini (Google) — 1M token context window',
+    llm_provider_codex: 'Codex (OpenAI) — Optimized for code generation',
+    llm_provider_copilot: 'Copilot (GitHub) — Multi-model, GitHub integrated',
+    llm_provider_not_installed: '(CLI not detected)',
+    llm_provider_label: 'AI Provider',
     will_install: 'Will install:',
     agents_count: '13 agent definitions (DISCOVER, PLAN, BUILD, DEPLOY phases)',
     workflows_count: '6 workflow blueprints',
     templates_count: '6 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate, Quick Brief)',
-    constitution: 'Constitution (17 Articles + Preamble)',
+    constitution: 'Constitution (19 Articles + Preamble)',
     session_mgmt: 'Session management system',
-    quality_gates: 'Quality gates (4-tier validation)',
+    quality_gates: 'Quality gates (3-tier verdicts)',
     proceed: 'Proceed with installation?',
     installing: 'Installing Chati.dev...',
     created_chati: 'Created .chati/ session directory',
     created_framework: 'Created chati.dev/ system directory (agents, templates, workflows)',
     created_commands: 'Created .claude/commands/ (thin router)',
-    installed_constitution: 'Installed Constitution (Articles I-XVII)',
+    installed_constitution: 'Installed Constitution (Articles I-XIX)',
     created_session: 'Created session.yaml schema',
     created_claude_md: 'Created CLAUDE.md',
     configured_mcps: 'Configured MCPs:',
@@ -40,7 +47,7 @@ const FALLBACK_EN = {
     agents_valid: 'All 13 agents implement 8 protocols',
     handoff_ok: 'Handoff protocol: OK',
     validation_ok: 'Self-validation criteria: OK',
-    constitution_ok: 'Constitution: 17 articles verified',
+    constitution_ok: 'Constitution: 19 articles verified',
     created_memories: 'Created .chati/memories/ (Memory Layer)',
     installed_intelligence: 'Installed Intelligence Layer (Context Engine, Memory, Registry)',
     intelligence_valid: 'Intelligence: 6 spec files verified',

package/src/wizard/index.js

@@ -3,12 +3,24 @@ import { readFileSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { logBanner } from '../utils/logger.js';
-import { stepLanguage, stepProjectType, stepConfirmation } from './questions.js';
+import { stepLanguage, stepProjectType, stepLlmProvider, stepConfirmation } from './questions.js';
 import { createSpinner, showStep, showValidation, showQuickStart } from './feedback.js';
 import { installFramework } from '../installer/core.js';
 import { validateInstallation } from '../installer/validator.js';
 import { t } from './i18n.js';
 import { DEFAULT_MCPS } from '../config/mcp-configs.js';
+import { IDE_CONFIGS } from '../config/ide-configs.js';
+
+/**
+ * Map LLM provider to its primary IDE.
+ * Each provider maps to its own standalone IDE — no cross-contamination.
+ */
+const PROVIDER_TO_IDE = {
+  claude: ['claude-code'],
+  gemini: ['gemini-cli'],
+  codex: ['codex-cli'],
+  copilot: ['github-copilot'],
+};
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8')).version;
@@ -35,16 +47,20 @@ export async function runWizard(targetDir, options = {}) {
   // Step 2: Project Type
   const projectType = options.projectType || await stepProjectType(targetDir);
 
-  // Auto-configured: Claude Code + default MCPs
-  const selectedIDEs = options.ides || ['claude-code'];
+  // Step 3: LLM Provider
+  const llmProvider = options.llmProvider || await stepLlmProvider();
+
+  // Map provider to its standalone IDE(s)
+  const selectedIDEs = options.ides || PROVIDER_TO_IDE[llmProvider] || ['claude-code'];
   const selectedMCPs = options.mcps || DEFAULT_MCPS;
 
-  // Step 3: Confirmation
+  // Step 4: Confirmation
   const projectName = basename(targetDir);
   const config = {
     projectName,
     projectType,
     language,
+    llmProvider,
     selectedIDEs,
     selectedMCPs,
     targetDir,
@@ -53,7 +69,7 @@ export async function runWizard(targetDir, options = {}) {
 
   await stepConfirmation(config);
 
-  // Step 4: Installation + Validation
+  // Step 5: Installation + Validation
   console.log();
   const installSpinner = createSpinner(t('installer.installing'));
   installSpinner.start();
@@ -67,7 +83,9 @@ export async function runWizard(targetDir, options = {}) {
     showStep(t('installer.created_commands'));
     showStep(t('installer.installed_constitution'));
     showStep(t('installer.created_session'));
-    showStep(t('installer.created_claude_md'));
+    if (selectedIDEs.includes('claude-code')) {
+      showStep(t('installer.created_claude_md'));
+    }
     showStep(t('installer.created_memories'));
     showStep(t('installer.installed_intelligence'));
     showStep(`${t('installer.configured_mcps')} ${selectedMCPs.join(', ')}`);
@@ -80,28 +98,40 @@ export async function runWizard(targetDir, options = {}) {
     const validation = await validateInstallation(targetDir);
     validateSpinner.stop();
 
-    showValidation(t('installer.agents_valid'));
+    // Show validation results based on actual checks
+    if (validation.agents?.pass) showValidation(t('installer.agents_valid'));
+    if (validation.constitution?.pass) showValidation(t('installer.constitution_ok'));
+    if (validation.intelligence?.pass) showValidation(t('installer.intelligence_valid'));
+    if (validation.registry?.pass) showValidation(t('installer.registry_valid'));
+    if (validation.memories?.pass) showValidation(t('installer.memories_valid'));
+    if (validation.session?.pass) showValidation(t('installer.session_ok'));
     showValidation(t('installer.handoff_ok'));
     showValidation(t('installer.validation_ok'));
-    showValidation(t('installer.constitution_ok'));
-    showValidation(t('installer.intelligence_valid'));
-    showValidation(t('installer.registry_valid'));
-    showValidation(t('installer.memories_valid'));
-    showValidation(t('installer.session_ok'));
+
+    // Warn if any checks failed
+    if (validation.passed < validation.total) {
+      const failed = validation.total - validation.passed;
+      p.log.warn(`${failed} validation check(s) did not pass. Run 'npx chati-dev health' for details.`);
+    }
 
     console.log();
     p.outro(t('installer.success'));
 
+    // Show quick start — same experience across all providers
+    const primaryIDE = selectedIDEs[selectedIDEs.length - 1];
+    const primaryIDEName = IDE_CONFIGS[primaryIDE]?.name || primaryIDE;
+    const invokeCmd = primaryIDE === 'github-copilot' ? '@chati' : '/chati';
     showQuickStart(t('installer.quick_start_title'), [
-      `${t('installer.quick_start_1')} (Claude Code)`,
-      t('installer.quick_start_2'),
+      `${t('installer.quick_start_1')} (${primaryIDEName})`,
+      `Type: ${invokeCmd}`,
       t('installer.quick_start_3'),
     ]);
 
     return { success: true, config, validation };
   } catch (err) {
     installSpinner.stop();
-    p.cancel(`Installation failed: ${err.message}`);
+    const phase = err.message?.includes('validat') ? 'Validation' : 'Installation';
+    p.cancel(`${phase} failed: ${err.message}`);
     return { success: false, error: err.message };
   }
 }

package/src/wizard/questions.js

@@ -3,6 +3,8 @@ import { t, SUPPORTED_LANGUAGES, loadLanguage } from './i18n.js';
 import { detectProjectType } from '../utils/detector.js';
 import { showSummary, showChecklist } from './feedback.js';
 import { brand, dim, success } from '../utils/colors.js';
+import { isProviderAvailable } from '../terminal/cli-registry.js';
+import { IDE_CONFIGS } from '../config/ide-configs.js';
 
 /**
  * Step 1: Language Selection (always in English)
@@ -58,13 +60,61 @@ export async function stepProjectType(targetDir) {
 }
 
 /**
- * Step 3: Confirmation
+ * Step 3: LLM Provider Selection
+ */
+export async function stepLlmProvider() {
+  const providers = [
+    { name: 'claude', label: t('installer.llm_provider_claude') },
+    { name: 'gemini', label: t('installer.llm_provider_gemini') },
+    { name: 'codex', label: t('installer.llm_provider_codex') },
+    { name: 'copilot', label: t('installer.llm_provider_copilot') },
+  ];
+
+  // Check availability of each provider
+  const availability = {};
+  for (const prov of providers) {
+    try {
+      availability[prov.name] = await isProviderAvailable(prov.name);
+    } catch {
+      availability[prov.name] = prov.name === 'claude'; // claude always available
+    }
+  }
+
+  const options = providers.map(prov => {
+    const installed = availability[prov.name];
+    const suffix = installed ? '' : ` ${dim(t('installer.llm_provider_not_installed'))}`;
+    return {
+      value: prov.name,
+      label: `${prov.label}${suffix}`,
+    };
+  });
+
+  const provider = await p.select({
+    message: t('installer.llm_provider_title'),
+    options,
+    initialValue: 'claude',
+  });
+
+  if (p.isCancel(provider)) {
+    p.cancel('Installation cancelled.');
+    process.exit(0);
+  }
+
+  return provider;
+}
+
+/**
+ * Step 4: Confirmation
  */
 export async function stepConfirmation(config) {
-  const { projectName, projectType, language, selectedMCPs } = config;
+  const { projectName, projectType, language, llmProvider, selectedMCPs, selectedIDEs } = config;
 
   const langName = SUPPORTED_LANGUAGES.find(l => l.value === language)?.label || language;
-  const ideNames = 'Claude Code (auto-configured)';
+  const providerNames = { claude: 'Claude (Anthropic)', gemini: 'Gemini (Google)', codex: 'Codex (OpenAI)', copilot: 'Copilot (GitHub)' };
+  const providerDisplay = providerNames[llmProvider] || llmProvider;
+  const ideNames = (selectedIDEs || ['claude-code'])
+    .map(id => IDE_CONFIGS[id]?.name || id)
+    .join(', ') + ' (auto-configured)';
   const mcpNames = selectedMCPs.length > 0
     ? `${selectedMCPs.join(', ')} (auto-installed)`
     : 'None';
@@ -74,6 +124,7 @@ export async function stepConfirmation(config) {
   showSummary({
     [t('installer.project_label')]: `${projectName} (${projectType === 'greenfield' ? 'Greenfield' : 'Brownfield'})`,
     [t('installer.language_label')]: langName,
+    [t('installer.llm_provider_label')]: providerDisplay,
     [t('installer.ides_label')]: ideNames,
     [t('installer.mcps_label')]: mcpNames,
   });