@bugzy-ai/bugzy 1.2.0 → 1.3.0

package/dist/cli/index.js

@@ -560,7 +560,9 @@ Document all findings including:
 \`\`\`
 
 #### 3.2 Launch Test Runner Agent
-Invoke the test-runner agent with special exploration instructions:
+{{INVOKE_TEST_RUNNER}}
+
+Execute the exploration test case with special exploration instructions:
 
 \`\`\`
 Execute the exploration test case at ./test-cases/EXPLORATION-TEMP.md with focus on discovery and documentation.
@@ -1031,10 +1033,10 @@ Before invoking the agent, identify the test cases for the current area:
 
 #### Step 2.2: Invoke test-code-generator Agent
 
-Use the test-code-generator agent for the current area with the following context:
+{{INVOKE_TEST_CODE_GENERATOR}} for the current area with the following context:
 
 **Agent Invocation:**
-"Use the test-code-generator agent to automate test cases for the [AREA_NAME] area.
+"Automate test cases for the [AREA_NAME] area.
 
 **Context:**
 - Area: [AREA_NAME]
@@ -1174,10 +1176,10 @@ Provide a comprehensive summary showing:
           role: "documentation-researcher",
           contentBlock: `#### 1.4 Gather Product Documentation
 
-Use the documentation-researcher agent to gather comprehensive product documentation:
+{{INVOKE_DOCUMENTATION_RESEARCHER}} to gather comprehensive product documentation:
 
 \`\`\`
-Use the documentation-researcher agent to explore all available product documentation, specifically focusing on:
+Explore all available product documentation, specifically focusing on:
 - UI elements and workflows
 - User interactions and navigation paths
 - Form fields and validation rules
@@ -1191,10 +1193,9 @@ Use the documentation-researcher agent to explore all available product document
           role: "team-communicator",
           contentBlock: `### Step 4.5: Team Communication
 
-Use the team-communicator agent to notify the product team about the new test cases and automated tests:
+{{INVOKE_TEAM_COMMUNICATOR}} to notify the product team about the new test cases and automated tests:
 
 \`\`\`
-Use the team-communicator agent to:
 1. Post an update about test case and automation creation
 2. Provide summary of coverage:
    - Number of manual test cases created
@@ -1463,10 +1464,10 @@ Provide a summary of:
           role: "documentation-researcher",
           contentBlock: `### Step 2: Gather comprehensive project documentation
 
-Use the documentation-researcher agent to explore and gather all available project information and other documentation sources. This ensures the test plan is based on complete and current information.
+{{INVOKE_DOCUMENTATION_RESEARCHER}} to explore and gather all available project information and other documentation sources. This ensures the test plan is based on complete and current information.
 
 \`\`\`
-Use the documentation-researcher agent to explore all available project documentation related to: $ARGUMENTS
+Explore all available project documentation related to: $ARGUMENTS
 
 Specifically gather:
 - Product specifications and requirements
@@ -1491,10 +1492,9 @@ The agent will:
           role: "team-communicator",
           contentBlock: `### Step 7.5: Team Communication
 
-Use the team-communicator agent to notify the product team about the new test plan:
+{{INVOKE_TEAM_COMMUNICATOR}} to notify the product team about the new test plan:
 
 \`\`\`
-Use the team-communicator agent to:
 1. Post an update about the test plan creation
 2. Provide a brief summary of coverage areas and key features
 3. Mention any areas that need exploration or clarification
@@ -1747,7 +1747,7 @@ Classify the ambiguity level to determine appropriate response:
 #### Clarification Approach by Severity
 
 **For CRITICAL/HIGH ambiguity:**
-1. **Use team-communicator to ask specific questions**
+1. **{{INVOKE_TEAM_COMMUNICATOR}} to ask specific questions**
 2. **WAIT for response before proceeding**
 3. **Document the clarification request in event history**
 
@@ -2020,7 +2020,7 @@ ${KNOWLEDGE_BASE_UPDATE_INSTRUCTIONS}`,
           contentBlock: `#### 3.3 Use Documentation Researcher if Needed
 For events mentioning unknown features or components:
 \`\`\`
-Use documentation-researcher agent to find information about: [component/feature]
+{{INVOKE_DOCUMENTATION_RESEARCHER}} to find information about: [component/feature]
 \`\`\``
         },
         {
@@ -2029,7 +2029,7 @@ Use documentation-researcher agent to find information about: [component/feature
 
 When an issue needs to be tracked (task type: report_bug or update_story):
 \`\`\`
-Use issue-tracker agent to:
+{{INVOKE_ISSUE_TRACKER}}
 1. Check for duplicate issues in the tracking system
 2. For bugs: Create detailed bug report with:
    - Clear, descriptive title
@@ -2307,7 +2307,7 @@ For each failed test:
 For each test classified as **[TEST ISSUE]**, use the test-debugger-fixer agent to automatically fix the test:
 
 \`\`\`
-Use the test-debugger-fixer agent to fix test issues:
+{{INVOKE_TEST_DEBUGGER_FIXER}}
 
 For each failed test classified as a test issue (not a product bug), provide:
 - Test run timestamp: [from manifest.timestamp]
@@ -2402,7 +2402,7 @@ After triage in Step 5.1, for tests classified as **[PRODUCT BUG]**, use the iss
 For each bug to report, use the issue-tracker agent:
 
 \`\`\`
-Use issue-tracker agent to:
+{{INVOKE_ISSUE_TRACKER}}
 1. Check for duplicate bugs in the tracking system
    - The agent will automatically search for similar existing issues
    - It maintains memory of recently reported issues
@@ -2473,10 +2473,11 @@ After issue tracker agent completes, create a summary:
           role: "team-communicator",
           contentBlock: `### Step 6: Team Communication
 
-Use the team-communicator agent to notify the product team about test execution:
+{{INVOKE_TEAM_COMMUNICATOR}}
+
+Notify the product team about test execution:
 
 \`\`\`
-Use the team-communicator agent to:
 1. Post test execution summary with key statistics
 2. Highlight critical failures that need immediate attention
 3. Share important learnings about product behavior
@@ -2820,7 +2821,7 @@ Read and analyze the JSON report:
 For each test classified as **[TEST ISSUE]**, use the test-debugger-fixer agent to automatically fix the test:
 
 \`\`\`
-Use the test-debugger-fixer agent to fix test issues:
+{{INVOKE_TEST_DEBUGGER_FIXER}}
 
 For each failed test classified as a test issue (not a product bug), provide:
 - Test file path: [from JSON report]
@@ -2861,7 +2862,7 @@ Classification guidelines:
 #### 4A.4 Fix Test Issues Automatically
 
 For tests classified as [TEST ISSUE]:
-- Use test-debugger-fixer agent to analyze and fix
+- {{INVOKE_TEST_DEBUGGER_FIXER}} to analyze and fix
 - Agent debugs with browser if needed
 - Applies fix (selector update, wait condition, assertion correction)
 - Reruns test to verify fix (10x for flaky tests)
@@ -2877,7 +2878,7 @@ Track fixed tests with:
 {{ISSUE_TRACKER_INSTRUCTIONS}}
 
 For tests classified as [PRODUCT BUG]:
-- Use issue-tracker agent to create bug reports
+- {{INVOKE_ISSUE_TRACKER}} to create bug reports
 - Agent checks for duplicates automatically
 - Creates detailed report with:
   - Title, description, reproduction steps
@@ -3193,10 +3194,10 @@ Format as comprehensive markdown report for terminal display:
 
 {{TEAM_COMMUNICATOR_INSTRUCTIONS}}
 
-Use team-communicator agent to post concise results to Slack thread:
+{{INVOKE_TEAM_COMMUNICATOR}} to post concise results to Slack thread:
 
 \`\`\`
-Use the team-communicator agent to post verification results.
+Post verification results.
 
 **Channel**: [from CHANGE_CONTEXT.slackChannel]
 **Thread**: [from CHANGE_CONTEXT.slackThread]
@@ -3377,10 +3378,10 @@ A successful verification includes:
           role: "documentation-researcher",
           contentBlock: `#### Research Project Documentation
 
-Use the documentation-researcher agent to gather comprehensive context about the changed features:
+{{INVOKE_DOCUMENTATION_RESEARCHER}} to gather comprehensive context about the changed features:
 
 \`\`\`
-Use the documentation-researcher agent to explore project documentation related to the changes.
+Explore project documentation related to the changes.
 
 Specifically gather:
 - Product specifications for affected features
@@ -3412,10 +3413,9 @@ Use this information to:
           role: "issue-tracker",
           contentBlock: `#### Log Product Bugs
 
-For tests classified as **[PRODUCT BUG]**, use the issue-tracker agent to log bugs:
+For tests classified as **[PRODUCT BUG]**, {{INVOKE_ISSUE_TRACKER}} to log bugs:
 
 \`\`\`
-Use issue-tracker agent to:
 1. Check for duplicate bugs in the tracking system
    - The agent will automatically search for similar existing issues
    - It maintains memory of recently reported issues
@@ -3464,10 +3464,9 @@ Use issue-tracker agent to:
           role: "team-communicator",
           contentBlock: `#### Team Communication
 
-Use the team-communicator agent to share verification results (primarily for Slack trigger, but can be used for other triggers):
+{{INVOKE_TEAM_COMMUNICATOR}} to share verification results (primarily for Slack trigger, but can be used for other triggers):
 
 \`\`\`
-Use the team-communicator agent to:
 1. Post verification results summary
 2. Highlight critical failures that need immediate attention
 3. Share bugs logged with issue tracker links
@@ -3590,13 +3589,14 @@ var init_tasks = __esm({
 init_esm_shims();
 import { Command } from "commander";
 import { readFileSync as readFileSync5 } from "fs";
-import { join as join10, dirname as dirname3 } from "path";
+import { join as join12, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk3 from "chalk";
 
 // src/cli/commands/start.ts
 init_esm_shims();
 import { spawn } from "child_process";
+import * as path5 from "path";
 import chalk from "chalk";
 import ora from "ora";
 
@@ -3604,6 +3604,97 @@ import ora from "ora";
 init_esm_shims();
 import * as fs from "fs";
 import * as path2 from "path";
+
+// src/core/tool-profile.ts
+init_esm_shims();
+var DEFAULT_TOOL = "claude-code";
+var CLAUDE_CODE_PROFILE = {
+  id: "claude-code",
+  name: "Claude Code",
+  cliCommand: "claude",
+  commandsDir: ".claude/commands",
+  agentsDir: ".claude/agents",
+  mcpConfigPath: ".mcp.json",
+  mcpFormat: "json",
+  memoryFile: "CLAUDE.md",
+  commandFrontmatter: true,
+  agentFrontmatter: true,
+  commandInvocationPrefix: "/",
+  commandExtension: ".md",
+  agentExtension: ".md"
+};
+var CURSOR_PROFILE = {
+  id: "cursor",
+  name: "Cursor",
+  cliCommand: "cursor-agent",
+  commandsDir: ".cursor/commands",
+  agentsDir: ".cursor/agents",
+  mcpConfigPath: ".cursor/mcp.json",
+  mcpFormat: "json",
+  memoryFile: "AGENTS.md",
+  // Cursor now uses AGENTS.md (.cursorrules deprecated as of v0.45+)
+  commandFrontmatter: false,
+  // Cursor uses plain markdown
+  agentFrontmatter: false,
+  // Agent files are plain markdown for CLI invocation
+  commandInvocationPrefix: "/",
+  commandExtension: ".md",
+  agentExtension: ".md"
+};
+var CODEX_PROFILE = {
+  id: "codex",
+  name: "Codex CLI",
+  cliCommand: "codex",
+  commandsDir: ".codex/prompts",
+  // Codex uses prompts directory
+  agentsDir: ".codex/agents",
+  mcpConfigPath: ".codex/config.toml",
+  // Project-local via CODEX_HOME
+  mcpFormat: "toml",
+  homeEnvVar: "CODEX_HOME",
+  // Set to project root for project-local config
+  memoryFile: "AGENTS.md",
+  commandFrontmatter: true,
+  // Codex prompts support frontmatter
+  agentFrontmatter: false,
+  // Agent files are plain markdown for CLI invocation
+  commandInvocationPrefix: "/prompts:",
+  commandExtension: ".md",
+  agentExtension: ".md"
+};
+var TOOL_PROFILES = {
+  "claude-code": CLAUDE_CODE_PROFILE,
+  "cursor": CURSOR_PROFILE,
+  "codex": CODEX_PROFILE
+};
+function getToolProfile(toolId) {
+  const profile = TOOL_PROFILES[toolId];
+  if (!profile) {
+    throw new Error(`Unknown tool: ${toolId}`);
+  }
+  return profile;
+}
+function getToolOptions() {
+  return [
+    {
+      value: "claude-code",
+      label: "Claude Code (CLI or Cloud)",
+      hint: "Anthropic's official CLI - recommended"
+    },
+    {
+      value: "cursor",
+      label: "Cursor (Experimental)",
+      hint: "VS Code-based AI editor - experimental support"
+    },
+    {
+      value: "codex",
+      label: "Codex CLI (Experimental)",
+      hint: "OpenAI's terminal-based agent - experimental support"
+    }
+  ];
+}
+
+// src/cli/utils/config.ts
 async function loadConfig(configPath = ".bugzy/config.json") {
   const fullPath = path2.join(process.cwd(), configPath);
   if (!fs.existsSync(fullPath)) {
@@ -3612,6 +3703,9 @@ async function loadConfig(configPath = ".bugzy/config.json") {
   try {
     const content = fs.readFileSync(fullPath, "utf-8");
     const config = JSON.parse(content);
+    if (!config.tool) {
+      config.tool = DEFAULT_TOOL;
+    }
     return config;
   } catch (error) {
     console.error(`Error loading config from ${fullPath}:`, error);
@@ -3636,15 +3730,19 @@ function configExists(configPath = ".bugzy/config.json") {
   const fullPath = path2.join(process.cwd(), configPath);
   return fs.existsSync(fullPath);
 }
-function createDefaultConfig(projectName) {
+function createDefaultConfig(projectName, tool = DEFAULT_TOOL) {
   return {
     version: "1.0.0",
+    tool,
     project: {
       name: projectName
     },
     subagents: {}
   };
 }
+function getToolFromConfig(config) {
+  return config.tool || DEFAULT_TOOL;
+}
 
 // src/cli/utils/env.ts
 init_esm_shims();
@@ -3707,13 +3805,19 @@ function validateEnvVars(mcpServers, envVars) {
 init_esm_shims();
 import * as fs3 from "fs";
 import * as path4 from "path";
-function validateProjectStructure() {
+async function validateProjectStructure() {
+  const config = await loadConfig();
+  const tool = config ? getToolFromConfig(config) : DEFAULT_TOOL;
+  const toolProfile = getToolProfile(tool);
   const requiredDirs = [
     ".bugzy",
     ".bugzy/runtime",
-    ".claude",
-    ".claude/commands",
-    ".claude/agents"
+    path4.dirname(toolProfile.commandsDir),
+    // .claude, .cursor, or .codex
+    toolProfile.commandsDir,
+    // .claude/commands, .cursor/commands, .codex/prompts
+    toolProfile.agentsDir
+    // .claude/agents, .cursor/agents, .codex/agents
   ];
   const requiredFiles = [
     ".bugzy/config.json",
@@ -3739,10 +3843,10 @@ function validateProjectStructure() {
   }
   return true;
 }
-async function checkClaudeAvailable() {
+async function checkToolAvailable(command) {
   const { spawn: spawn2 } = await import("child_process");
   return new Promise((resolve) => {
-    const proc = spawn2("which", ["claude"]);
+    const proc = spawn2("which", [command]);
     proc.on("close", (code) => {
       resolve(code === 0);
     });
@@ -3787,9 +3891,11 @@ async function startSession(prompt) {
     process.exit(1);
   }
   spinner.succeed(chalk.green("Configuration loaded"));
+  const tool = getToolFromConfig(config);
+  const toolProfile = getToolProfile(tool);
   spinner = ora("Validating project structure").start();
   try {
-    validateProjectStructure();
+    await validateProjectStructure();
     spinner.succeed(chalk.green("Project structure validated"));
   } catch (error) {
     spinner.fail(chalk.red("Invalid project structure"));
@@ -3797,15 +3903,22 @@ async function startSession(prompt) {
     console.log(chalk.yellow("\nRun"), chalk.cyan("bugzy setup"), chalk.yellow("to fix the project structure"));
     process.exit(1);
   }
-  spinner = ora("Checking Claude Code availability").start();
-  const claudeAvailable = await checkClaudeAvailable();
-  if (!claudeAvailable) {
-    spinner.fail(chalk.red("Claude Code CLI not found"));
-    console.log(chalk.yellow("\nPlease install Claude Code:"));
-    console.log(chalk.cyan("  https://claude.com/claude-code"));
+  spinner = ora(`Checking ${toolProfile.name} availability`).start();
+  const toolAvailable = await checkToolAvailable(toolProfile.cliCommand);
+  if (!toolAvailable) {
+    spinner.fail(chalk.red(`${toolProfile.name} CLI not found`));
+    console.log(chalk.yellow(`
+Please install ${toolProfile.name}:`));
+    if (tool === "claude-code") {
+      console.log(chalk.cyan("  https://claude.com/claude-code"));
+    } else if (tool === "cursor") {
+      console.log(chalk.cyan("  https://www.cursor.com/"));
+    } else if (tool === "codex") {
+      console.log(chalk.cyan("  npm install -g @openai/codex"));
+    }
     process.exit(1);
   }
-  spinner.succeed(chalk.green("Claude Code CLI found"));
+  spinner.succeed(chalk.green(`${toolProfile.name} CLI found`));
   spinner = ora("Loading environment variables").start();
   const envVars = loadEnvFiles();
   const envCount = Object.keys(envVars).length;
@@ -3823,14 +3936,20 @@ async function startSession(prompt) {
     process.exit(1);
   }
   spinner.succeed(chalk.green("All required MCP secrets present"));
-  console.log(chalk.green.bold("\n\u{1F680} Launching Claude Code...\n"));
+  console.log(chalk.green.bold(`
+\u{1F680} Launching ${toolProfile.name}...
+`));
   const args = prompt ? [prompt] : [];
-  const claude = spawn("claude", args, {
+  const spawnEnv = { ...process.env, ...envVars };
+  if (toolProfile.homeEnvVar) {
+    spawnEnv[toolProfile.homeEnvVar] = path5.join(process.cwd(), ".codex");
+  }
+  const child = spawn(toolProfile.cliCommand, args, {
     cwd: process.cwd(),
-    env: { ...process.env, ...envVars },
+    env: spawnEnv,
     stdio: "inherit"
   });
-  claude.on("close", (code) => {
+  child.on("close", (code) => {
     if (code === 0) {
       console.log(chalk.green("\n\u2713 Session ended successfully"));
     } else {
@@ -3838,15 +3957,16 @@ async function startSession(prompt) {
 \u2713 Session ended (exit code: ${code})`));
     }
   });
-  claude.on("error", (error) => {
-    console.error(chalk.red("\n\u2717 Error launching Claude Code:"), error);
+  child.on("error", (error) => {
+    console.error(chalk.red(`
+\u2717 Error launching ${toolProfile.name}:`), error);
     process.exit(1);
   });
 }
 
 // src/cli/commands/setup.ts
 init_esm_shims();
-import * as path11 from "path";
+import * as path12 from "path";
 import chalk2 from "chalk";
 import inquirer from "inquirer";
 import ora2 from "ora";
@@ -6481,27 +6601,31 @@ function buildSubagentConfig(role, integration) {
 // src/cli/generators/structure.ts
 init_esm_shims();
 import * as fs4 from "fs";
-import * as path5 from "path";
-async function createProjectStructure() {
+import * as path6 from "path";
+async function createProjectStructure(tool = DEFAULT_TOOL) {
   const cwd = process.cwd();
+  const toolProfile = getToolProfile(tool);
   const bugzyDirs = [
     ".bugzy",
     ".bugzy/runtime",
     ".bugzy/runtime/templates"
   ];
   for (const dir of bugzyDirs) {
-    const dirPath = path5.join(cwd, dir);
+    const dirPath = path6.join(cwd, dir);
     if (!fs4.existsSync(dirPath)) {
       fs4.mkdirSync(dirPath, { recursive: true });
     }
   }
-  const claudeDirs = [
-    ".claude",
-    ".claude/commands",
-    ".claude/agents"
+  const toolDirs = [
+    path6.dirname(toolProfile.commandsDir),
+    // .claude, .cursor, or .codex
+    toolProfile.commandsDir,
+    // .claude/commands, .cursor/commands, .codex/prompts
+    toolProfile.agentsDir
+    // .claude/agents, .cursor/agents, .codex/agents
   ];
-  for (const dir of claudeDirs) {
-    const dirPath = path5.join(cwd, dir);
+  for (const dir of toolDirs) {
+    const dirPath = path6.join(cwd, dir);
     if (!fs4.existsSync(dirPath)) {
       fs4.mkdirSync(dirPath, { recursive: true });
     }
@@ -6509,69 +6633,69 @@ async function createProjectStructure() {
   await createRuntimeFiles();
 }
 function getTemplatesDir() {
-  return path5.join(__dirname, "../../templates/init");
+  return path6.join(__dirname, "../../templates/init");
 }
 async function createRuntimeFiles() {
   const cwd = process.cwd();
   const templatesDir = getTemplatesDir();
-  const projectContextPath = path5.join(cwd, ".bugzy/runtime/project-context.md");
+  const projectContextPath = path6.join(cwd, ".bugzy/runtime/project-context.md");
   if (!fs4.existsSync(projectContextPath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/project-context.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/project-context.md");
     let content = fs4.readFileSync(templatePath, "utf-8");
-    const projectName = path5.basename(cwd);
+    const projectName = path6.basename(cwd);
     content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
     content = content.replace(/\{\{CUSTOMER_NAME\}\}/g, "[To be filled]");
     content = content.replace(/\{\{BUG_TRACKING_SYSTEM\}\}/g, "[To be filled]");
     content = content.replace(/\{\{DOCUMENTATION_SYSTEM\}\}/g, "[To be filled]");
     fs4.writeFileSync(projectContextPath, content, "utf-8");
   }
-  const testPlanTemplatePath = path5.join(cwd, ".bugzy/runtime/templates/test-plan-template.md");
+  const testPlanTemplatePath = path6.join(cwd, ".bugzy/runtime/templates/test-plan-template.md");
   if (!fs4.existsSync(testPlanTemplatePath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/templates/test-plan-template.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/templates/test-plan-template.md");
     const content = fs4.readFileSync(templatePath, "utf-8");
     fs4.writeFileSync(testPlanTemplatePath, content, "utf-8");
   }
-  const bestPracticesPath = path5.join(cwd, ".bugzy/runtime/testing-best-practices.md");
+  const bestPracticesPath = path6.join(cwd, ".bugzy/runtime/testing-best-practices.md");
   if (!fs4.existsSync(bestPracticesPath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/testing-best-practices.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/testing-best-practices.md");
     const content = fs4.readFileSync(templatePath, "utf-8");
     fs4.writeFileSync(bestPracticesPath, content, "utf-8");
   }
-  const testResultSchemaPath = path5.join(cwd, ".bugzy/runtime/templates/test-result-schema.md");
+  const testResultSchemaPath = path6.join(cwd, ".bugzy/runtime/templates/test-result-schema.md");
   if (!fs4.existsSync(testResultSchemaPath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/templates/test-result-schema.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/templates/test-result-schema.md");
     if (fs4.existsSync(templatePath)) {
       const content = fs4.readFileSync(templatePath, "utf-8");
       fs4.writeFileSync(testResultSchemaPath, content, "utf-8");
     }
   }
-  const knowledgeBasePath = path5.join(cwd, ".bugzy/runtime/knowledge-base.md");
+  const knowledgeBasePath = path6.join(cwd, ".bugzy/runtime/knowledge-base.md");
   if (!fs4.existsSync(knowledgeBasePath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/knowledge-base.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/knowledge-base.md");
     if (fs4.existsSync(templatePath)) {
       const content = fs4.readFileSync(templatePath, "utf-8");
       fs4.writeFileSync(knowledgeBasePath, content, "utf-8");
     }
   }
-  const knowledgeMaintenancePath = path5.join(cwd, ".bugzy/runtime/knowledge-maintenance-guide.md");
+  const knowledgeMaintenancePath = path6.join(cwd, ".bugzy/runtime/knowledge-maintenance-guide.md");
   if (!fs4.existsSync(knowledgeMaintenancePath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/knowledge-maintenance-guide.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/knowledge-maintenance-guide.md");
     if (fs4.existsSync(templatePath)) {
       const content = fs4.readFileSync(templatePath, "utf-8");
       fs4.writeFileSync(knowledgeMaintenancePath, content, "utf-8");
     }
   }
-  const subagentMemoryPath = path5.join(cwd, ".bugzy/runtime/subagent-memory-guide.md");
+  const subagentMemoryPath = path6.join(cwd, ".bugzy/runtime/subagent-memory-guide.md");
   if (!fs4.existsSync(subagentMemoryPath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/subagent-memory-guide.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/subagent-memory-guide.md");
     if (fs4.existsSync(templatePath)) {
       const content = fs4.readFileSync(templatePath, "utf-8");
       fs4.writeFileSync(subagentMemoryPath, content, "utf-8");
     }
   }
-  const testExecutionStrategyPath = path5.join(cwd, ".bugzy/runtime/test-execution-strategy.md");
+  const testExecutionStrategyPath = path6.join(cwd, ".bugzy/runtime/test-execution-strategy.md");
   if (!fs4.existsSync(testExecutionStrategyPath)) {
-    const templatePath = path5.join(templatesDir, ".bugzy/runtime/test-execution-strategy.md");
+    const templatePath = path6.join(templatesDir, ".bugzy/runtime/test-execution-strategy.md");
     if (fs4.existsSync(templatePath)) {
       const content = fs4.readFileSync(templatePath, "utf-8");
       fs4.writeFileSync(testExecutionStrategyPath, content, "utf-8");
@@ -6581,18 +6705,28 @@ async function createRuntimeFiles() {
 async function generateClaudeMd() {
   const cwd = process.cwd();
   const templatesDir = getTemplatesDir();
-  const claudeMdPath = path5.join(cwd, "CLAUDE.md");
+  const claudeMdPath = path6.join(cwd, "CLAUDE.md");
   if (!fs4.existsSync(claudeMdPath)) {
-    const templatePath = path5.join(templatesDir, "CLAUDE.md");
+    const templatePath = path6.join(templatesDir, "CLAUDE.md");
     const content = fs4.readFileSync(templatePath, "utf-8");
     fs4.writeFileSync(claudeMdPath, content, "utf-8");
   }
 }
+async function generateAgentsMd() {
+  const cwd = process.cwd();
+  const templatesDir = getTemplatesDir();
+  const agentsMdPath = path6.join(cwd, "AGENTS.md");
+  if (!fs4.existsSync(agentsMdPath)) {
+    const templatePath = path6.join(templatesDir, "AGENTS.md");
+    const content = fs4.readFileSync(templatePath, "utf-8");
+    fs4.writeFileSync(agentsMdPath, content, "utf-8");
+  }
+}
 async function updateGitignore() {
   const cwd = process.cwd();
-  const gitignorePath = path5.join(cwd, ".gitignore");
+  const gitignorePath = path6.join(cwd, ".gitignore");
   const templatesDir = getTemplatesDir();
-  const templatePath = path5.join(templatesDir, ".gitignore-template");
+  const templatePath = path6.join(templatesDir, ".gitignore-template");
   const bugzyEntries = fs4.readFileSync(templatePath, "utf-8");
   if (fs4.existsSync(gitignorePath)) {
     const content = fs4.readFileSync(gitignorePath, "utf-8");
@@ -6608,7 +6742,7 @@ async function updateGitignore() {
 init_esm_shims();
 init_tasks();
 import * as fs5 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 
 // src/core/task-builder.ts
 init_esm_shims();
@@ -6657,22 +6791,80 @@ function buildTaskDefinition(taskSlug, projectSubAgents) {
   };
 }
 
+// src/core/tool-strings.ts
+init_esm_shims();
+var TOOL_STRINGS = {
+  "claude-code": {
+    INVOKE_TEST_RUNNER: "Use the test-runner subagent to execute the tests",
+    INVOKE_TEST_DEBUGGER_FIXER: "Use the test-debugger-fixer subagent to debug and fix the failing test",
+    INVOKE_TEST_CODE_GENERATOR: "Use the test-code-generator subagent to generate automated test code",
+    INVOKE_TEAM_COMMUNICATOR: "Use the team-communicator subagent to notify the team",
+    INVOKE_ISSUE_TRACKER: "Use the issue-tracker subagent to create or update issues",
+    INVOKE_DOCUMENTATION_RESEARCHER: "Use the documentation-researcher subagent to search and gather documentation"
+  },
+  "cursor": {
+    INVOKE_TEST_RUNNER: 'Run the test-runner agent:\n```bash\ncursor-agent -p "$(cat .cursor/agents/test-runner.md)" --output-format text\n```',
+    INVOKE_TEST_DEBUGGER_FIXER: 'Run the test-debugger-fixer agent:\n```bash\ncursor-agent -p "$(cat .cursor/agents/test-debugger-fixer.md)" --output-format text\n```',
+    INVOKE_TEST_CODE_GENERATOR: 'Run the test-code-generator agent:\n```bash\ncursor-agent -p "$(cat .cursor/agents/test-code-generator.md)" --output-format text\n```',
+    INVOKE_TEAM_COMMUNICATOR: 'Run the team-communicator agent:\n```bash\ncursor-agent -p "$(cat .cursor/agents/team-communicator.md)" --output-format text\n```',
+    INVOKE_ISSUE_TRACKER: 'Run the issue-tracker agent:\n```bash\ncursor-agent -p "$(cat .cursor/agents/issue-tracker.md)" --output-format text\n```',
+    INVOKE_DOCUMENTATION_RESEARCHER: 'Run the documentation-researcher agent:\n```bash\ncursor-agent -p "$(cat .cursor/agents/documentation-researcher.md)" --output-format text\n```'
+  },
+  "codex": {
+    INVOKE_TEST_RUNNER: 'Run the test-runner agent:\n```bash\ncodex -p "$(cat .codex/agents/test-runner.md)"\n```',
+    INVOKE_TEST_DEBUGGER_FIXER: 'Run the test-debugger-fixer agent:\n```bash\ncodex -p "$(cat .codex/agents/test-debugger-fixer.md)"\n```',
+    INVOKE_TEST_CODE_GENERATOR: 'Run the test-code-generator agent:\n```bash\ncodex -p "$(cat .codex/agents/test-code-generator.md)"\n```',
+    INVOKE_TEAM_COMMUNICATOR: 'Run the team-communicator agent:\n```bash\ncodex -p "$(cat .codex/agents/team-communicator.md)"\n```',
+    INVOKE_ISSUE_TRACKER: 'Run the issue-tracker agent:\n```bash\ncodex -p "$(cat .codex/agents/issue-tracker.md)"\n```',
+    INVOKE_DOCUMENTATION_RESEARCHER: 'Run the documentation-researcher agent:\n```bash\ncodex -p "$(cat .codex/agents/documentation-researcher.md)"\n```'
+  }
+};
+function getToolString(toolId, key) {
+  const toolStrings = TOOL_STRINGS[toolId];
+  if (!toolStrings) {
+    throw new Error(`Unknown tool: ${toolId}`);
+  }
+  const value = toolStrings[key];
+  if (!value) {
+    throw new Error(`Unknown string key: ${key} for tool: ${toolId}`);
+  }
+  return value;
+}
+function replaceInvocationPlaceholders(content, toolId) {
+  let result = content;
+  const keys = [
+    "INVOKE_TEST_RUNNER",
+    "INVOKE_TEST_DEBUGGER_FIXER",
+    "INVOKE_TEST_CODE_GENERATOR",
+    "INVOKE_TEAM_COMMUNICATOR",
+    "INVOKE_ISSUE_TRACKER",
+    "INVOKE_DOCUMENTATION_RESEARCHER"
+  ];
+  for (const key of keys) {
+    const placeholder = `{{${key}}}`;
+    const replacement = getToolString(toolId, key);
+    result = result.replace(new RegExp(placeholder, "g"), replacement);
+  }
+  return result;
+}
+
 // src/cli/generators/commands.ts
 var COMMAND_FILTER = {
   // Cloud-only commands (skip in local environment)
   "handle-message": false,
   "process-event": false
 };
-async function generateCommands(subagents) {
+async function generateCommands(subagents, tool = DEFAULT_TOOL) {
   const cwd = process.cwd();
-  const commandsDir = path6.join(cwd, ".claude", "commands");
+  const toolProfile = getToolProfile(tool);
+  const commandsDir = path7.join(cwd, toolProfile.commandsDir);
   if (!fs5.existsSync(commandsDir)) {
     fs5.mkdirSync(commandsDir, { recursive: true });
   }
   const existingFiles = fs5.readdirSync(commandsDir);
   for (const file of existingFiles) {
     if (file.endsWith(".md")) {
-      fs5.unlinkSync(path6.join(commandsDir, file));
+      fs5.unlinkSync(path7.join(commandsDir, file));
     }
   }
   const projectSubAgents = Object.entries(subagents).map(
@@ -6686,18 +6878,35 @@ async function generateCommands(subagents) {
     const outputSlug = typeof filterValue === "string" ? filterValue : slug;
     try {
       const taskDef = buildTaskDefinition(slug, projectSubAgents);
-      const content = formatCommandMarkdown(taskDef.frontmatter, taskDef.content);
-      const filePath = path6.join(commandsDir, `${outputSlug}.md`);
+      const processedContent = replaceInvocationPlaceholders(taskDef.content, tool);
+      const content = formatCommandMarkdown(taskDef.frontmatter, processedContent, toolProfile.commandFrontmatter);
+      const fileName = `${outputSlug}${toolProfile.commandExtension}`;
+      const filePath = path7.join(commandsDir, fileName);
       fs5.writeFileSync(filePath, content, "utf-8");
     } catch (error) {
-      const content = formatCommandMarkdown(template.frontmatter, template.baseContent);
-      const filePath = path6.join(commandsDir, `${outputSlug}.md`);
+      const processedContent = replaceInvocationPlaceholders(template.baseContent, tool);
+      const content = formatCommandMarkdown(template.frontmatter, processedContent, toolProfile.commandFrontmatter);
+      const fileName = `${outputSlug}${toolProfile.commandExtension}`;
+      const filePath = path7.join(commandsDir, fileName);
       fs5.writeFileSync(filePath, content, "utf-8");
       console.warn(`Warning: Generated ${outputSlug} without required subagents: ${error.message}`);
     }
   }
 }
-function formatCommandMarkdown(frontmatter, content) {
+function formatCommandMarkdown(frontmatter, content, includeFrontmatter) {
+  if (!includeFrontmatter) {
+    const lines2 = [];
+    if (frontmatter.description) {
+      lines2.push(`# ${frontmatter.description}`);
+      lines2.push("");
+    }
+    if (frontmatter["argument-hint"]) {
+      lines2.push(`**Arguments**: ${frontmatter["argument-hint"]}`);
+      lines2.push("");
+    }
+    lines2.push(content);
+    return lines2.join("\n");
+  }
   const lines = ["---"];
   for (const [key, value] of Object.entries(frontmatter)) {
     if (value !== void 0 && value !== null) {
@@ -6714,17 +6923,18 @@ function formatCommandMarkdown(frontmatter, content) {
 // src/cli/generators/agents.ts
 init_esm_shims();
 import * as fs6 from "fs";
-import * as path7 from "path";
-async function generateAgents(subagents) {
+import * as path8 from "path";
+async function generateAgents(subagents, tool = DEFAULT_TOOL) {
   const cwd = process.cwd();
-  const agentsDir = path7.join(cwd, ".claude", "agents");
+  const toolProfile = getToolProfile(tool);
+  const agentsDir = path8.join(cwd, toolProfile.agentsDir);
   if (!fs6.existsSync(agentsDir)) {
     fs6.mkdirSync(agentsDir, { recursive: true });
   }
   const existingFiles = fs6.readdirSync(agentsDir);
   for (const file of existingFiles) {
     if (file.endsWith(".md")) {
-      fs6.unlinkSync(path7.join(agentsDir, file));
+      fs6.unlinkSync(path8.join(agentsDir, file));
     }
   }
   for (const [role, integration] of Object.entries(subagents)) {
@@ -6733,12 +6943,16 @@ async function generateAgents(subagents) {
       console.warn(`Warning: Could not load template for ${role} with ${integration}`);
       continue;
     }
-    const content = formatAgentMarkdown(config.frontmatter, config.content);
-    const filePath = path7.join(agentsDir, `${role}.md`);
+    const content = formatAgentMarkdown(config.frontmatter, config.content, toolProfile.agentFrontmatter);
+    const fileName = `${role}${toolProfile.agentExtension}`;
+    const filePath = path8.join(agentsDir, fileName);
     fs6.writeFileSync(filePath, content, "utf-8");
   }
 }
-function formatAgentMarkdown(frontmatter, content) {
+function formatAgentMarkdown(frontmatter, content, includeFrontmatter) {
+  if (!includeFrontmatter) {
+    return content;
+  }
   const lines = ["---"];
   for (const [key, value] of Object.entries(frontmatter)) {
     if (value !== void 0 && value !== null) {
@@ -6759,7 +6973,8 @@ function formatAgentMarkdown(frontmatter, content) {
 // src/cli/generators/mcp.ts
 init_esm_shims();
 import * as fs7 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
+import { execSync } from "child_process";
 
 // src/mcp/index.ts
 init_esm_shims();
@@ -6928,12 +7143,59 @@ function buildMCPConfig(requiredServers, target = "container") {
 }
 
 // src/cli/generators/mcp.ts
-async function generateMCPConfig(mcpServers) {
+async function generateMCPConfig(mcpServers, tool = DEFAULT_TOOL) {
   const cwd = process.cwd();
-  const mcpConfigPath = path8.join(cwd, ".mcp.json");
-  const mcpConfig = buildMCPConfig(mcpServers, "local");
-  const content = JSON.stringify(mcpConfig, null, 2);
-  fs7.writeFileSync(mcpConfigPath, content, "utf-8");
+  const toolProfile = getToolProfile(tool);
+  if (toolProfile.mcpFormat === "json") {
+    const mcpConfigPath = path9.join(cwd, toolProfile.mcpConfigPath);
+    const mcpDir = path9.dirname(mcpConfigPath);
+    if (!fs7.existsSync(mcpDir)) {
+      fs7.mkdirSync(mcpDir, { recursive: true });
+    }
+    const mcpConfig = buildMCPConfig(mcpServers, "local");
+    const content = JSON.stringify(mcpConfig, null, 2);
+    fs7.writeFileSync(mcpConfigPath, content, "utf-8");
+  } else if (toolProfile.mcpFormat === "toml") {
+    return;
+  }
+}
+function buildCodexMCPCommand(serverName) {
+  const serverTemplate = MCP_SERVERS[serverName];
+  if (!serverTemplate) {
+    throw new Error(`Unknown MCP server: ${serverName}`);
+  }
+  const args = ["mcp", "add", `bugzy-${serverName}`];
+  const envVars = [];
+  if (serverTemplate.config.env) {
+    for (const [key, value] of Object.entries(serverTemplate.config.env)) {
+      const match = value.match(/\$\{([A-Z_]+)\}/);
+      if (match) {
+        args.push("--env", `${key}=$${match[1]}`);
+        envVars.push(match[1]);
+      }
+    }
+  }
+  args.push("--", serverTemplate.config.command);
+  if (serverTemplate.config.args?.length) {
+    args.push(...serverTemplate.config.args);
+  }
+  return { args, envVars };
+}
+async function getConfiguredCodexMCPServers() {
+  try {
+    const output = execSync("codex mcp list", {
+      encoding: "utf-8",
+      env: { ...process.env, CODEX_HOME: path9.join(process.cwd(), ".codex") },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const lines = output.split("\n");
+    return lines.filter((line) => line.includes("bugzy-")).map((line) => {
+      const match = line.match(/bugzy-([a-z-]+)/);
+      return match ? match[1] : null;
+    }).filter((name) => name !== null);
+  } catch {
+    return [];
+  }
 }
 function getMCPServersFromSubagents(subagents) {
   const mcps = /* @__PURE__ */ new Set();
@@ -6943,13 +7205,16 @@ function getMCPServersFromSubagents(subagents) {
   return Array.from(mcps);
 }
 
+// src/cli/commands/setup.ts
+import { execSync as execSync3 } from "child_process";
+
 // src/cli/generators/env.ts
 init_esm_shims();
 import * as fs8 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 async function generateEnvExample(mcpServers) {
   const cwd = process.cwd();
-  const envExamplePath = path9.join(cwd, ".env.example");
+  const envExamplePath = path10.join(cwd, ".env.example");
   const header = `# ============================================
 # Bugzy OSS - Environment Variables
 # ============================================
@@ -7009,8 +7274,8 @@ GITHUB_TOKEN=`
 // src/cli/generators/scaffold-playwright.ts
 init_esm_shims();
 import * as fs9 from "fs";
-import * as path10 from "path";
-import { execSync } from "child_process";
+import * as path11 from "path";
+import { execSync as execSync2 } from "child_process";
 async function scaffoldPlaywrightProject(options) {
   const { projectName, targetDir, skipInstall = false } = options;
   console.log("\n\u{1F3AD} Scaffolding Playwright test automation project...\n");
@@ -7043,7 +7308,7 @@ async function createDirectoryStructure(targetDir) {
     "test-runs"
   ];
   for (const dir of directories) {
-    const fullPath = path10.join(targetDir, dir);
+    const fullPath = path11.join(targetDir, dir);
     if (!fs9.existsSync(fullPath)) {
       fs9.mkdirSync(fullPath, { recursive: true });
       console.log(`  \u2713 Created ${dir}/`);
@@ -7052,11 +7317,11 @@ async function createDirectoryStructure(targetDir) {
 }
 async function copyTemplateFiles(targetDir, projectName) {
   const possiblePaths = [
-    path10.join(__dirname, "../../templates/playwright"),
+    path11.join(__dirname, "../../templates/playwright"),
     // When running from dist
-    path10.join(process.cwd(), "templates/playwright"),
+    path11.join(process.cwd(), "templates/playwright"),
     // When running from project root
-    path10.join(__dirname, "../../../templates/playwright")
+    path11.join(__dirname, "../../../templates/playwright")
     // When running tests
   ];
   let templatesDir = "";
@@ -7069,9 +7334,9 @@ async function copyTemplateFiles(targetDir, projectName) {
   if (!templatesDir) {
     throw new Error("Templates directory not found. Searched paths: " + possiblePaths.join(", "));
   }
-  const initTemplatesDir = path10.join(__dirname, "../../templates/init");
-  const testRunsReadmeSrc = path10.join(initTemplatesDir, "test-runs/README.md");
-  const testRunsReadmeDest = path10.join(targetDir, "test-runs/README.md");
+  const initTemplatesDir = path11.join(__dirname, "../../templates/init");
+  const testRunsReadmeSrc = path11.join(initTemplatesDir, "test-runs/README.md");
+  const testRunsReadmeDest = path11.join(targetDir, "test-runs/README.md");
   if (fs9.existsSync(testRunsReadmeSrc)) {
     const content = fs9.readFileSync(testRunsReadmeSrc, "utf-8");
     fs9.writeFileSync(testRunsReadmeDest, content, "utf-8");
@@ -7115,8 +7380,8 @@ async function copyTemplateFiles(targetDir, projectName) {
     }
   ];
   for (const template of templates) {
-    const srcPath = path10.join(templatesDir, template.src);
-    const destPath = path10.join(targetDir, template.dest);
+    const srcPath = path11.join(templatesDir, template.src);
+    const destPath = path11.join(targetDir, template.dest);
     if (fs9.existsSync(srcPath)) {
       let content = fs9.readFileSync(srcPath, "utf-8");
       if (template.process) {
@@ -7126,7 +7391,7 @@ async function copyTemplateFiles(targetDir, projectName) {
           DATE: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
         });
       }
-      const destDir = path10.dirname(destPath);
+      const destDir = path11.dirname(destPath);
       if (!fs9.existsSync(destDir)) {
         fs9.mkdirSync(destDir, { recursive: true });
       }
@@ -7146,7 +7411,7 @@ function processTemplate(content, values) {
   return processed;
 }
 async function updateGitignore2(targetDir) {
-  const gitignorePath = path10.join(targetDir, ".gitignore");
+  const gitignorePath = path11.join(targetDir, ".gitignore");
   const playwrightEntries = `
 # Playwright
 test-results/
@@ -7166,7 +7431,7 @@ tests/.auth/
   }
 }
 async function createPackageJson(targetDir, projectName) {
-  const packageJsonPath = path10.join(targetDir, "package.json");
+  const packageJsonPath = path11.join(targetDir, "package.json");
   const recommendedDeps = {
     "@playwright/test": "^1.48.0",
     "@types/node": "^20.0.0",
@@ -7222,7 +7487,7 @@ async function installDependencies(targetDir) {
     console.log(`
   \u{1F4E6} Installing dependencies using ${packageManager}...`);
     const installCommand = packageManager === "pnpm" ? "pnpm install" : packageManager === "yarn" ? "yarn install" : "npm install";
-    execSync(installCommand, {
+    execSync2(installCommand, {
       cwd: targetDir,
       stdio: "inherit"
     });
@@ -7233,17 +7498,17 @@ async function installDependencies(targetDir) {
   }
 }
 function detectPackageManager(targetDir) {
-  if (fs9.existsSync(path10.join(targetDir, "pnpm-lock.yaml"))) {
+  if (fs9.existsSync(path11.join(targetDir, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs9.existsSync(path10.join(targetDir, "yarn.lock"))) {
+  if (fs9.existsSync(path11.join(targetDir, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
 }
 function isPlaywrightScaffolded(targetDir) {
-  const playwrightConfig = path10.join(targetDir, "playwright.config.ts");
-  const testsDir = path10.join(targetDir, "tests");
+  const playwrightConfig = path11.join(targetDir, "playwright.config.ts");
+  const testsDir = path11.join(targetDir, "tests");
   return fs9.existsSync(playwrightConfig) && fs9.existsSync(testsDir);
 }
 
@@ -7287,9 +7552,26 @@ async function setupProject(cliArgs = []) {
 async function firstTimeSetup(cliSubagents) {
   console.log(getBanner());
   console.log(chalk2.cyan("  Project Setup\n"));
+  const toolOptions = getToolOptions();
+  const { selectedTool } = await inquirer.prompt([{
+    type: "list",
+    name: "selectedTool",
+    message: "Which AI coding assistant do you use?",
+    choices: toolOptions.map((opt) => ({
+      name: opt.hint ? `${opt.label} - ${chalk2.gray(opt.hint)}` : opt.label,
+      value: opt.value
+    })),
+    default: DEFAULT_TOOL
+  }]);
+  const tool = selectedTool;
+  const toolProfile = getToolProfile(tool);
+  console.log(chalk2.gray(`
+\u2713 Using ${toolProfile.name}
+`));
   let spinner = ora2("Creating project structure").start();
-  await createProjectStructure();
-  spinner.succeed(chalk2.green("Created .bugzy/ and .claude/ directories"));
+  await createProjectStructure(tool);
+  const toolDirName = path12.dirname(toolProfile.commandsDir);
+  spinner.succeed(chalk2.green(`Created .bugzy/ and ${toolDirName}/ directories`));
   const subagents = {};
   if (cliSubagents) {
     console.log(chalk2.cyan("\nConfiguring subagents from CLI arguments:\n"));
@@ -7347,15 +7629,19 @@ async function firstTimeSetup(cliSubagents) {
     }
   }
   spinner = ora2("Saving configuration").start();
-  const projectName = path11.basename(process.cwd());
-  const config = createDefaultConfig(projectName);
+  const projectName = path12.basename(process.cwd());
+  const config = createDefaultConfig(projectName, tool);
   config.subagents = subagents;
   saveConfig(config);
   spinner.succeed(chalk2.green("Saved to .bugzy/config.json"));
-  await regenerateAll(subagents);
-  spinner = ora2("Creating CLAUDE.md").start();
-  await generateClaudeMd();
-  spinner.succeed(chalk2.green("Created CLAUDE.md"));
+  await regenerateAll(subagents, tool);
+  spinner = ora2(`Creating ${toolProfile.memoryFile}`).start();
+  if (tool === "claude-code") {
+    await generateClaudeMd();
+  } else {
+    await generateAgentsMd();
+  }
+  spinner.succeed(chalk2.green(`Created ${toolProfile.memoryFile}`));
   spinner = ora2("Updating .gitignore").start();
   await updateGitignore();
   spinner.succeed(chalk2.green("Updated .gitignore"));
@@ -7382,11 +7668,38 @@ async function reconfigureProject() {
     console.error(chalk2.red("Error: Could not load existing configuration"));
     process.exit(1);
   }
+  const currentTool = getToolFromConfig(existingConfig);
+  const currentToolProfile = getToolProfile(currentTool);
   console.log(chalk2.gray("Current configuration:"));
+  console.log(chalk2.gray(`  Tool: ${currentToolProfile.name}`));
   for (const [role, integration] of Object.entries(existingConfig.subagents)) {
     console.log(chalk2.gray(`  \u2022 ${role}: ${integration}`));
   }
   console.log();
+  const toolOptions = getToolOptions();
+  const { changeTool } = await inquirer.prompt([{
+    type: "confirm",
+    name: "changeTool",
+    message: `Keep using ${currentToolProfile.name}?`,
+    default: true
+  }]);
+  let tool = currentTool;
+  if (!changeTool) {
+    const { selectedTool } = await inquirer.prompt([{
+      type: "list",
+      name: "selectedTool",
+      message: "Which AI coding assistant do you want to use?",
+      choices: toolOptions.map((opt) => ({
+        name: opt.hint ? `${opt.label} - ${chalk2.gray(opt.hint)}` : opt.label,
+        value: opt.value
+      })),
+      default: currentTool
+    }]);
+    tool = selectedTool;
+    console.log(chalk2.gray(`
+\u2713 Switching to ${getToolProfile(tool).name}
+`));
+  }
   const allSubAgents = getAllSubAgents();
   const newSubagents = {};
   for (const subagent of allSubAgents) {
@@ -7462,13 +7775,19 @@ async function reconfigureProject() {
     }
   }
   let spinner = ora2("Updating configuration").start();
+  existingConfig.tool = tool;
   existingConfig.subagents = newSubagents;
   await saveConfig(existingConfig);
   spinner.succeed(chalk2.green("Updated .bugzy/config.json"));
-  await regenerateAll(newSubagents);
-  spinner = ora2("Creating CLAUDE.md").start();
-  await generateClaudeMd();
-  spinner.succeed(chalk2.green("Created CLAUDE.md"));
+  await regenerateAll(newSubagents, tool);
+  const toolProfile = getToolProfile(tool);
+  spinner = ora2(`Creating ${toolProfile.memoryFile}`).start();
+  if (tool === "claude-code") {
+    await generateClaudeMd();
+  } else {
+    await generateAgentsMd();
+  }
+  spinner.succeed(chalk2.green(`Created ${toolProfile.memoryFile}`));
   console.log(chalk2.green.bold("\n\u2705 Reconfiguration complete!\n"));
   console.log(chalk2.yellow("Next steps:"));
   console.log(chalk2.white("1. Check .env.example for new required secrets"));
@@ -7476,23 +7795,52 @@ async function reconfigureProject() {
   console.log(chalk2.white("3. Run:"), chalk2.cyan("bugzy"));
   console.log();
 }
-async function regenerateAll(subagents) {
+async function regenerateAll(subagents, tool = DEFAULT_TOOL) {
+  const toolProfile = getToolProfile(tool);
   let spinner = ora2("Generating task commands").start();
-  await generateCommands(subagents);
+  await generateCommands(subagents, tool);
   const taskCount = Object.keys((init_tasks(), __toCommonJS(tasks_exports)).TASK_TEMPLATES).length;
-  spinner.succeed(chalk2.green(`Generated ${taskCount} task commands in .claude/commands/`));
+  spinner.succeed(chalk2.green(`Generated ${taskCount} task commands in ${toolProfile.commandsDir}/`));
   spinner = ora2("Generating subagent configurations").start();
-  await generateAgents(subagents);
+  await generateAgents(subagents, tool);
   const subagentCount = Object.keys(subagents).length;
-  spinner.succeed(chalk2.green(`Generated ${subagentCount} subagent configurations in .claude/agents/`));
+  spinner.succeed(chalk2.green(`Generated ${subagentCount} subagent configurations in ${toolProfile.agentsDir}/`));
   spinner = ora2("Generating MCP configuration").start();
   const mcpServers = getMCPServersFromSubagents(subagents);
-  await generateMCPConfig(mcpServers);
-  spinner.succeed(chalk2.green(`Generated .mcp.json (${mcpServers.length} servers)`));
+  await generateMCPConfig(mcpServers, tool);
+  if (toolProfile.mcpFormat === "json") {
+    spinner.succeed(chalk2.green(`Generated ${toolProfile.mcpConfigPath} (${mcpServers.length} servers)`));
+  } else if (toolProfile.mcpFormat === "toml") {
+    spinner.succeed(chalk2.green("MCP configuration ready"));
+    await setupCodexMCP(mcpServers);
+  }
   spinner = ora2("Creating environment template").start();
   await generateEnvExample(mcpServers);
   spinner.succeed(chalk2.green("Created .env.example"));
 }
+async function setupCodexMCP(mcpServers) {
+  const existingServers = await getConfiguredCodexMCPServers();
+  const newServers = mcpServers.filter((s) => !existingServers.includes(s));
+  if (newServers.length === 0) {
+    console.log(chalk2.gray("\n\u2713 All MCP servers already configured"));
+    return;
+  }
+  console.log();
+  for (const serverName of newServers) {
+    const spinner = ora2(`Configuring ${serverName}`).start();
+    try {
+      const { args } = buildCodexMCPCommand(serverName);
+      execSync3(["codex", ...args].join(" "), {
+        stdio: "pipe",
+        env: { ...process.env, CODEX_HOME: path12.join(process.cwd(), ".codex") }
+      });
+      spinner.succeed(chalk2.green(`Configured ${serverName}`));
+    } catch (error) {
+      spinner.fail(chalk2.red(`Failed to configure ${serverName}`));
+      console.error(chalk2.gray(error.message));
+    }
+  }
+}
 
 // src/cli/index.ts
 process.on("uncaughtException", (error) => {
@@ -7503,9 +7851,9 @@ process.on("unhandledRejection", (reason) => {
   console.error(chalk3.red("\n\u2717 Error:"), reason?.message || reason);
   process.exit(1);
 });
-var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname7(fileURLToPath2(import.meta.url));
 var packageJson = JSON.parse(
-  readFileSync5(join10(__dirname2, "../../package.json"), "utf-8")
+  readFileSync5(join12(__dirname2, "../../package.json"), "utf-8")
 );
 if (process.argv.includes("-v") || process.argv.includes("--version")) {
   console.log(getBanner());