ai-control-center 1.15.2

package/lib/init/wizard.js

@@ -0,0 +1,973 @@
+/**
+ * `aicc init` — interactive project setup wizard.
+ *
+ * Guides the user through:
+ *   1. Project configuration (name, deploy command, review settings)
+ *   2. Tool verification (git, AI CLIs, deployment tools)
+ *   3. AI CLI authentication checks
+ *   4. Telegram bot setup (optional)
+ *   5. AI mode configuration
+ *   6. AI pipeline files (skills, agents, role files)
+ *
+ * Writes aicc.config.js + creates workflow directories + status.json +
+ * skill files + agent definitions + GEMINI.md + copilot-instructions.md.
+ */
+import chalk from 'chalk';
+import { execSync, spawn, spawnSync } from 'child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import inquirer from 'inquirer';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { PROJECT_PRESETS, PROJECT_TYPE_CHOICES } from './presets.js';
+import { fetchSkills, printFetchResults } from './skill-fetcher.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function checkTool(name) {
+  try {
+    const path = execSync(`which ${name} 2>/dev/null`, { encoding: 'utf8' }).trim();
+    return { ok: true, path };
+  } catch {
+    return { ok: false, path: null };
+  }
+}
+
+function checkToolVersion(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', timeout: 5000 }).trim().split('\n')[0];
+  } catch {
+    return null;
+  }
+}
+
+function icon(ok) {
+  return ok ? chalk.green('✓') : chalk.red('✗');
+}
+
+// ─── Phase 1: Project Configuration ─────────────────────────────────────────
+
+async function phaseProjectConfig(cwd) {
+  console.log(chalk.cyan.bold('\n  ── Phase 1: Project Configuration ──\n'));
+
+  // ── Project type selector — drives default values for everything below
+  const { projectType } = await inquirer.prompt([{
+    type: 'list',
+    name: 'projectType',
+    message: 'What type of project is this?',
+    choices: PROJECT_TYPE_CHOICES,
+    pageSize: 16,
+  }]);
+
+  const preset = PROJECT_PRESETS[projectType] || PROJECT_PRESETS.custom;
+  const presetExts = preset.extensions.join(', ');
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Project name:',
+      default: cwd.split('/').pop() || 'my-project',
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Short description:',
+      default: '',
+    },
+    {
+      type: 'input',
+      name: 'workflowDir',
+      message: 'Workflow directory:',
+      default: '.ai-workflow',
+    },
+    {
+      type: 'input',
+      name: 'envPrefix',
+      message: 'Environment variable prefix:',
+      default: (a) => a.name.replace(/[^a-zA-Z0-9]/g, '_').toUpperCase().slice(0, 12),
+    },
+    {
+      type: 'input',
+      name: 'deployCommand',
+      message: 'Deploy command (leave empty if none):',
+      default: preset.deployCommand || '',
+    },
+    {
+      type: 'input',
+      name: 'extensions',
+      message: 'Reviewable file extensions (comma-separated):',
+      default: presetExts,
+    },
+    {
+      type: 'input',
+      name: 'sourceDir',
+      message: 'Source directory for diffs/reviews:',
+      default: preset.sourceDir || 'src/',
+    },
+    {
+      type: 'input',
+      name: 'skillsDir',
+      message: 'AI skills directory:',
+      default: '.claude/skills',
+    },
+    {
+      type: 'input',
+      name: 'webPort',
+      message: 'Web dashboard port:',
+      default: '3847',
+    },
+  ]);
+
+  // Attach preset metadata for use in later phases
+  answers.projectType = projectType;
+  answers._preset = preset;
+
+  return answers;
+}
+
+// ─── Phase 2: Tool Verification ─────────────────────────────────────────────
+
+async function phaseToolCheck(envPrefix) {
+  console.log(chalk.cyan.bold('\n  ── Phase 2: Tool Verification ──\n'));
+
+  const results = {};
+  const tools = [
+    { name: 'git',     label: 'Git',                required: true,  versionCmd: 'git --version' },
+    { name: 'gh',      label: 'GitHub CLI',          required: false, versionCmd: 'gh --version' },
+    { name: 'claude',  label: 'Claude Code CLI',     required: false, versionCmd: 'claude --version' },
+    { name: 'copilot', label: 'GitHub Copilot CLI',  required: false, versionCmd: 'copilot --version' },
+    { name: 'gemini',  label: 'Gemini CLI',          required: false, versionCmd: 'gemini --version' },
+  ];
+
+  for (const tool of tools) {
+    const check = checkTool(tool.name);
+    const version = check.ok ? checkToolVersion(tool.versionCmd) : null;
+    const reqTag = tool.required ? chalk.red(' (required)') : chalk.dim(' (optional)');
+    const versionStr = version ? chalk.dim(` — ${version}`) : '';
+
+    console.log(`  ${icon(check.ok)}  ${tool.label}${reqTag}${versionStr}`);
+    results[tool.name] = check;
+
+    if (tool.required && !check.ok) {
+      console.log(chalk.red(`\n     ${tool.label} is required. Please install it and re-run "aicc init".\n`));
+    }
+  }
+
+  // Check Ollama (HTTP-based, not a CLI binary)
+  let ollamaAvailable = false;
+  try {
+    execSync('curl -sf http://localhost:11434/api/tags > /dev/null 2>&1', { timeout: 3000 });
+    ollamaAvailable = true;
+  } catch { /* not running */ }
+  console.log(`  ${icon(ollamaAvailable)}  Ollama (local AI)${chalk.dim(' (optional)')}`);
+  results.ollama = { ok: ollamaAvailable };
+
+  return results;
+}
+
+// ─── Phase 3: Authentication & Credentials ──────────────────────────────────
+
+async function phaseAuth(toolResults, envPrefix) {
+  console.log(chalk.cyan.bold('\n  ── Phase 3: Authentication & Credentials ──\n'));
+  const setupActions = [];
+
+  // Git: check if repo initialized + remote configured
+  if (toolResults.git?.ok) {
+    let gitOk = false;
+    try {
+      execSync('git rev-parse --is-inside-work-tree 2>/dev/null', { encoding: 'utf8' });
+      gitOk = true;
+    } catch { /* not a git repo */ }
+
+    if (gitOk) {
+      let hasRemote = false;
+      try {
+        const remote = execSync('git remote get-url origin 2>/dev/null', { encoding: 'utf8' }).trim();
+        hasRemote = !!remote;
+        console.log(`  ${icon(true)}  Git remote: ${chalk.dim(remote)}`);
+      } catch { /* no remote */ }
+
+      if (!hasRemote) {
+        console.log(`  ${icon(false)}  Git remote not configured`);
+        setupActions.push(`  Run: ${chalk.bold('git remote add origin <your-repo-url>')}`);
+      }
+    } else {
+      console.log(`  ${icon(false)}  Not a git repository`);
+      setupActions.push(`  Run: ${chalk.bold('git init')} to initialize`);
+    }
+  }
+
+  // GitHub CLI: check auth status
+  if (toolResults.gh?.ok) {
+    try {
+      const ghStatus = execSync('gh auth status 2>&1', { encoding: 'utf8', timeout: 5000 });
+      const loggedIn = ghStatus.includes('Logged in');
+      console.log(`  ${icon(loggedIn)}  GitHub CLI auth`);
+      if (!loggedIn) {
+        setupActions.push(`  Run: ${chalk.bold('gh auth login')}`);
+      }
+    } catch {
+      console.log(`  ${icon(false)}  GitHub CLI auth`);
+      setupActions.push(`  Run: ${chalk.bold('gh auth login')}`);
+    }
+  }
+
+  // Claude: check if authenticated
+  if (toolResults.claude?.ok) {
+    // Claude Code doesn't have a simple auth-check command
+    // We just note that it needs to be run interactively once
+    console.log(`  ${icon(true)}  Claude Code CLI installed`);
+    console.log(chalk.dim(`     Auth is handled by Claude Code on first run`));
+  }
+
+  // Copilot: check if config exists
+  if (toolResults.copilot?.ok) {
+    const copilotConfig = resolve(process.env.HOME || '', '.copilot', 'config.json');
+    const hasConfig = existsSync(copilotConfig);
+    console.log(`  ${icon(hasConfig)}  Copilot CLI config`);
+    if (!hasConfig) {
+      setupActions.push(`  Run: ${chalk.bold('copilot auth login')}`);
+    }
+  }
+
+  // Gemini: check if credentials cached
+  if (toolResults.gemini?.ok) {
+    const geminiCache = resolve(process.env.HOME || '', '.gemini');
+    const hasCache = existsSync(geminiCache);
+    console.log(`  ${icon(hasCache)}  Gemini CLI credentials`);
+    if (!hasCache) {
+      setupActions.push(`  Run: ${chalk.bold('gemini')} and follow the auth flow`);
+    }
+  }
+
+  if (setupActions.length) {
+    console.log(chalk.yellow('\n  Actions needed:'));
+    setupActions.forEach(a => console.log(chalk.white(`    ${a}`)));
+  } else {
+    console.log(chalk.green('\n  All tools authenticated!'));
+  }
+
+  return setupActions;
+}
+
+// ─── Phase 4: Telegram Setup ────────────────────────────────────────────────
+
+async function phaseTelegram(envPrefix, cwd) {
+  console.log(chalk.cyan.bold('\n  ── Phase 4: Telegram Bot (optional) ──\n'));
+
+  const { setupTelegram } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setupTelegram',
+    message: 'Set up Telegram bot for remote pipeline control?',
+    default: false,
+  }]);
+
+  if (!setupTelegram) {
+    console.log(chalk.dim('  Skipped. You can set this up later.\n'));
+    return null;
+  }
+
+  console.log('');
+  console.log(chalk.dim('  To get a bot token:'));
+  console.log(chalk.dim('    1. Open Telegram and talk to @BotFather'));
+  console.log(chalk.dim('    2. Send /newbot and follow the prompts'));
+  console.log(chalk.dim('    3. Copy the token you receive'));
+  console.log('');
+
+  const telegram = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'token',
+      message: `Telegram bot token (${envPrefix}_TELEGRAM_TOKEN):`,
+      default: '',
+    },
+    {
+      type: 'input',
+      name: 'chatId',
+      message: `Telegram chat ID for notifications (${envPrefix}_TELEGRAM_CHAT_ID):`,
+      default: '',
+      when: (a) => a.token,
+    },
+    {
+      type: 'input',
+      name: 'allowedIds',
+      message: `Allowed user IDs, comma-separated (${envPrefix}_TELEGRAM_ALLOWED_IDS):`,
+      default: '',
+      when: (a) => a.token,
+    },
+  ]);
+
+  if (!telegram.token) {
+    console.log(chalk.dim('  No token provided. Skipping.\n'));
+    return null;
+  }
+
+  // Write to .env file
+  const envLines = [`${envPrefix}_TELEGRAM_TOKEN=${telegram.token}`];
+  if (telegram.chatId) envLines.push(`${envPrefix}_TELEGRAM_CHAT_ID=${telegram.chatId}`);
+  if (telegram.allowedIds) envLines.push(`${envPrefix}_TELEGRAM_ALLOWED_IDS=${telegram.allowedIds}`);
+
+  const envPath = resolve(cwd, '.env');
+  const envContent = '\n# AI Control Center — Telegram Bot\n' + envLines.join('\n') + '\n';
+
+  if (existsSync(envPath)) {
+    const current = readFileSync(envPath, 'utf8');
+    if (!current.includes(`${envPrefix}_TELEGRAM_TOKEN`)) {
+      appendFileSync(envPath, envContent);
+      console.log(chalk.green(`  ✓  Appended Telegram config to .env`));
+    } else {
+      console.log(chalk.yellow(`  ~  ${envPrefix}_TELEGRAM_TOKEN already exists in .env`));
+    }
+  } else {
+    writeFileSync(envPath, envContent.trimStart());
+    console.log(chalk.green(`  ✓  Created .env with Telegram config`));
+  }
+
+  // Ensure .env is in .gitignore
+  const gitignorePath = resolve(cwd, '.gitignore');
+  if (existsSync(gitignorePath)) {
+    const gitignore = readFileSync(gitignorePath, 'utf8');
+    if (!gitignore.includes('.env')) {
+      appendFileSync(gitignorePath, '\n# Environment variables (secrets)\n.env\n');
+      console.log(chalk.green(`  ✓  Added .env to .gitignore`));
+    }
+  }
+
+  return telegram;
+}
+
+// ─── Phase 4b: Twitch Setup ──────────────────────────────────────────────────
+
+async function phaseTwitch(envPrefix, cwd) {
+  console.log(chalk.cyan.bold('\n  ── Phase 4b: Twitch Bot (optional) ──\n'));
+
+  const { setupTwitch } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setupTwitch',
+    message: 'Set up Twitch bot for remote pipeline control?',
+    default: false,
+  }]);
+
+  if (!setupTwitch) {
+    console.log(chalk.dim('  Skipped. You can set this up later.\n'));
+    return null;
+  }
+
+  console.log('');
+  console.log(chalk.dim('  To get credentials:'));
+  console.log(chalk.dim('    1. Create an app at https://dev.twitch.tv/console'));
+  console.log(chalk.dim('    2. Generate an OAuth token with chat:read and chat:edit scopes'));
+  console.log(chalk.dim('    3. Find your Twitch user ID at https://www.streamweasels.com/tools/convert-twitch-username-to-user-id/'));
+  console.log('');
+
+  const twitch = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'channel',
+      message: `Twitch channel to join (${envPrefix}_TWITCH_CHANNEL):`,
+      default: '',
+      validate: (v) => {
+        if (!v || !v.trim()) return true; // optional — skip validation if empty
+        if (/\s/.test(v.trim())) return 'Channel name cannot contain spaces';
+        return true;
+      },
+      filter: (v) => v.trim().toLowerCase().replace(/^#/, ''), // normalize: strip # and lowercase
+    },
+    {
+      type: 'input',
+      name: 'accessToken',
+      message: `OAuth access token (${envPrefix}_TWITCH_ACCESS_TOKEN):`,
+      default: '',
+      when: (a) => !!a.channel,
+      validate: (v) => {
+        if (!v || !v.trim()) return 'Access token is required to run the bot';
+        return true;
+      },
+      filter: (v) => v.trim().replace(/^oauth:/, ''), // strip oauth: prefix if user pastes full token
+    },
+    {
+      type: 'input',
+      name: 'clientId',
+      message: `Client ID (${envPrefix}_TWITCH_CLIENT_ID):`,
+      default: '',
+      when: (a) => !!a.accessToken,
+      filter: (v) => v.trim(),
+    },
+    {
+      type: 'input',
+      name: 'clientSecret',
+      message: `Client secret (${envPrefix}_TWITCH_CLIENT_SECRET, optional):`,
+      default: '',
+      when: (a) => !!a.clientId,
+      filter: (v) => v.trim(),
+    },
+    {
+      type: 'input',
+      name: 'allowedIds',
+      message: `Allowed Twitch user IDs, comma-separated (${envPrefix}_TWITCH_ALLOWED_IDS):`,
+      default: '',
+      when: (a) => !!a.accessToken,
+      validate: (v) => {
+        if (!v || !v.trim()) return true; // optional
+        const ids = v.split(',').map(s => s.trim()).filter(Boolean);
+        if (ids.some(id => !/^\d+$/.test(id))) {
+          return 'Twitch user IDs must be numeric (e.g. 12345678). Find yours at id.twitch.tv/oauth2/validate';
+        }
+        return true;
+      },
+      filter: (v) => v.split(',').map(s => s.trim()).filter(Boolean).join(','),
+    },
+  ]);
+
+  if (!twitch.channel || !twitch.accessToken) {
+    console.log(chalk.dim('  No channel or token provided. Skipping.\n'));
+    return null;
+  }
+
+  // Write to .env file
+  const envLines = [
+    `${envPrefix}_TWITCH_CHANNEL=${twitch.channel}`,
+    `${envPrefix}_TWITCH_ACCESS_TOKEN=${twitch.accessToken}`,
+  ];
+  if (twitch.clientId)     envLines.push(`${envPrefix}_TWITCH_CLIENT_ID=${twitch.clientId}`);
+  if (twitch.clientSecret) envLines.push(`${envPrefix}_TWITCH_CLIENT_SECRET=${twitch.clientSecret}`);
+  if (twitch.allowedIds)   envLines.push(`${envPrefix}_TWITCH_ALLOWED_IDS=${twitch.allowedIds}`);
+
+  const envPath = resolve(cwd, '.env');
+  const envContent = '\n# AI Control Center — Twitch Bot\n' + envLines.join('\n') + '\n';
+
+  if (existsSync(envPath)) {
+    const current = readFileSync(envPath, 'utf8');
+    if (!current.includes(`${envPrefix}_TWITCH_CHANNEL`)) {
+      appendFileSync(envPath, envContent);
+      console.log(chalk.green(`  ✓  Appended Twitch config to .env`));
+    } else {
+      console.log(chalk.yellow(`  ~  ${envPrefix}_TWITCH_CHANNEL already exists in .env`));
+    }
+  } else {
+    writeFileSync(envPath, envContent.trimStart());
+    console.log(chalk.green(`  ✓  Created .env with Twitch config`));
+  }
+
+  // Ensure .env is in .gitignore
+  const gitignorePath = resolve(cwd, '.gitignore');
+  if (existsSync(gitignorePath)) {
+    const gitignore = readFileSync(gitignorePath, 'utf8');
+    if (!gitignore.includes('.env')) {
+      appendFileSync(gitignorePath, '\n# Environment variables (secrets)\n.env\n');
+      console.log(chalk.green(`  ✓  Added .env to .gitignore`));
+    }
+  }
+
+  console.log(chalk.green(`\n  ✓  Twitch bot configured. Run: aicc twitch\n`));
+  return twitch;
+}
+
+// ─── Phase 5: AI Mode Configuration ────────────────────────────────────────
+
+async function phaseAIMode(envPrefix, toolResults, cwd) {
+  console.log(chalk.cyan.bold('\n  ── Phase 5: AI Mode Configuration ──\n'));
+
+  const choices = [];
+  if (toolResults.ollama?.ok) {
+    choices.push({ name: 'Hybrid — Ollama for light tasks, cloud AI for heavy (recommended)', value: 'hybrid' });
+    choices.push({ name: 'Local only — Ollama only, no cloud fallback', value: 'local' });
+  }
+  choices.push({ name: 'Cloud only — Use cloud AI CLIs for everything', value: 'cloud' });
+
+  const { aiMode } = await inquirer.prompt([{
+    type: 'list',
+    name: 'aiMode',
+    message: 'AI execution mode:',
+    choices,
+    default: toolResults.ollama?.ok ? 'hybrid' : 'cloud',
+  }]);
+
+  // Write AI_MODE to .env
+  const envPath = resolve(cwd, '.env');
+  const envLine = `\n# AI execution mode (hybrid | cloud | local)\n${envPrefix}_AI_MODE=${aiMode}\n`;
+
+  if (existsSync(envPath)) {
+    const current = readFileSync(envPath, 'utf8');
+    if (!current.includes(`${envPrefix}_AI_MODE`)) {
+      appendFileSync(envPath, envLine);
+    }
+  } else {
+    writeFileSync(envPath, envLine.trimStart());
+  }
+
+  console.log(chalk.green(`  ✓  AI mode set to: ${aiMode}`));
+  return aiMode;
+}
+
+// ─── Phase 6: AI Pipeline Files (skills, agents, roles) ─────────────────────
+
+function loadTemplate(name) {
+  const templateDir = resolve(__dirname, '../../templates');
+  return readFileSync(resolve(templateDir, name), 'utf8');
+}
+
+function renderTemplate(content, vars) {
+  return content
+    .replace(/\{\{PROJECT_NAME\}\}/g, vars.name)
+    .replace(/\{\{PROJECT_DESCRIPTION\}\}/g, vars.description || `A project managed by AI Control Center.`)
+    .replace(/\{\{DESCRIPTION\}\}/g, vars.description || `A project managed by AI Control Center.`)
+    .replace(/\{\{PROJECT_ROOT\}\}/g, vars.root || process.cwd())
+    .replace(/\{\{WORKFLOW_DIR\}\}/g, vars.workflowDir || '.ai-workflow');
+}
+
+function writeIfMissing(filePath, content, label) {
+  if (existsSync(filePath)) {
+    console.log(chalk.dim(`  ·  ${label} (already exists)`));
+    return false;
+  }
+  const dir = resolve(filePath, '..');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, content);
+  console.log(chalk.green(`  ✓  ${label}`));
+  return true;
+}
+
+async function phaseAIPipeline(answers, toolResults, cwd) {
+  console.log(chalk.cyan.bold('\n  ── Phase 6: AI Pipeline Files ──\n'));
+
+  console.log(chalk.dim('  The pipeline needs skill files, agent definitions, and role files'));
+  console.log(chalk.dim('  to instruct each AI tool (Claude, Copilot, Gemini) what to do.\n'));
+
+  const { setupFiles } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setupFiles',
+    message: 'Create AI pipeline files (skills, agents, role files)?',
+    default: true,
+  }]);
+
+  if (!setupFiles) {
+    console.log(chalk.dim('  Skipped. You can create these manually later.\n'));
+    return { skillsCreated: false };
+  }
+
+  const vars = { name: answers.name, description: answers.description, root: cwd, workflowDir: answers.workflowDir };
+  const skillsDir = resolve(cwd, answers.skillsDir);
+  const agentsDir = resolve(cwd, '.claude/agents');
+  const githubDir = resolve(cwd, '.github');
+  let filesCreated = 0;
+
+  // ── Pipeline skills (auto-created, no user input needed)
+  // These are internal prompt templates for each AI stage in the pipeline.
+  const skillNames = {
+    architect: 'architect',
+    implement: 'copilot-implement',
+    review: 'code-review',
+  };
+
+  console.log(chalk.white('\n  Pipeline skills (prompt templates for each AI stage):'));
+
+  if (writeIfMissing(
+    resolve(skillsDir, `${skillNames.architect}.md`),
+    renderTemplate(loadTemplate('skill-architect.md'), vars),
+    `${answers.skillsDir}/${skillNames.architect}.md  ${chalk.dim('← Claude architect prompt')}`
+  )) filesCreated++;
+
+  if (writeIfMissing(
+    resolve(skillsDir, `${skillNames.implement}.md`),
+    renderTemplate(loadTemplate('skill-implement.md'), vars),
+    `${answers.skillsDir}/${skillNames.implement}.md  ${chalk.dim('← Copilot implementation prompt')}`
+  )) filesCreated++;
+
+  if (writeIfMissing(
+    resolve(skillsDir, `${skillNames.review}.md`),
+    renderTemplate(loadTemplate('skill-review.md'), vars),
+    `${answers.skillsDir}/${skillNames.review}.md  ${chalk.dim('← Gemini code review prompt')}`
+  )) filesCreated++;
+
+  // ── Chatbot skill (AI's "employee manual" for Telegram/Web natural conversation)
+  console.log(chalk.white('\n  Chatbot skill (natural conversation + intent detection):'));
+
+  if (writeIfMissing(
+    resolve(skillsDir, 'chatbot.md'),
+    renderTemplate(loadTemplate('skill-chatbot.md'), vars),
+    `${answers.skillsDir}/chatbot.md  ${chalk.dim('← AI chatbot behavior rules')}`
+  )) filesCreated++;
+
+  // ── OpenClaw skill (for openclaw gateway integration)
+  console.log(chalk.white('\n  OpenClaw skill (gateway AI integration):'));
+
+  const openclawSkillDir = resolve(cwd, '.openclaw/skills/aicc');
+  if (writeIfMissing(
+    resolve(openclawSkillDir, 'SKILL.md'),
+    renderTemplate(loadTemplate('skill-openclaw.md'), vars),
+    `.openclaw/skills/aicc/SKILL.md  ${chalk.dim('← OpenClaw pipeline skill')}`
+  )) filesCreated++;
+
+  // ── Agent definitions (for Claude Code agent system)
+  console.log(chalk.white('\n  Agents (Claude Code agent definitions):'));
+
+  if (writeIfMissing(
+    resolve(agentsDir, 'architect.agent.md'),
+    loadTemplate('agent-architect.md'),
+    `.claude/agents/architect.agent.md`
+  )) filesCreated++;
+
+  if (toolResults.gemini?.ok) {
+    if (writeIfMissing(
+      resolve(agentsDir, 'gemini-pm.agent.md'),
+      loadTemplate('agent-gemini-pm.md'),
+      `.claude/agents/gemini-pm.agent.md`
+    )) filesCreated++;
+
+    if (writeIfMissing(
+      resolve(agentsDir, 'gemini-reviewer.agent.md'),
+      loadTemplate('agent-gemini-reviewer.md'),
+      `.claude/agents/gemini-reviewer.agent.md`
+    )) filesCreated++;
+  }
+
+  // ── Role files (loaded at runtime by pipeline actions)
+  console.log(chalk.white('\n  Role files (AI instructions):'));
+
+  if (toolResults.gemini?.ok || toolResults.claude?.ok) {
+    if (writeIfMissing(
+      resolve(cwd, 'GEMINI.md'),
+      renderTemplate(loadTemplate('role-gemini.md'), vars),
+      `GEMINI.md (Gemini PM + Reviewer role)`
+    )) filesCreated++;
+  }
+
+  if (toolResults.copilot?.ok) {
+    if (writeIfMissing(
+      resolve(githubDir, 'copilot-instructions.md'),
+      renderTemplate(loadTemplate('copilot-instructions.md'), vars),
+      `.github/copilot-instructions.md`
+    )) filesCreated++;
+  }
+
+  // ── Fetch technology-specific skills from antigravity-awesome-skills ──
+  const preset = answers._preset;
+  let fetchedTechSkills = [];
+  if (preset && preset.skills && preset.skills.length > 0) {
+    console.log(chalk.white('\n  Technology skills (from antigravity-awesome-skills):'));
+    const results = await fetchSkills(preset.skills, skillsDir);
+    printFetchResults(results);
+    fetchedTechSkills = results.filter(r => r.status === 'ok' || r.status === 'exists').map(r => r.name);
+  }
+
+  // ── Additional workflow subdirectories
+  const extraDirs = ['inbox', 'implementation-notes', 'deploy-fixes', 'sessions', 'rejected'];
+  const workflowDir = resolve(cwd, answers.workflowDir);
+  for (const sub of extraDirs) {
+    mkdirSync(resolve(workflowDir, sub), { recursive: true });
+  }
+
+  console.log(chalk.green(`\n  ✓  ${filesCreated} files created`));
+
+  return { skillsCreated: true, skillNames, techSkills: fetchedTechSkills };
+}
+
+// ─── Main: Run All Phases ───────────────────────────────────────────────────
+
+export async function runInit() {
+  const cwd = process.cwd();
+  const configPath = resolve(cwd, 'aicc.config.js');
+
+  console.log('');
+  console.log(chalk.cyan.bold('  ◆  AI Control Center — Project Setup'));
+  console.log(chalk.dim('  ' + '─'.repeat(50)));
+  console.log('');
+
+  // Warn if config already exists
+  if (existsSync(configPath)) {
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'overwrite',
+      message: 'aicc.config.js already exists. Overwrite?',
+      default: false,
+    }]);
+    if (!overwrite) {
+      console.log(chalk.yellow('\n  Aborted.\n'));
+      return;
+    }
+  }
+
+  // ── Phase 1: Project config
+  const answers = await phaseProjectConfig(cwd);
+
+  // ── Phase 2: Tool verification
+  const toolResults = await phaseToolCheck(answers.envPrefix);
+
+  // ── Phase 3: Auth & credentials
+  const authActions = await phaseAuth(toolResults, answers.envPrefix);
+
+  // ── Phase 4: Telegram (optional)
+  const telegram = await phaseTelegram(answers.envPrefix, cwd);
+
+  // ── Phase 4b: Twitch (optional)
+  const twitch = await phaseTwitch(answers.envPrefix, cwd);
+
+  // ── Phase 5: AI mode
+  const aiMode = await phaseAIMode(answers.envPrefix, toolResults, cwd);
+
+  // ── Phase 6: AI pipeline files
+  const pipeline = await phaseAIPipeline(answers, toolResults, cwd);
+
+  // ── Write aicc.config.js ──────────────────────────────────────────────────
+
+  console.log(chalk.cyan.bold('\n  ── Writing Configuration ──\n'));
+
+  const extensions = answers.extensions
+    .split(',')
+    .map(e => e.trim())
+    .filter(Boolean)
+    .map(e => `'${e}'`)
+    .join(', ');
+
+  const preset = answers._preset || PROJECT_PRESETS.custom;
+  const aiSystemStr = preset.aiSystem
+    ? preset.aiSystem(answers.name).replace(/'/g, "\\'")
+    : `You are a concise DevOps assistant for ${answers.name}.`;
+
+  // Deploy block — include preset options if available
+  let deployBlock;
+  if (answers.deployCommand) {
+    const deployOpts = preset.deployOptions || [];
+    if (deployOpts.length > 0) {
+      const optsStr = deployOpts.map(o => `      { label: '${o.label}', value: '${o.value}' },`).join('\n');
+      deployBlock = `  deploy: {\n    command: '${answers.deployCommand}',\n    options: [\n${optsStr}\n    ],\n  },\n`;
+    } else {
+      deployBlock = `  deploy: {\n    command: '${answers.deployCommand}',\n    options: [],\n  },\n`;
+    }
+  } else {
+    deployBlock = `  deploy: { command: null, options: [] },\n`;
+  }
+
+  // Debug commands from preset
+  const debugCmds = preset.debugCommands || [];
+  const debugBlock = debugCmds.length > 0
+    ? `  debug: {\n    commands: [\n${debugCmds.map(c => `      { name: '${c.name}', command: '${c.command}' },`).join('\n')}\n    ],\n  },`
+    : `  debug: { commands: [] },`;
+
+  // Tech skills list
+  const techSkillsList = pipeline.techSkills || [];
+  const techSkillsStr = techSkillsList.length > 0
+    ? `\n    techSkills: [${techSkillsList.map(s => `'${s}'`).join(', ')}],`
+    : '';
+
+  const configContent = `export default {
+  name: '${answers.name}',
+  description: '${answers.description.replace(/'/g, "\\'")}',
+  projectType: '${answers.projectType}',
+  workflowDir: '${answers.workflowDir}',
+  skillsDir: '${answers.skillsDir}',
+  envPrefix: '${answers.envPrefix}',
+
+  stages: {
+    idle:                    { label: 'Idle',              color: 'gray' },
+    inbox:                   { label: 'Feature Submitted', color: 'yellow' },
+    spec_complete:           { label: 'PM Spec Ready',     color: 'cyan' },
+    arch_complete:           { label: 'Arch Ready',        color: 'blue' },
+    implementation_complete: { label: 'Code Done',         color: 'magenta' },
+    review_complete:         { label: 'Review Ready',      color: 'green' },
+    approved:                { label: 'Approved',          color: 'green' },
+    rejected:                { label: 'Rejected',          color: 'red' },
+    deployed:                { label: 'Deployed',          color: 'green' },
+  },
+
+${deployBlock}
+  review: {
+    extensions: [${extensions}],
+    sourceDir: '${answers.sourceDir}',
+  },
+
+  ai: {
+    system: '${aiSystemStr}',
+    roleFile: ${pipeline.skillsCreated ? "'GEMINI.md'" : 'null'},${pipeline.skillNames ? `
+    architectSkill: '${pipeline.skillNames.architect}',
+    implementSkill: '${pipeline.skillNames.implement}',
+    reviewSkill: '${pipeline.skillNames.review}',` : ''}${techSkillsStr}
+  },
+
+  queries: [],
+${debugBlock}
+  web: { port: ${parseInt(answers.webPort, 10) || 3847} },
+
+  // ─── Pipeline — which AI model runs each stage ─────────────────────────
+  // Each line = one stage. Change provider/model to switch instantly.
+  // provider: 'openclaw' | 'copilot' | 'claude' | 'gemini' | 'ollama'
+  // fallbacks: backup 'provider:model' pairs tried if primary fails
+  // Override at runtime: CLAUDE_MODEL=xxx GEMINI_MODEL=xxx aicc ...
+  pipeline: [
+    { stage: 'chat',      provider: 'openclaw', model: 'auto',               fallbacks: ['copilot:claude-haiku-4.5']                },
+    { stage: 'pm',        provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'architect', provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'implement', provider: 'claude',  model: 'claude-sonnet-4-6',  fallbacks: ['copilot:claude-sonnet-4.6', 'ollama']    },
+    { stage: 'review',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+    { stage: 'deploy',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
+  ],
+
+  // Ollama local fallback settings
+  ollama: { model: 'llama3.1', baseUrl: 'http://localhost:11434' },
+  plugins: [],
+
+  // ─── Roleplay / Multi-agent chat ─────────────────────────────────────────
+  // Enable the PM agent group chat in Telegram, Slack, and the web dashboard.
+  // The PM agent posts progress updates, handles errors, and asks for decisions.
+  roleplay: {
+    enabled: true,
+    verbosity: 'normal',          // 'minimal' | 'normal' | 'verbose'
+    pmPersonality: 'professional', // 'professional' | 'casual' | 'technical'
+    agentChat: true,              // Show agent-to-agent messages in the room
+    progressUpdates: true,        // PM posts "still working..." during long stages
+    progressInterval: 60000,      // How often to post progress updates (ms)
+    maxReviewCycles: 3,           // After N review cycles, PM auto-approves minor issues
+    autoDeployOnApproval: false,  // Auto-deploy when review is approved
+  },
+};
+`;
+
+  writeFileSync(configPath, configContent);
+  console.log(chalk.green(`  ✓  Created aicc.config.js`));
+
+  // Ensure package.json has "type": "module" (suppresses Node warning for ESM config)
+  const pkgJsonPath = resolve(cwd, 'package.json');
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+      if (!pkgJson.type) {
+        pkgJson.type = 'module';
+        writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n');
+        console.log(chalk.green(`  ✓  Added "type": "module" to package.json`));
+      }
+    } catch { /* skip if package.json is not valid JSON */ }
+  }
+
+  // Create workflow directory + status.json
+  const workflowDir = resolve(cwd, answers.workflowDir);
+  const subdirs = ['specs', 'architecture', 'tasks', 'reviews', 'approved', 'logs'];
+
+  mkdirSync(workflowDir, { recursive: true });
+  for (const sub of subdirs) {
+    mkdirSync(resolve(workflowDir, sub), { recursive: true });
+  }
+
+  const statusFile = resolve(workflowDir, 'status.json');
+  if (!existsSync(statusFile)) {
+    writeFileSync(statusFile, JSON.stringify({
+      stage: 'idle',
+      current_feature: null,
+      pipeline_mode: 'manual',
+    }, null, 2));
+  }
+  console.log(chalk.green(`  ✓  Created ${answers.workflowDir}/ with subdirectories`));
+
+  // Add logs to .gitignore
+  const gitignorePath = resolve(cwd, '.gitignore');
+  if (existsSync(gitignorePath)) {
+    const gitignore = readFileSync(gitignorePath, 'utf8');
+    if (!gitignore.includes(`${answers.workflowDir}/logs`)) {
+      appendFileSync(gitignorePath, `\n# AI workflow logs\n${answers.workflowDir}/logs/\n`);
+      console.log(chalk.green(`  ✓  Added ${answers.workflowDir}/logs/ to .gitignore`));
+    }
+  }
+
+  // ── Summary ─────────────────────────────────────────────────────────────────
+
+  console.log('');
+  console.log(chalk.dim('  ' + '─'.repeat(50)));
+  console.log(chalk.cyan.bold('\n  ◆  Setup Complete!\n'));
+
+  const typeLabel = PROJECT_TYPE_CHOICES.find(c => c.value === answers.projectType)?.name || answers.projectType;
+  console.log(chalk.white('  Configuration:'));
+  console.log(chalk.dim(`    Project:     ${answers.name}`));
+  console.log(chalk.dim(`    Type:        ${typeLabel}`));
+  console.log(chalk.dim(`    Prefix:      ${answers.envPrefix}`));
+  console.log(chalk.dim(`    AI Mode:     ${aiMode}`));
+  console.log(chalk.dim(`    Telegram:    ${telegram?.token ? 'configured' : 'not configured'}`));
+  console.log(chalk.dim(`    Web Port:    ${answers.webPort}`));
+
+  if (pipeline.skillsCreated) {
+    console.log('');
+    console.log(chalk.white('  Generated Files:'));
+    console.log(chalk.dim(`    Pipeline:    ${answers.skillsDir}/architect.md`));
+    console.log(chalk.dim(`                 ${answers.skillsDir}/copilot-implement.md`));
+    console.log(chalk.dim(`                 ${answers.skillsDir}/code-review.md`));
+    if (pipeline.techSkills && pipeline.techSkills.length > 0) {
+      console.log(chalk.green(`    Tech Skills: ${pipeline.techSkills.map(s => s + '.md').join(', ')}`));
+      console.log(chalk.dim(`                 (auto-downloaded from antigravity-awesome-skills)`));
+      console.log(chalk.dim(`                 AIs will follow these during architect/implement/review`));
+    }
+  }
+
+  if (authActions.length) {
+    console.log(chalk.yellow('\n  Remaining setup:'));
+    authActions.forEach(a => console.log(chalk.white(`    ${a}`)));
+  }
+
+  // ── Auto-start services ──────────────────────────────────────────────────────
+
+  console.log(chalk.cyan('\n  Starting services...'));
+
+  // 1. Generate OpenClaw skill (synchronous, quick)
+  try {
+    const openclawBin = spawnSync('which', ['openclaw'], { encoding: 'utf8' }).stdout.trim();
+    if (openclawBin) {
+      // Import and run generateSkill inline since config is not loaded yet via loadConfig()
+      // Instead, spawn aicc openclaw as a child so it loads config from the file we just wrote
+      const oc = spawnSync(process.execPath, [resolve(__dirname, '../../bin/aicc.js'), 'openclaw'], {
+        cwd, encoding: 'utf8', timeout: 15000,
+      });
+      if (oc.status === 0) {
+        console.log(chalk.green('  ✓  OpenClaw skill generated'));
+      } else {
+        console.log(chalk.yellow('  ~  OpenClaw skill generation skipped (openclaw gateway not running)'));
+      }
+    } else {
+      console.log(chalk.dim('  ·  OpenClaw CLI not installed — skipping'));
+    }
+  } catch {
+    console.log(chalk.dim('  ·  OpenClaw — skipped'));
+  }
+
+  // 2. Start web dashboard as detached background process
+  const webPort = parseInt(answers.webPort, 10) || 3847;
+  try {
+    const webProc = spawn(process.execPath, [resolve(__dirname, '../../bin/aicc.js'), 'web'], {
+      cwd,
+      stdio: 'ignore',
+      detached: true,
+      env: { ...process.env },
+    });
+    webProc.unref();
+    console.log(chalk.green(`  ✓  Web dashboard started → `) + chalk.cyan.bold(`http://localhost:${webPort}`));
+  } catch {
+    console.log(chalk.yellow(`  ~  Web dashboard failed to start. Run ${chalk.bold('aicc web')} manually.`));
+  }
+
+  // 3. Start Telegram bot as detached background process (if configured)
+  if (telegram?.token) {
+    try {
+      const tgProc = spawn(process.execPath, [resolve(__dirname, '../../bin/aicc.js'), 'telegram'], {
+        cwd,
+        stdio: 'ignore',
+        detached: true,
+        env: { ...process.env },
+      });
+      tgProc.unref();
+      console.log(chalk.green('  ✓  Telegram bot started'));
+    } catch {
+      console.log(chalk.yellow(`  ~  Telegram bot failed to start. Run ${chalk.bold('aicc telegram')} manually.`));
+    }
+  }
+
+  console.log('');
+  console.log(chalk.dim('  ' + '─'.repeat(50)));
+  console.log(chalk.cyan('\n  Quick reference:'));
+  console.log(chalk.white(`    ${chalk.bold('aicc')}             Launch terminal menu`));
+  console.log(chalk.white(`    ${chalk.bold('aicc web')}         Restart web dashboard`));
+  console.log(chalk.white(`    ${chalk.bold('aicc status')}      Check pipeline status`));
+  if (telegram?.token) {
+    console.log(chalk.white(`    ${chalk.bold('aicc telegram')}    Restart Telegram bot`));
+  }
+  console.log(chalk.white(`    ${chalk.bold('aicc openclaw')}    Regenerate OpenClaw skill`));
+  console.log('');
+}