rrce-workflow 0.2.27 → 0.2.29

package/dist/index.js

@@ -8,6 +8,22 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/lib/git.ts
+import { execSync } from "child_process";
+function getGitUser() {
+  try {
+    const result = execSync("git config user.name", { encoding: "utf-8" });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var init_git = __esm({
+  "src/lib/git.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/paths.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -366,6 +382,128 @@ var init_prompts = __esm({
   }
 });
 
+// src/commands/wizard/utils.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function copyPromptsToDir(prompts, targetDir, extension) {
+  for (const prompt of prompts) {
+    const baseName = path4.basename(prompt.filePath, ".md");
+    const targetName = baseName + extension;
+    const targetPath = path4.join(targetDir, targetName);
+    const content = fs4.readFileSync(prompt.filePath, "utf-8");
+    fs4.writeFileSync(targetPath, content);
+  }
+}
+function copyDirRecursive(src, dest) {
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      ensureDir(destPath);
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs4.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+var init_utils = __esm({
+  "src/commands/wizard/utils.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/commands/wizard/vscode.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
+  const workspaceFilePath = path5.join(workspacePath, `${workspaceName}.code-workspace`);
+  let workspace;
+  if (fs5.existsSync(workspaceFilePath)) {
+    try {
+      const content = fs5.readFileSync(workspaceFilePath, "utf-8");
+      workspace = JSON.parse(content);
+    } catch {
+      workspace = { folders: [], settings: {} };
+    }
+  } else {
+    workspace = { folders: [], settings: {} };
+  }
+  if (!workspace.settings) {
+    workspace.settings = {};
+  }
+  workspace.folders = workspace.folders.filter(
+    (f) => f.path === "." || !f.name?.startsWith("\u{1F4C1}") && !f.name?.startsWith("\u{1F4DA}") && !f.name?.startsWith("\u{1F4CE}") && !f.name?.startsWith("\u{1F4CB}")
+  );
+  const mainFolderIndex = workspace.folders.findIndex((f) => f.path === ".");
+  if (mainFolderIndex === -1) {
+    workspace.folders.unshift({
+      path: ".",
+      name: `\u{1F3E0} ${workspaceName} (workspace)`
+    });
+  } else {
+    workspace.folders[mainFolderIndex] = {
+      path: ".",
+      name: `\u{1F3E0} ${workspaceName} (workspace)`
+    };
+  }
+  const referenceFolderPaths = [];
+  const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === "object";
+  if (isDetectedProjects) {
+    const projects = linkedProjects;
+    for (const project of projects) {
+      const sourceLabel = project.source === "global" ? "global" : "local";
+      const folderPath = project.dataPath;
+      if (fs5.existsSync(folderPath)) {
+        referenceFolderPaths.push(folderPath);
+        workspace.folders.push({
+          path: folderPath,
+          name: `\u{1F4C1} ${project.name} [${sourceLabel}]`
+        });
+      }
+    }
+  } else {
+    const projectNames = linkedProjects;
+    const rrceHome = customGlobalPath || getRRCEHome();
+    for (const projectName of projectNames) {
+      const folderPath = path5.join(rrceHome, "workspaces", projectName);
+      if (fs5.existsSync(folderPath)) {
+        referenceFolderPaths.push(folderPath);
+        workspace.folders.push({
+          path: folderPath,
+          name: `\u{1F4C1} ${projectName} [global]`
+        });
+      }
+    }
+  }
+  if (referenceFolderPaths.length > 0) {
+    const readonlyPatterns = {};
+    for (const folderPath of referenceFolderPaths) {
+      readonlyPatterns[`${folderPath}/**`] = true;
+    }
+    const existingReadonly = workspace.settings["files.readonlyInclude"] || {};
+    const cleanedReadonly = {};
+    for (const [pattern, value] of Object.entries(existingReadonly)) {
+      if (!pattern.includes(".rrce-workflow") && !pattern.includes("rrce-workflow/workspaces")) {
+        cleanedReadonly[pattern] = value;
+      }
+    }
+    workspace.settings["files.readonlyInclude"] = {
+      ...cleanedReadonly,
+      ...readonlyPatterns
+    };
+  }
+  fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
+}
+var init_vscode = __esm({
+  "src/commands/wizard/vscode.ts"() {
+    "use strict";
+    init_paths();
+    init_detection();
+  }
+});
+
 // src/lib/autocomplete-prompt.ts
 import * as fs6 from "fs";
 import * as path6 from "path";
@@ -583,20 +721,20 @@ var init_types = __esm({
 });
 
 // src/mcp/config.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 function getMCPConfigPath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path11.join(rrceHome, "mcp.yaml");
+  return path8.join(rrceHome, "mcp.yaml");
 }
 function ensureMCPGlobalPath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
   if (rrceHome.startsWith(".") || rrceHome.includes(".rrce-workflow/")) {
-    const configPath = path11.join(workspaceRoot, ".rrce-workflow", "config.yaml");
-    if (fs12.existsSync(configPath)) {
-      const content = fs12.readFileSync(configPath, "utf-8");
+    const configPath = path8.join(workspaceRoot, ".rrce-workflow", "config.yaml");
+    if (fs7.existsSync(configPath)) {
+      const content = fs7.readFileSync(configPath, "utf-8");
       const modeMatch = content.match(/mode:\s*(global|workspace)/);
       if (modeMatch?.[1] === "workspace") {
         return {
@@ -614,11 +752,11 @@ function ensureMCPGlobalPath() {
 }
 function loadMCPConfig() {
   const configPath = getMCPConfigPath();
-  if (!fs12.existsSync(configPath)) {
+  if (!fs7.existsSync(configPath)) {
     return { ...DEFAULT_MCP_CONFIG };
   }
   try {
-    const content = fs12.readFileSync(configPath, "utf-8");
+    const content = fs7.readFileSync(configPath, "utf-8");
     return parseMCPConfig(content);
   } catch {
     return { ...DEFAULT_MCP_CONFIG };
@@ -626,12 +764,12 @@ function loadMCPConfig() {
 }
 function saveMCPConfig(config) {
   const configPath = getMCPConfigPath();
-  const dir = path11.dirname(configPath);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(configPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
   const content = serializeMCPConfig(config);
-  fs12.writeFileSync(configPath, content);
+  fs7.writeFileSync(configPath, content);
 }
 function parseMCPConfig(content) {
   const config = { ...DEFAULT_MCP_CONFIG, projects: [] };
@@ -794,12 +932,12 @@ __export(logger_exports, {
   getLogFilePath: () => getLogFilePath,
   logger: () => logger
 });
-import * as fs13 from "fs";
-import * as path12 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 function getLogFilePath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path12.join(rrceHome, "mcp-server.log");
+  return path9.join(rrceHome, "mcp-server.log");
 }
 var Logger, logger;
 var init_logger = __esm({
@@ -830,11 +968,11 @@ ${JSON.stringify(data, null, 2)}`;
         }
         logMessage += "\n";
         try {
-          const dir = path12.dirname(this.logPath);
-          if (!fs13.existsSync(dir)) {
-            fs13.mkdirSync(dir, { recursive: true });
+          const dir = path9.dirname(this.logPath);
+          if (!fs8.existsSync(dir)) {
+            fs8.mkdirSync(dir, { recursive: true });
           }
-          fs13.appendFileSync(this.logPath, logMessage);
+          fs8.appendFileSync(this.logPath, logMessage);
         } catch (e) {
           console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
           console.error(logMessage);
@@ -858,8 +996,8 @@ ${JSON.stringify(data, null, 2)}`;
 });
 
 // src/mcp/resources.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 function getExposedProjects() {
   const config = loadMCPConfig();
   const allProjects = scanForProjects();
@@ -886,11 +1024,11 @@ function getProjectContext(projectName) {
   if (!project?.knowledgePath) {
     return null;
   }
-  const contextPath = path13.join(project.knowledgePath, "project-context.md");
-  if (!fs14.existsSync(contextPath)) {
+  const contextPath = path10.join(project.knowledgePath, "project-context.md");
+  if (!fs9.existsSync(contextPath)) {
     return null;
   }
-  return fs14.readFileSync(contextPath, "utf-8");
+  return fs9.readFileSync(contextPath, "utf-8");
 }
 function getProjectTasks(projectName) {
   const config = loadMCPConfig();
@@ -903,18 +1041,18 @@ function getProjectTasks(projectName) {
   }
   const projects = scanForProjects();
   const project = projects.find((p) => p.name === projectName);
-  if (!project?.tasksPath || !fs14.existsSync(project.tasksPath)) {
+  if (!project?.tasksPath || !fs9.existsSync(project.tasksPath)) {
     return [];
   }
   const tasks = [];
   try {
-    const taskDirs = fs14.readdirSync(project.tasksPath, { withFileTypes: true });
+    const taskDirs = fs9.readdirSync(project.tasksPath, { withFileTypes: true });
     for (const dir of taskDirs) {
       if (!dir.isDirectory()) continue;
-      const metaPath = path13.join(project.tasksPath, dir.name, "meta.json");
-      if (fs14.existsSync(metaPath)) {
+      const metaPath = path10.join(project.tasksPath, dir.name, "meta.json");
+      if (fs9.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs14.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
           tasks.push(meta);
         } catch {
         }
@@ -933,11 +1071,11 @@ function searchKnowledge(query) {
     const permissions = getProjectPermissions(config, project.name);
     if (!permissions.knowledge || !project.knowledgePath) continue;
     try {
-      const files = fs14.readdirSync(project.knowledgePath);
+      const files = fs9.readdirSync(project.knowledgePath);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path13.join(project.knowledgePath, file);
-        const content = fs14.readFileSync(filePath, "utf-8");
+        const filePath = path10.join(project.knowledgePath, file);
+        const content = fs9.readFileSync(filePath, "utf-8");
         const lines = content.split("\n");
         const matches = [];
         for (const line of lines) {
@@ -1105,8 +1243,9 @@ function registerResourceHandlers(server) {
         };
       }
       const projectMatch = uri.match(/^rrce:\/\/projects\/([^/]+)\/(.+)$/);
-      if (projectMatch) {
-        const [, projectName, resourceType] = projectMatch;
+      if (projectMatch && projectMatch[1] && projectMatch[2]) {
+        const projectName = projectMatch[1];
+        const resourceType = projectMatch[2];
         const content = resourceType === "context" ? getProjectContext(projectName) : JSON.stringify(getProjectTasks(projectName), null, 2);
         if (content === null) throw new Error(`Resource not found: ${uri}`);
         return {
@@ -1357,34 +1496,81 @@ var init_server = __esm({
 });
 
 // src/mcp/install.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import * as os from "os";
-function checkInstallStatus() {
+function checkInstallStatus(workspacePath) {
   return {
-    antigravity: checkConfigFile(ANTIGRAVITY_CONFIG),
-    claude: checkConfigFile(CLAUDE_CONFIG)
+    antigravity: checkAntigravityConfig(),
+    claude: checkClaudeConfig(),
+    vscodeGlobal: checkVSCodeGlobalConfig(),
+    vscodeWorkspace: workspacePath ? checkVSCodeWorkspaceConfig(workspacePath) : false
   };
 }
-function checkConfigFile(configPath) {
-  if (!fs15.existsSync(configPath)) return false;
+function checkAntigravityConfig() {
+  if (!fs10.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  try {
+    const content = JSON.parse(fs10.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    return !!content.mcpServers?.["rrce"];
+  } catch {
+    return false;
+  }
+}
+function checkClaudeConfig() {
+  if (!fs10.existsSync(CLAUDE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs15.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs10.readFileSync(CLAUDE_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
-function installToConfig(target) {
-  const configPath = target === "antigravity" ? ANTIGRAVITY_CONFIG : CLAUDE_CONFIG;
-  const dir = path14.dirname(configPath);
-  if (!fs15.existsSync(dir)) {
-    fs15.mkdirSync(dir, { recursive: true });
+function checkVSCodeGlobalConfig() {
+  if (!fs10.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  try {
+    const content = JSON.parse(fs10.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    return !!content["mcp.servers"]?.["rrce"];
+  } catch {
+    return false;
+  }
+}
+function checkVSCodeWorkspaceConfig(workspacePath) {
+  const configPath = path11.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs10.existsSync(configPath)) return false;
+  try {
+    const content = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+    return !!content.servers?.["rrce"];
+  } catch {
+    return false;
+  }
+}
+function isInstalledAnywhere(workspacePath) {
+  const status = checkInstallStatus(workspacePath);
+  return status.antigravity || status.claude || status.vscodeGlobal || status.vscodeWorkspace;
+}
+function installToConfig(target, workspacePath) {
+  switch (target) {
+    case "antigravity":
+      return installToAntigravity();
+    case "claude":
+      return installToClaude();
+    case "vscode-global":
+      return installToVSCodeGlobal();
+    case "vscode-workspace":
+      return workspacePath ? installToVSCodeWorkspace(workspacePath) : false;
+    default:
+      return false;
+  }
+}
+function installToAntigravity() {
+  const dir = path11.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs15.existsSync(configPath)) {
+  if (fs10.existsSync(ANTIGRAVITY_CONFIG)) {
     try {
-      config = JSON.parse(fs15.readFileSync(configPath, "utf-8"));
+      config = JSON.parse(fs10.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -1392,21 +1578,108 @@ function installToConfig(target) {
   config.mcpServers["rrce"] = {
     command: "npx",
     args: ["-y", "rrce-workflow", "mcp", "start"]
-    // -y to avoid interactive prompts
   };
   try {
-    fs15.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs10.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installToClaude() {
+  const dir = path11.dirname(CLAUDE_CONFIG);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
+  }
+  let config = { mcpServers: {} };
+  if (fs10.existsSync(CLAUDE_CONFIG)) {
+    try {
+      config = JSON.parse(fs10.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    } catch {
+    }
+  }
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+  };
+  try {
+    fs10.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installToVSCodeGlobal() {
+  const dir = path11.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
+  }
+  let settings = {};
+  if (fs10.existsSync(VSCODE_GLOBAL_CONFIG)) {
+    try {
+      settings = JSON.parse(fs10.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    } catch {
+    }
+  }
+  if (!settings["mcp.servers"]) settings["mcp.servers"] = {};
+  settings["mcp.servers"]["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+  };
+  try {
+    fs10.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installToVSCodeWorkspace(workspacePath) {
+  const vscodeDir = path11.join(workspacePath, ".vscode");
+  const configPath = path11.join(vscodeDir, "mcp.json");
+  if (!fs10.existsSync(vscodeDir)) {
+    fs10.mkdirSync(vscodeDir, { recursive: true });
+  }
+  let config = { servers: {} };
+  if (fs10.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!config.servers) config.servers = {};
+  config.servers["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+  };
+  try {
+    fs10.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
-var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG;
+function getTargetLabel(target) {
+  switch (target) {
+    case "antigravity":
+      return "Antigravity IDE";
+    case "claude":
+      return "Claude Desktop";
+    case "vscode-global":
+      return "VSCode (Global)";
+    case "vscode-workspace":
+      return "VSCode (Workspace)";
+    default:
+      return target;
+  }
+}
+var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path14.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path14.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    ANTIGRAVITY_CONFIG = path11.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path11.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path11.join(os.homedir(), ".config/Code/User/settings.json");
   }
 });
 
@@ -1415,8 +1688,8 @@ var mcp_exports = {};
 __export(mcp_exports, {
   runMCP: () => runMCP
 });
-import { intro as intro2, outro as outro6, select as select4, multiselect as multiselect3, confirm as confirm4, spinner as spinner6, note as note7, cancel as cancel6, isCancel as isCancel7, text as text2 } from "@clack/prompts";
-import pc8 from "picocolors";
+import { intro, outro, select as select2, multiselect, confirm, spinner, note as note2, cancel, isCancel as isCancel2, text } from "@clack/prompts";
+import pc3 from "picocolors";
 async function runMCP(subcommand2) {
   if (subcommand2) {
     switch (subcommand2) {
@@ -1436,42 +1709,72 @@ async function runMCP(subcommand2) {
         return;
     }
   }
-  intro2(pc8.bgCyan(pc8.black(" RRCE MCP Hub ")));
+  intro(pc3.bgCyan(pc3.black(" RRCE MCP Hub ")));
+  const workspacePath = detectWorkspaceRoot();
   const globalPathCheck = await ensureMCPGlobalPath();
   if (!globalPathCheck.configured) {
     const configured = await handleConfigureGlobalPath();
     if (!configured) {
-      outro6(pc8.yellow("MCP requires a global storage path. Setup cancelled."));
+      outro(pc3.yellow("MCP requires a global storage path. Setup cancelled."));
       return;
     }
   }
-  const status = checkInstallStatus();
-  if (!status.antigravity && !status.claude) {
-    const shouldInstall = await confirm4({
-      message: "MCP server is not installed in your IDEs. Install now?",
+  const installed = isInstalledAnywhere(workspacePath);
+  if (!installed) {
+    note2(
+      `${pc3.bold("Welcome to RRCE MCP Hub!")}
+
+MCP (Model Context Protocol) allows AI assistants to access your 
+project knowledge in real-time. Let's get you set up.`,
+      "Getting Started"
+    );
+    const shouldInstall = await confirm({
+      message: "Install MCP server to your IDE(s)?",
       initialValue: true
     });
-    if (shouldInstall && !isCancel7(shouldInstall)) {
-      await handleInstallWizard();
+    if (shouldInstall && !isCancel2(shouldInstall)) {
+      await handleInstallWizard(workspacePath);
+      const config2 = loadMCPConfig();
+      const exposedCount2 = config2.projects.filter((p) => p.expose).length;
+      if (exposedCount2 === 0) {
+        await handleConfigure();
+      }
+      const shouldStart = await confirm({
+        message: "Start the MCP server now?",
+        initialValue: true
+      });
+      if (shouldStart && !isCancel2(shouldStart)) {
+        await handleStartServer();
+      }
     }
+    outro(pc3.green("MCP Hub setup complete!"));
+    return;
+  }
+  const config = loadMCPConfig();
+  const exposedCount = config.projects.filter((p) => p.expose).length;
+  if (exposedCount === 0 && !config.defaults.includeNew) {
+    note2("MCP is installed but no projects are exposed. Let's configure that.", "Configuration Needed");
+    await handleConfigure();
   }
   let running = true;
   while (running) {
     const serverStatus = getMCPServerStatus();
-    const serverLabel = serverStatus.running ? pc8.green("Running") : pc8.dim("Stopped");
-    const action = await select4({
+    const serverLabel = serverStatus.running ? pc3.green("\u25CF Running") : pc3.dim("\u25CB Stopped");
+    const currentStatus = checkInstallStatus(workspacePath);
+    const installedCount = [currentStatus.antigravity, currentStatus.claude, currentStatus.vscodeGlobal, currentStatus.vscodeWorkspace].filter(Boolean).length;
+    const action = await select2({
       message: "What would you like to do?",
       options: [
-        { value: "start", label: `\u25B6\uFE0F  Start MCP server`, hint: `Current status: ${serverLabel}` },
+        { value: "start", label: `\u25B6\uFE0F  Start MCP server`, hint: serverLabel },
         { value: "configure", label: "\u2699\uFE0F  Configure projects", hint: "Choose which projects to expose" },
-        { value: "install", label: "\u{1F4E5} Install to IDE", hint: "Add to Antigravity or Claude Desktop" },
+        { value: "install", label: "\u{1F4E5} Install to IDE", hint: `${installedCount} IDE(s) configured` },
         { value: "status", label: "\u{1F4CB} View status", hint: "See details" },
         { value: "help", label: "\u2753 Help", hint: "Learn about MCP Hub" },
         { value: "exit", label: "\u21A9  Exit", hint: "Return to shell" }
       ]
     });
-    if (isCancel7(action)) {
-      cancel6("MCP Hub closed.");
+    if (isCancel2(action)) {
+      cancel("MCP Hub closed.");
       return;
     }
     switch (action) {
@@ -1482,7 +1785,7 @@ async function runMCP(subcommand2) {
         await handleConfigure();
         break;
       case "install":
-        await handleInstallWizard();
+        await handleInstallWizard(workspacePath);
         break;
       case "status":
         await handleShowStatus();
@@ -1495,140 +1798,227 @@ async function runMCP(subcommand2) {
         break;
     }
   }
-  outro6(pc8.green("MCP Hub closed."));
+  outro(pc3.green("MCP Hub closed."));
 }
-async function handleInstallWizard() {
-  const status = checkInstallStatus();
+async function handleInstallWizard(workspacePath) {
+  const status = checkInstallStatus(workspacePath);
   const options = [
-    { value: "antigravity", label: "Antigravity IDE", hint: status.antigravity ? "Installed" : "Not installed" },
-    { value: "claude", label: "Claude Desktop", hint: status.claude ? "Installed" : "Not installed" }
+    {
+      value: "antigravity",
+      label: "Antigravity IDE",
+      hint: status.antigravity ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")
+    },
+    {
+      value: "vscode-global",
+      label: "VSCode (Global Settings)",
+      hint: status.vscodeGlobal ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")
+    },
+    {
+      value: "vscode-workspace",
+      label: "VSCode (Workspace Config)",
+      hint: status.vscodeWorkspace ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")
+    },
+    {
+      value: "claude",
+      label: "Claude Desktop",
+      hint: status.claude ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")
+    }
   ];
-  const selected = await multiselect3({
+  const selected = await multiselect({
     message: "Select where to install RRCE MCP Server:",
     options,
     initialValues: [
       ...status.antigravity ? ["antigravity"] : [],
+      ...status.vscodeGlobal ? ["vscode-global"] : [],
+      ...status.vscodeWorkspace ? ["vscode-workspace"] : [],
       ...status.claude ? ["claude"] : []
     ],
     required: false
   });
-  if (isCancel7(selected)) return;
+  if (isCancel2(selected)) return;
   const targets = selected;
   const results = [];
   for (const target of targets) {
-    const success = installToConfig(target);
-    results.push(`${target}: ${success ? pc8.green("Success") : pc8.red("Failed")}`);
+    const success = installToConfig(target, workspacePath);
+    const label = getTargetLabel(target);
+    results.push(`${label}: ${success ? pc3.green("\u2713 Success") : pc3.red("\u2717 Failed")}`);
   }
   if (results.length > 0) {
-    note7(results.join("\n"), "Installation Results");
+    note2(results.join("\n"), "Installation Results");
   }
 }
 async function handleStartServer() {
   const fs16 = await import("fs");
   const { getLogFilePath: getLogFilePath2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
   const config = loadMCPConfig();
-  const exposedCount = config.projects.filter((p) => p.expose).length;
-  if (exposedCount === 0 && !config.defaults.includeNew) {
-    const shouldConfig = await confirm4({
+  const projects = scanForProjects();
+  const exposedProjects = projects.filter((p) => {
+    const cfg = config.projects.find((c) => c.name === p.name);
+    return cfg?.expose ?? config.defaults.includeNew;
+  });
+  if (exposedProjects.length === 0) {
+    const shouldConfig = await confirm({
       message: "No projects are currently exposed. Configure now?",
       initialValue: true
     });
-    if (shouldConfig && !isCancel7(shouldConfig)) {
+    if (shouldConfig && !isCancel2(shouldConfig)) {
       await handleConfigure();
+      return handleStartServer();
     }
   }
-  const portInput = await text2({
-    message: "Select port for MCP Server",
-    initialValue: config.server.port.toString(),
-    placeholder: "3200",
-    validate(value) {
-      if (isNaN(Number(value))) return "Port must be a number";
+  const status = getMCPServerStatus();
+  let newPort = config.server.port;
+  if (!status.running) {
+    const portInput = await text({
+      message: "Select port for MCP Server",
+      initialValue: config.server.port.toString(),
+      placeholder: "3200",
+      validate(value) {
+        if (isNaN(Number(value))) return "Port must be a number";
+      }
+    });
+    if (isCancel2(portInput)) return;
+    newPort = parseInt(portInput, 10);
+    if (newPort !== config.server.port) {
+      config.server.port = newPort;
+      saveMCPConfig(config);
     }
-  });
-  if (isCancel7(portInput)) return;
-  const newPort = parseInt(portInput, 10);
-  if (newPort !== config.server.port) {
-    config.server.port = newPort;
-    saveMCPConfig(config);
+  } else {
+    newPort = status.port || newPort;
+    note2(`Server is already running on port ${newPort}`, "Info");
   }
   console.clear();
   const logPath = getLogFilePath2();
-  const renderHeader = () => {
+  const exposedNames = exposedProjects.map((p) => p.name).slice(0, 5);
+  const exposedLabel = exposedNames.length > 0 ? exposedNames.join(", ") + (exposedProjects.length > 5 ? ` (+${exposedProjects.length - 5} more)` : "") : pc3.dim("(none)");
+  const render = (logs = []) => {
     console.clear();
-    console.log(pc8.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
-    console.log(pc8.cyan("\u2551           RRCE MCP Hub Running            \u2551"));
-    console.log(pc8.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
-    console.log(pc8.dim("Server is running in Stdio mode (JSON-RPC)."));
-    console.log(pc8.dim(`Port: ${newPort} | PID: ${process.pid}`));
-    console.log(pc8.dim(`Logging to: ${logPath}`));
-    console.log(pc8.dim("---------------------------------------------"));
-  };
-  const renderFooter = () => {
-    console.log(pc8.dim("---------------------------------------------"));
-    console.log(pc8.bgBlue(pc8.white(pc8.bold(" COMMANDS "))));
-    console.log(`${pc8.bold("q")}: Stop & Quit   ${pc8.bold("g")}: Configure Projects   ${pc8.bold("p")}: Change Port`);
+    console.log(pc3.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+    console.log(pc3.cyan("\u2551") + pc3.bold(pc3.white("                    RRCE MCP Hub Running                      ")) + pc3.cyan("\u2551"));
+    console.log(pc3.cyan("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563"));
+    const logLines = logs.slice(-10);
+    const emptyLines = 10 - logLines.length;
+    for (let i = 0; i < emptyLines; i++) {
+      console.log(pc3.cyan("\u2551") + " ".repeat(63) + pc3.cyan("\u2551"));
+    }
+    for (const line of logLines) {
+      const cleanLine = line.replace(/\u001b\[\d+m/g, "");
+      const truncated = cleanLine.substring(0, 61).padEnd(61);
+      console.log(pc3.cyan("\u2551") + " " + pc3.dim(truncated) + " " + pc3.cyan("\u2551"));
+    }
+    console.log(pc3.cyan("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563"));
+    const infoLine = ` \u{1F4CB} ${exposedLabel} \u2502 Port: ${newPort} \u2502 PID: ${process.pid || "?"}`.substring(0, 61).padEnd(61);
+    console.log(pc3.cyan("\u2551") + pc3.yellow(infoLine) + " " + pc3.cyan("\u2551"));
+    console.log(pc3.cyan("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563"));
+    const cmdLine = ` q:Quit  p:Projects  i:Install  r:Reload  c:Clear  ?:Help`;
+    console.log(pc3.cyan("\u2551") + pc3.dim(cmdLine.padEnd(63)) + pc3.cyan("\u2551"));
+    console.log(pc3.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
   };
-  renderHeader();
-  renderFooter();
+  let logBuffer = [];
+  render(logBuffer);
   try {
-    await startMCPServer();
+    if (!status.running) {
+      await startMCPServer();
+    }
     let lastSize = 0;
     if (fs16.existsSync(logPath)) {
       const stats = fs16.statSync(logPath);
       lastSize = stats.size;
     }
     let isRunning = true;
+    let interval;
     if (process.stdin.setRawMode) {
       process.stdin.setRawMode(true);
       process.stdin.resume();
       process.stdin.setEncoding("utf8");
     }
     return new Promise((resolve) => {
+      const cleanup = (shouldStopServer) => {
+        isRunning = false;
+        clearInterval(interval);
+        if (process.stdin.setRawMode) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.removeListener("data", onKey);
+        process.stdin.pause();
+        if (shouldStopServer) {
+          stopMCPServer();
+        }
+        console.log("");
+      };
       const onKey = async (key) => {
         if (key === "" || key.toLowerCase() === "q") {
-          cleanup();
+          cleanup(true);
+          resolve();
+          return;
+        }
+        if (key.toLowerCase() === "p") {
+          cleanup(false);
+          console.clear();
+          await handleConfigure();
+          await handleStartServer();
           resolve();
+          return;
         }
-        if (key.toLowerCase() === "p" || key.toLowerCase() === "g") {
-          cleanup();
+        if (key.toLowerCase() === "i") {
+          cleanup(false);
+          console.clear();
+          await handleInstallWizard(detectWorkspaceRoot());
+          await handleStartServer();
           resolve();
+          return;
+        }
+        if (key.toLowerCase() === "r") {
+          logBuffer.push("[INFO] Reloading configuration...");
+          render(logBuffer);
+          return;
+        }
+        if (key.toLowerCase() === "c") {
+          logBuffer = [];
+          render(logBuffer);
+          return;
+        }
+        if (key === "?") {
+          logBuffer.push("\u2500".repeat(40));
+          logBuffer.push("Commands:");
+          logBuffer.push("  q - Stop server and return to menu");
+          logBuffer.push("  p - Reconfigure exposed projects");
+          logBuffer.push("  i - Install to additional IDEs");
+          logBuffer.push("  r - Reload configuration");
+          logBuffer.push("  c - Clear log display");
+          logBuffer.push("  ? - Show this help");
+          logBuffer.push("\u2500".repeat(40));
+          render(logBuffer);
+          return;
         }
       };
       process.stdin.on("data", onKey);
-      const interval = setInterval(() => {
+      interval = setInterval(() => {
         if (!isRunning) return;
         if (fs16.existsSync(logPath)) {
           const stats = fs16.statSync(logPath);
           if (stats.size > lastSize) {
-            const stream = fs16.createReadStream(logPath, {
-              start: lastSize,
-              end: stats.size,
-              encoding: "utf-8"
-            });
-            stream.on("data", (chunk) => {
-              process.stderr.write(chunk);
-            });
+            const buffer = Buffer.alloc(stats.size - lastSize);
+            const fd = fs16.openSync(logPath, "r");
+            fs16.readSync(fd, buffer, 0, buffer.length, lastSize);
+            fs16.closeSync(fd);
+            const newContent = buffer.toString("utf-8");
+            const newLines = newContent.split("\n").filter((l) => l.trim());
+            logBuffer.push(...newLines);
+            if (logBuffer.length > 100) {
+              logBuffer = logBuffer.slice(-100);
+            }
             lastSize = stats.size;
+            render(logBuffer);
           }
         }
       }, 500);
-      const cleanup = () => {
-        isRunning = false;
-        clearInterval(interval);
-        if (process.stdin.setRawMode) {
-          process.stdin.setRawMode(false);
-        }
-        process.stdin.removeListener("data", onKey);
-        process.stdin.pause();
-        stopMCPServer();
-        console.log("");
-      };
     });
   } catch (error) {
     if (process.stdin.setRawMode) {
       process.stdin.setRawMode(false);
     }
-    console.error(pc8.red("\nFailed to start server:"));
+    console.error(pc3.red("\nFailed to start/monitor server:"));
     console.error(error);
   }
 }
@@ -1636,11 +2026,11 @@ async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
   const fs16 = await import("fs");
   const path16 = await import("path");
-  note7(
-    `MCP Hub requires a ${pc8.bold("global storage path")} to store its configuration
+  note2(
+    `MCP Hub requires a ${pc3.bold("global storage path")} to store its configuration
 and coordinate across projects.
 
-Your current setup uses ${pc8.cyan("workspace")} mode, which stores data
+Your current setup uses ${pc3.cyan("workspace")} mode, which stores data
 locally in each project. MCP needs a central location.`,
     "Global Path Required"
   );
@@ -1654,8 +2044,8 @@ locally in each project. MCP needs a central location.`,
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
-    note7(
-      `${pc8.green("\u2713")} Global path configured: ${pc8.cyan(resolvedPath)}
+    note2(
+      `${pc3.green("\u2713")} Global path configured: ${pc3.cyan(resolvedPath)}
 
 MCP config will be stored at:
 ${path16.join(resolvedPath, "mcp.yaml")}`,
@@ -1663,54 +2053,63 @@ ${path16.join(resolvedPath, "mcp.yaml")}`,
     );
     return true;
   } catch (error) {
-    note7(
-      `${pc8.red("\u2717")} Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
+    note2(
+      `${pc3.red("\u2717")} Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
       "Error"
     );
     return false;
   }
 }
 async function handleShowStatus() {
-  const s = spinner6();
+  const s = spinner();
   s.start("Loading projects...");
   const config = loadMCPConfig();
   const projects = scanForProjects();
+  const workspacePath = detectWorkspaceRoot();
+  const installStatus = checkInstallStatus(workspacePath);
   s.stop("Projects loaded");
   if (projects.length === 0) {
-    note7('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
+    note2('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
     return;
   }
   const lines = [
-    `${pc8.bold("Project Status")}`,
+    `${pc3.bold("Installation Status")}`,
+    "",
+    `  Antigravity:      ${installStatus.antigravity ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")}`,
+    `  VSCode (Global):  ${installStatus.vscodeGlobal ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")}`,
+    `  VSCode (Workspace): ${installStatus.vscodeWorkspace ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")}`,
+    `  Claude Desktop:   ${installStatus.claude ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")}`,
+    "",
+    `${pc3.bold("Project Status")}`,
     ""
   ];
   for (const project of projects) {
     const projectConfig = config.projects.find((p) => p.name === project.name);
     const isExposed = projectConfig?.expose ?? config.defaults.includeNew;
-    const status = isExposed ? pc8.green("\u2713 exposed") : pc8.dim("\u25CB hidden");
-    const source = pc8.dim(`(${project.source})`);
+    const status = isExposed ? pc3.green("\u2713 exposed") : pc3.dim("\u25CB hidden");
+    const source = pc3.dim(`(${project.source})`);
     lines.push(`  ${status}  ${project.name} ${source}`);
   }
   lines.push("");
-  lines.push(pc8.dim(`Config: ${getMCPConfigPath()}`));
+  lines.push(pc3.dim(`Config: ${getMCPConfigPath()}`));
   const serverStatus = getMCPServerStatus();
   if (serverStatus.running) {
-    lines.push(pc8.green(`Server: running on port ${serverStatus.port}`));
+    lines.push(pc3.green(`Server: running on port ${serverStatus.port}`));
   } else {
-    lines.push(pc8.dim("Server: not running"));
+    lines.push(pc3.dim("Server: not running"));
   }
-  note7(lines.join("\n"), "MCP Hub Status");
+  note2(lines.join("\n"), "MCP Hub Status");
 }
 async function handleConfigure() {
   const { logger: logger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
-  const s = spinner6();
+  const s = spinner();
   s.start("Scanning for projects...");
   const config = loadMCPConfig();
   const projects = scanForProjects();
   logger2.info("Configure: Loaded config", { projects: config.projects, defaultMode: config.defaults.includeNew });
   s.stop("Projects found");
   if (projects.length === 0) {
-    note7('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
+    note2('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
     return;
   }
   const options = projects.map((project) => {
@@ -1718,7 +2117,7 @@ async function handleConfigure() {
     const isExposed = projectConfig?.expose ?? config.defaults.includeNew;
     return {
       value: project.name,
-      label: `${project.name} ${pc8.dim(`(${project.source})`)}`,
+      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
       hint: project.dataPath
     };
   });
@@ -1726,13 +2125,13 @@ async function handleConfigure() {
     const cfg = config.projects.find((c) => c.name === p.name);
     return cfg?.expose ?? config.defaults.includeNew;
   }).map((p) => p.name);
-  const selected = await multiselect3({
+  const selected = await multiselect({
     message: "Select projects to expose via MCP:",
     options,
     initialValues: currentlyExposed,
     required: false
   });
-  if (isCancel7(selected)) {
+  if (isCancel2(selected)) {
     return;
   }
   const selectedNames = selected;
@@ -1744,8 +2143,8 @@ async function handleConfigure() {
   saveMCPConfig(config);
   logger2.info("Configure: Config saved", config);
   const exposedCount = selectedNames.length;
-  note7(
-    `${pc8.green("\u2713")} Configuration saved!
+  note2(
+    `${pc3.green("\u2713")} Configuration saved!
 
 Exposed projects: ${exposedCount}
 Hidden projects: ${projects.length - exposedCount}`,
@@ -1755,65 +2154,57 @@ Hidden projects: ${projects.length - exposedCount}`,
 async function handleStopServer() {
   const status = getMCPServerStatus();
   if (!status.running) {
-    note7("MCP server is not running.", "Status");
+    note2("MCP server is not running.", "Status");
     return;
   }
-  const confirmed = await confirm4({
+  const confirmed = await confirm({
     message: "Stop the MCP server?",
     initialValue: true
   });
-  if (isCancel7(confirmed) || !confirmed) {
+  if (isCancel2(confirmed) || !confirmed) {
     return;
   }
   stopMCPServer();
-  note7(pc8.green("MCP server stopped."), "Server Stopped");
+  note2(pc3.green("MCP server stopped."), "Server Stopped");
 }
 function showHelp() {
   const help = `
-${pc8.bold("RRCE MCP Hub")} - Cross-project AI assistant server
+${pc3.bold("RRCE MCP Hub")} - Cross-project AI assistant server
 
-${pc8.bold("ABOUT")}
+${pc3.bold("ABOUT")}
 MCP (Model Context Protocol) allows AI assistants like Claude to 
 access your project knowledge in real-time. The RRCE MCP Hub 
 provides a central server that exposes selected projects.
 
-${pc8.bold("MENU OPTIONS")}
-  ${pc8.cyan("View project status")}   See which projects are exposed
-  ${pc8.cyan("Configure projects")}    Choose which projects to expose
-  ${pc8.cyan("Start MCP server")}      Start the server for AI access
-  ${pc8.cyan("Stop MCP server")}       Stop the running server
+${pc3.bold("MENU OPTIONS")}
+  ${pc3.cyan("Start MCP server")}      Start the server for AI access
+  ${pc3.cyan("Configure projects")}    Choose which projects to expose
+  ${pc3.cyan("Install to IDE")}        Add to Antigravity, VSCode, or Claude
+  ${pc3.cyan("View status")}           See which projects are exposed
 
-${pc8.bold("DIRECT COMMANDS")}
-  ${pc8.dim("rrce-workflow mcp start")}    Start server directly
-  ${pc8.dim("rrce-workflow mcp stop")}     Stop server directly
-  ${pc8.dim("rrce-workflow mcp status")}   Show status directly
-  ${pc8.dim("rrce-workflow mcp help")}     Show this help
+${pc3.bold("DIRECT COMMANDS")}
+  ${pc3.dim("rrce-workflow mcp start")}    Start server directly
+  ${pc3.dim("rrce-workflow mcp stop")}     Stop server directly
+  ${pc3.dim("rrce-workflow mcp status")}   Show status directly
+  ${pc3.dim("rrce-workflow mcp help")}     Show this help
 
-${pc8.bold("CLAUDE DESKTOP SETUP")}
-Add to ${pc8.cyan("~/.config/claude/claude_desktop_config.json")}:
-${pc8.dim(`{
-  "mcpServers": {
-    "rrce": {
-      "command": "npx",
-      "args": ["rrce-workflow", "mcp", "start"]
-    }
-  }
-}`)}
+${pc3.bold("IDE INSTALLATION")}
+  ${pc3.cyan("Antigravity")}    ~/.gemini/antigravity/mcp_config.json
+  ${pc3.cyan("VSCode Global")} ~/.config/Code/User/settings.json
+  ${pc3.cyan("VSCode Workspace")} .vscode/mcp.json
+  ${pc3.cyan("Claude Desktop")} ~/.config/claude/claude_desktop_config.json
 
-${pc8.bold("RESOURCES EXPOSED")}
-  ${pc8.cyan("rrce://projects")}              List all exposed projects
-  ${pc8.cyan("rrce://projects/{name}/context")}  Get project context
-  ${pc8.cyan("rrce://projects/{name}/tasks")}    Get project tasks
+${pc3.bold("SERVER COMMANDS")} (while running)
+  ${pc3.cyan("q")} Stop and quit       ${pc3.cyan("p")} Reconfigure projects
+  ${pc3.cyan("i")} Install to IDE      ${pc3.cyan("r")} Reload config
+  ${pc3.cyan("c")} Clear logs          ${pc3.cyan("?")} Show help
 
-${pc8.bold("PROMPTS (Agent Commands)")}
-  ${pc8.cyan("init")}      Initialize project context
-  ${pc8.cyan("research")}  Research requirements for a task
-  ${pc8.cyan("plan")}      Create execution plan
-  ${pc8.cyan("execute")}   Implement planned work
-  ${pc8.cyan("docs")}      Generate documentation
-  ${pc8.cyan("sync")}      Sync knowledge with codebase
+${pc3.bold("RESOURCES EXPOSED")}
+  ${pc3.cyan("rrce://projects")}              List all exposed projects
+  ${pc3.cyan("rrce://projects/{name}/context")}  Get project context
+  ${pc3.cyan("rrce://projects/{name}/tasks")}    Get project tasks
 `;
-  note7(help.trim(), "Help");
+  note2(help.trim(), "Help");
 }
 var init_mcp = __esm({
   "src/mcp/index.ts"() {
@@ -1822,157 +2213,20 @@ var init_mcp = __esm({
     init_detection();
     init_server();
     init_install();
+    init_paths();
   }
 });
 
-// src/commands/wizard/index.ts
-import { intro, select as select3, spinner as spinner5, note as note6, outro as outro5, isCancel as isCancel6 } from "@clack/prompts";
-import pc7 from "picocolors";
-import * as fs11 from "fs";
-
-// src/lib/git.ts
-import { execSync } from "child_process";
-function getGitUser() {
-  try {
-    const result = execSync("git config user.name", { encoding: "utf-8" });
-    return result.trim() || null;
-  } catch {
-    return null;
-  }
-}
-
-// src/commands/wizard/index.ts
-init_paths();
-init_detection();
-
 // src/commands/wizard/setup-flow.ts
-init_paths();
-init_prompts();
-import { group, select as select2, multiselect, confirm, spinner, note as note2, outro, cancel } from "@clack/prompts";
-import pc3 from "picocolors";
-import * as fs7 from "fs";
-import * as path8 from "path";
-
-// src/commands/wizard/utils.ts
-init_paths();
-import * as fs4 from "fs";
-import * as path4 from "path";
-function copyPromptsToDir(prompts, targetDir, extension) {
-  for (const prompt of prompts) {
-    const baseName = path4.basename(prompt.filePath, ".md");
-    const targetName = baseName + extension;
-    const targetPath = path4.join(targetDir, targetName);
-    const content = fs4.readFileSync(prompt.filePath, "utf-8");
-    fs4.writeFileSync(targetPath, content);
-  }
-}
-function copyDirRecursive(src, dest) {
-  const entries = fs4.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path4.join(src, entry.name);
-    const destPath = path4.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs4.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-// src/commands/wizard/vscode.ts
-init_paths();
-init_detection();
-import * as fs5 from "fs";
-import * as path5 from "path";
-function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
-  const workspaceFilePath = path5.join(workspacePath, `${workspaceName}.code-workspace`);
-  let workspace;
-  if (fs5.existsSync(workspaceFilePath)) {
-    try {
-      const content = fs5.readFileSync(workspaceFilePath, "utf-8");
-      workspace = JSON.parse(content);
-    } catch {
-      workspace = { folders: [], settings: {} };
-    }
-  } else {
-    workspace = { folders: [], settings: {} };
-  }
-  if (!workspace.settings) {
-    workspace.settings = {};
-  }
-  workspace.folders = workspace.folders.filter(
-    (f) => f.path === "." || !f.name?.startsWith("\u{1F4C1}") && !f.name?.startsWith("\u{1F4DA}") && !f.name?.startsWith("\u{1F4CE}") && !f.name?.startsWith("\u{1F4CB}")
-  );
-  const mainFolderIndex = workspace.folders.findIndex((f) => f.path === ".");
-  if (mainFolderIndex === -1) {
-    workspace.folders.unshift({
-      path: ".",
-      name: `\u{1F3E0} ${workspaceName} (workspace)`
-    });
-  } else {
-    workspace.folders[mainFolderIndex] = {
-      path: ".",
-      name: `\u{1F3E0} ${workspaceName} (workspace)`
-    };
-  }
-  const referenceFolderPaths = [];
-  const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === "object";
-  if (isDetectedProjects) {
-    const projects = linkedProjects;
-    for (const project of projects) {
-      const sourceLabel = project.source === "global" ? "global" : "local";
-      const folderPath = project.dataPath;
-      if (fs5.existsSync(folderPath)) {
-        referenceFolderPaths.push(folderPath);
-        workspace.folders.push({
-          path: folderPath,
-          name: `\u{1F4C1} ${project.name} [${sourceLabel}]`
-        });
-      }
-    }
-  } else {
-    const projectNames = linkedProjects;
-    const rrceHome = customGlobalPath || getRRCEHome();
-    for (const projectName of projectNames) {
-      const folderPath = path5.join(rrceHome, "workspaces", projectName);
-      if (fs5.existsSync(folderPath)) {
-        referenceFolderPaths.push(folderPath);
-        workspace.folders.push({
-          path: folderPath,
-          name: `\u{1F4C1} ${projectName} [global]`
-        });
-      }
-    }
-  }
-  if (referenceFolderPaths.length > 0) {
-    const readonlyPatterns = {};
-    for (const folderPath of referenceFolderPaths) {
-      readonlyPatterns[`${folderPath}/**`] = true;
-    }
-    const existingReadonly = workspace.settings["files.readonlyInclude"] || {};
-    const cleanedReadonly = {};
-    for (const [pattern, value] of Object.entries(existingReadonly)) {
-      if (!pattern.includes(".rrce-workflow") && !pattern.includes("rrce-workflow/workspaces")) {
-        cleanedReadonly[pattern] = value;
-      }
-    }
-    workspace.settings["files.readonlyInclude"] = {
-      ...cleanedReadonly,
-      ...readonlyPatterns
-    };
-  }
-  fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
-}
-
-// src/commands/wizard/setup-flow.ts
-init_detection();
-init_tui_utils();
+import { group, select as select3, multiselect as multiselect2, confirm as confirm2, spinner as spinner2, note as note3, outro as outro2, cancel as cancel2, isCancel as isCancel3 } from "@clack/prompts";
+import pc4 from "picocolors";
+import * as fs11 from "fs";
+import * as path12 from "path";
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
-  const s = spinner();
+  const s = spinner2();
   const config = await group(
     {
-      storageMode: () => select2({
+      storageMode: () => select3({
         message: "Where should workflow data be stored?",
         options: [
           { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Cross-project access, clean workspace" },
@@ -1980,7 +2234,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
         ],
         initialValue: "global"
       }),
-      tools: () => multiselect({
+      tools: () => multiselect2({
         message: "Which AI tools do you use?",
         options: [
           { value: "copilot", label: "GitHub Copilot", hint: "VSCode" },
@@ -1992,44 +2246,44 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
         if (existingProjects.length === 0) {
           return Promise.resolve([]);
         }
-        return multiselect({
+        return multiselect2({
           message: "Link knowledge from other projects?",
           options: existingProjects.map((project) => ({
             value: `${project.name}:${project.source}`,
             // Unique key
-            label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
-            hint: pc3.dim(
+            label: `${project.name} ${pc4.dim(`(${project.source})`)}`,
+            hint: pc4.dim(
               project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
             )
           })),
           required: false
         });
       },
-      addToGitignore: () => confirm({
+      addToGitignore: () => confirm2({
         message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
         initialValue: true
       }),
-      confirm: () => confirm({
+      confirm: () => confirm2({
         message: "Create configuration?",
         initialValue: true
       })
     },
     {
       onCancel: () => {
-        cancel("Setup process cancelled.");
+        cancel2("Setup process cancelled.");
         process.exit(0);
       }
     }
   );
   if (!config.confirm) {
-    outro("Setup cancelled by user.");
+    outro2("Setup cancelled by user.");
     process.exit(0);
   }
   let customGlobalPath;
   if (config.storageMode === "global") {
     customGlobalPath = await resolveGlobalPath();
     if (!customGlobalPath) {
-      cancel("Setup cancelled - no writable global path available.");
+      cancel2("Setup cancelled - no writable global path available.");
       process.exit(1);
     }
   }
@@ -2053,7 +2307,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       `Storage: ${config.storageMode}`
     ];
     if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc3.cyan(customGlobalPath)}`);
+      summary.push(`Global path: ${pc4.cyan(customGlobalPath)}`);
     }
     if (dataPaths.length > 0) {
       summary.push(`Data paths:`);
@@ -2066,17 +2320,26 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     const linkedProjects = config.linkedProjects;
     if (linkedProjects.length > 0) {
       summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
-      summary.push(`Workspace file: ${pc3.cyan(`${workspaceName}.code-workspace`)}`);
+      summary.push(`Workspace file: ${pc4.cyan(`${workspaceName}.code-workspace`)}`);
     }
-    note2(summary.join("\n"), "Setup Summary");
-    if (linkedProjects.length > 0) {
-      outro(pc3.green(`\u2713 Setup complete! Open ${pc3.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+    note3(summary.join("\n"), "Setup Summary");
+    const shouldConfigureMCP = await confirm2({
+      message: "Would you like to configure the MCP server now?",
+      initialValue: true
+    });
+    if (shouldConfigureMCP && !isCancel3(shouldConfigureMCP)) {
+      const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      await runMCP2();
     } else {
-      outro(pc3.green(`\u2713 Setup complete! Your agents are ready to use.`));
+      if (linkedProjects.length > 0) {
+        outro2(pc4.green(`\u2713 Setup complete! Open ${pc4.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+      } else {
+        outro2(pc4.green(`\u2713 Setup complete! Your agents are ready to use.`));
+      }
     }
   } catch (error) {
     s.stop("Error occurred");
-    cancel(`Failed to setup: ${error instanceof Error ? error.message : String(error)}`);
+    cancel2(`Failed to setup: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
@@ -2084,14 +2347,14 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path8.join(dataPath, "knowledge"));
-    ensureDir(path8.join(dataPath, "refs"));
-    ensureDir(path8.join(dataPath, "tasks"));
-    ensureDir(path8.join(dataPath, "templates"));
+    ensureDir(path12.join(dataPath, "knowledge"));
+    ensureDir(path12.join(dataPath, "refs"));
+    ensureDir(path12.join(dataPath, "tasks"));
+    ensureDir(path12.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path12.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (config.tools.includes("copilot")) {
     const copilotPath = getAgentPromptPath(workspacePath, "copilot");
@@ -2103,8 +2366,8 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
     ensureDir(antigravityPath);
     copyPromptsToDir(prompts, antigravityPath, ".md");
   }
-  const workspaceConfigPath = path8.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path8.dirname(workspaceConfigPath));
+  const workspaceConfigPath = path12.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path12.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -2132,7 +2395,7 @@ linked_projects:
 `;
     });
   }
-  fs7.writeFileSync(workspaceConfigPath, configContent);
+  fs11.writeFileSync(workspaceConfigPath, configContent);
   if (config.addToGitignore) {
     updateGitignore(workspacePath, config.storageMode, config.tools);
   }
@@ -2144,8 +2407,8 @@ linked_projects:
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path8.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path12.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path12.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -2156,7 +2419,7 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
   }
 }
 function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path8.join(workspacePath, ".gitignore");
+  const gitignorePath = path12.join(workspacePath, ".gitignore");
   const entries = [];
   if (storageMode === "workspace") {
     entries.push(".rrce-workflow/");
@@ -2172,8 +2435,8 @@ function updateGitignore(workspacePath, storageMode, tools) {
   }
   try {
     let content = "";
-    if (fs7.existsSync(gitignorePath)) {
-      content = fs7.readFileSync(gitignorePath, "utf-8");
+    if (fs11.existsSync(gitignorePath)) {
+      content = fs11.readFileSync(gitignorePath, "utf-8");
     }
     const lines = content.split("\n").map((line) => line.trim());
     const newEntries = [];
@@ -2198,57 +2461,66 @@ function updateGitignore(workspacePath, storageMode, tools) {
       newContent += "\n# rrce-workflow generated folders (uncomment to ignore)\n";
     }
     newContent += newEntries.map((e) => `# ${e}`).join("\n") + "\n";
-    fs7.writeFileSync(gitignorePath, newContent);
+    fs11.writeFileSync(gitignorePath, newContent);
     return true;
   } catch {
     return false;
   }
 }
+var init_setup_flow = __esm({
+  "src/commands/wizard/setup-flow.ts"() {
+    "use strict";
+    init_paths();
+    init_prompts();
+    init_utils();
+    init_vscode();
+    init_detection();
+    init_tui_utils();
+  }
+});
 
 // src/commands/wizard/link-flow.ts
-init_paths();
-import { multiselect as multiselect2, spinner as spinner2, note as note3, outro as outro2, cancel as cancel2, isCancel as isCancel3 } from "@clack/prompts";
-import pc4 from "picocolors";
-import * as fs8 from "fs";
-init_detection();
+import { multiselect as multiselect3, spinner as spinner3, note as note4, outro as outro3, cancel as cancel3, isCancel as isCancel4 } from "@clack/prompts";
+import pc5 from "picocolors";
+import * as fs12 from "fs";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
     workspacePath
   });
   if (projects.length === 0) {
-    outro2(pc4.yellow("No other projects found. Try setting up another project first."));
+    outro3(pc5.yellow("No other projects found. Try setting up another project first."));
     return;
   }
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const linkedProjects = await multiselect2({
+  const linkedProjects = await multiselect3({
     message: "Select projects to link:",
     options: projects.map((project) => ({
       value: `${project.name}:${project.source}`,
       // Unique key
-      label: `${project.name} ${pc4.dim(`(${project.source})`)}`,
-      hint: pc4.dim(
+      label: `${project.name} ${pc5.dim(`(${project.source})`)}`,
+      hint: pc5.dim(
         project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
       )
     })),
     required: true
   });
-  if (isCancel3(linkedProjects)) {
-    cancel2("Cancelled.");
+  if (isCancel4(linkedProjects)) {
+    cancel3("Cancelled.");
     process.exit(0);
   }
   const selectedKeys = linkedProjects;
   if (selectedKeys.length === 0) {
-    outro2("No projects selected.");
+    outro3("No projects selected.");
     return;
   }
   const selectedProjects = projects.filter(
     (p) => selectedKeys.includes(`${p.name}:${p.source}`)
   );
-  const s = spinner2();
+  const s = spinner3();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs8.readFileSync(configFilePath, "utf-8");
+  let configContent = fs12.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -2275,60 +2547,67 @@ linked_projects:
 `;
     });
   }
-  fs8.writeFileSync(configFilePath, configContent);
+  fs12.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
   const summary = [
     `Linked projects:`,
-    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc4.dim(`(${p.source})`)}`),
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc5.dim(`(${p.source})`)}`),
     ``,
-    `Workspace file: ${pc4.cyan(workspaceFile)}`
+    `Workspace file: ${pc5.cyan(workspaceFile)}`
   ];
-  note3(summary.join("\n"), "Link Summary");
-  outro2(pc4.green(`\u2713 Projects linked! Open ${pc4.bold(workspaceFile)} in VSCode to access linked data.`));
+  note4(summary.join("\n"), "Link Summary");
+  outro3(pc5.green(`\u2713 Projects linked! Open ${pc5.bold(workspaceFile)} in VSCode to access linked data.`));
 }
+var init_link_flow = __esm({
+  "src/commands/wizard/link-flow.ts"() {
+    "use strict";
+    init_paths();
+    init_vscode();
+    init_detection();
+  }
+});
 
 // src/commands/wizard/sync-flow.ts
-init_paths();
-import { confirm as confirm2, spinner as spinner3, note as note4, outro as outro3, cancel as cancel3, isCancel as isCancel4 } from "@clack/prompts";
-import pc5 from "picocolors";
-import * as fs9 from "fs";
-import * as path9 from "path";
+import { confirm as confirm3, spinner as spinner4, note as note5, outro as outro4, cancel as cancel4, isCancel as isCancel5 } from "@clack/prompts";
+import pc6 from "picocolors";
+import * as fs13 from "fs";
+import * as path13 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path13.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs9.existsSync(path9.join(localPath, dir))
+    (dir) => fs13.existsSync(path13.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
-    outro3(pc5.yellow("No data found in workspace storage to sync."));
+    outro4(pc6.yellow("No data found in workspace storage to sync."));
     return;
   }
-  note4(
+  note5(
     `The following will be copied to global storage:
 ${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 
-Destination: ${pc5.cyan(globalPath)}`,
+Destination: ${pc6.cyan(globalPath)}`,
     "Sync Preview"
   );
-  const shouldSync = await confirm2({
+  const shouldSync = await confirm3({
     message: "Proceed with sync to global storage?",
     initialValue: true
   });
-  if (isCancel4(shouldSync) || !shouldSync) {
-    outro3("Sync cancelled.");
+  if (isCancel5(shouldSync) || !shouldSync) {
+    outro4("Sync cancelled.");
     return;
   }
-  const s = spinner3();
+  const s = spinner4();
   s.start("Syncing to global storage");
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path9.join(localPath, dir);
-      const destDir = path9.join(globalPath, dir);
+      const srcDir = path13.join(localPath, dir);
+      const destDir = path13.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -2337,28 +2616,33 @@ Destination: ${pc5.cyan(globalPath)}`,
       `Synced directories:`,
       ...existingDirs.map((d) => `  \u2713 ${d}/`),
       ``,
-      `Global path: ${pc5.cyan(globalPath)}`,
+      `Global path: ${pc6.cyan(globalPath)}`,
       ``,
       `Other projects can now link this knowledge!`
     ];
-    note4(summary.join("\n"), "Sync Summary");
-    outro3(pc5.green("\u2713 Workspace knowledge synced to global storage!"));
+    note5(summary.join("\n"), "Sync Summary");
+    outro4(pc6.green("\u2713 Workspace knowledge synced to global storage!"));
   } catch (error) {
     s.stop("Error occurred");
-    cancel3(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
+    cancel4(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
+var init_sync_flow = __esm({
+  "src/commands/wizard/sync-flow.ts"() {
+    "use strict";
+    init_paths();
+    init_utils();
+  }
+});
 
 // src/commands/wizard/update-flow.ts
-init_paths();
-init_prompts();
-import { confirm as confirm3, spinner as spinner4, note as note5, outro as outro4, cancel as cancel4, isCancel as isCancel5 } from "@clack/prompts";
-import pc6 from "picocolors";
-import * as fs10 from "fs";
-import * as path10 from "path";
+import { confirm as confirm4, spinner as spinner5, note as note6, outro as outro5, cancel as cancel5, isCancel as isCancel6 } from "@clack/prompts";
+import pc7 from "picocolors";
+import * as fs14 from "fs";
+import * as path14 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
-  const s = spinner4();
+  const s = spinner5();
   s.start("Checking for updates");
   try {
     const agentCoreDir = getAgentCoreDir();
@@ -2367,7 +2651,7 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const customGlobalPath = getEffectiveRRCEHome(workspacePath);
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     s.stop("Updates found");
-    note5(
+    note6(
       `The following will be updated from the package:
   \u2022 prompts/ (${prompts.length} agent prompts)
   \u2022 templates/ (output templates)
@@ -2376,20 +2660,20 @@ Target locations:
 ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       "Update Preview"
     );
-    const shouldUpdate = await confirm3({
+    const shouldUpdate = await confirm4({
       message: "Proceed with update?",
       initialValue: true
     });
-    if (isCancel5(shouldUpdate) || !shouldUpdate) {
-      outro4("Update cancelled.");
+    if (isCancel6(shouldUpdate) || !shouldUpdate) {
+      outro5("Update cancelled.");
       return;
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path10.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path14.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs10.readFileSync(configFilePath, "utf-8");
+    const configContent = fs14.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -2408,17 +2692,17 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       ``,
       `Your configuration and knowledge files were preserved.`
     ];
-    note5(summary.join("\n"), "Update Summary");
-    outro4(pc6.green("\u2713 Successfully updated from package!"));
+    note6(summary.join("\n"), "Update Summary");
+    outro5(pc7.green("\u2713 Successfully updated from package!"));
   } catch (error) {
     s.stop("Error occurred");
-    cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
+    cancel5(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path10.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path14.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path14.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -2428,20 +2712,35 @@ function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot,
       return [globalPath];
   }
 }
+var init_update_flow = __esm({
+  "src/commands/wizard/update-flow.ts"() {
+    "use strict";
+    init_paths();
+    init_prompts();
+    init_utils();
+  }
+});
 
 // src/commands/wizard/index.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  runWizard: () => runWizard
+});
+import { intro as intro2, select as select4, spinner as spinner6, note as note7, outro as outro6, isCancel as isCancel7 } from "@clack/prompts";
+import pc8 from "picocolors";
+import * as fs15 from "fs";
 async function runWizard() {
-  intro(pc7.cyan(pc7.inverse(" RRCE-Workflow Setup ")));
-  const s = spinner5();
+  intro2(pc8.cyan(pc8.inverse(" RRCE-Workflow Setup ")));
+  const s = spinner6();
   s.start("Detecting environment");
   const workspacePath = detectWorkspaceRoot();
   const workspaceName = getWorkspaceName(workspacePath);
   const gitUser = getGitUser();
   await new Promise((r) => setTimeout(r, 800));
   s.stop("Environment detected");
-  note6(
-    `Git User:  ${pc7.bold(gitUser || "(not found)")}
-Workspace: ${pc7.bold(workspaceName)}`,
+  note7(
+    `Git User:  ${pc8.bold(gitUser || "(not found)")}
+Workspace: ${pc8.bold(workspaceName)}`,
     "Context"
   );
   const detectedProjects = scanForProjects({
@@ -2449,44 +2748,53 @@ Workspace: ${pc7.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs11.existsSync(configFilePath);
+  const isAlreadyConfigured = fs15.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs11.readFileSync(configFilePath, "utf-8");
+      const configContent = fs15.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs11.existsSync(localDataPath);
+  const hasLocalData = fs15.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
+    menuOptions.push({
+      value: "mcp",
+      label: "\u{1F50C} Configure MCP Server",
+      hint: "Expose projects to AI assistants (VSCode, Antigravity, Claude)"
+    });
     if (detectedProjects.length > 0) {
       menuOptions.push({
         value: "link",
-        label: "Link other project knowledge",
+        label: "\u{1F517} Link other project knowledge",
         hint: `${detectedProjects.length} projects detected (global + sibling)`
       });
     }
     if (currentStorageMode === "workspace" && hasLocalData) {
       menuOptions.push({
         value: "sync-global",
-        label: "Sync to global storage",
+        label: "\u2601\uFE0F  Sync to global storage",
         hint: "Share knowledge with other projects"
       });
     }
-    menuOptions.push({ value: "update", label: "Update from package", hint: "Get latest prompts & templates" });
-    menuOptions.push({ value: "exit", label: "Exit" });
-    const action = await select3({
+    menuOptions.push({ value: "update", label: "\u{1F4E6} Update from package", hint: "Get latest prompts & templates" });
+    menuOptions.push({ value: "exit", label: "\u21A9  Exit" });
+    const action = await select4({
       message: "This workspace is already configured. What would you like to do?",
       options: menuOptions
     });
-    if (isCancel6(action) || action === "exit") {
-      outro5("Exited.");
+    if (isCancel7(action) || action === "exit") {
+      outro6("Exited.");
       process.exit(0);
     }
+    if (action === "mcp") {
+      await runMCP();
+      return;
+    }
     if (action === "link") {
       await runLinkProjectsFlow(workspacePath, workspaceName);
       return;
@@ -2502,6 +2810,22 @@ Workspace: ${pc7.bold(workspaceName)}`,
   }
   await runSetupFlow(workspacePath, workspaceName, detectedProjects);
 }
+var init_wizard = __esm({
+  "src/commands/wizard/index.ts"() {
+    "use strict";
+    init_git();
+    init_paths();
+    init_detection();
+    init_setup_flow();
+    init_link_flow();
+    init_sync_flow();
+    init_update_flow();
+    init_mcp();
+  }
+});
+
+// src/index.ts
+init_wizard();
 
 // src/commands/selector.ts
 init_prompts();
@@ -2521,9 +2845,14 @@ async function runSelector() {
     options: [
       {
         value: "mcp",
-        label: "Manage MCP Hub",
+        label: "\u{1F50C} Manage MCP Hub",
         hint: "Configure & Start MCP Server"
       },
+      {
+        value: "wizard",
+        label: "\u2728 Run Setup Wizard",
+        hint: "Configure workspace & agents"
+      },
       ...prompts.map((p) => ({
         value: p,
         label: p.frontmatter.name,
@@ -2540,6 +2869,11 @@ async function runSelector() {
     await runMCP2();
     return;
   }
+  if (selection === "wizard") {
+    const { runWizard: runWizard2 } = await Promise.resolve().then(() => (init_wizard(), wizard_exports));
+    await runWizard2();
+    return;
+  }
   const prompt = selection;
   note8(
     `Use this agent in your IDE by invoking: