rrce-workflow 0.2.28 → 0.2.30

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,31 @@ var init_types = __esm({
 });
 
 // src/mcp/config.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+var config_exports = {};
+__export(config_exports, {
+  ensureMCPGlobalPath: () => ensureMCPGlobalPath,
+  getMCPConfigPath: () => getMCPConfigPath,
+  getProjectPermissions: () => getProjectPermissions,
+  isProjectExposed: () => isProjectExposed,
+  loadMCPConfig: () => loadMCPConfig,
+  removeProjectConfig: () => removeProjectConfig,
+  saveMCPConfig: () => saveMCPConfig,
+  setProjectConfig: () => setProjectConfig
+});
+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 (fs11.existsSync(configPath)) {
-      const content = fs11.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 +763,11 @@ function ensureMCPGlobalPath() {
 }
 function loadMCPConfig() {
   const configPath = getMCPConfigPath();
-  if (!fs11.existsSync(configPath)) {
+  if (!fs7.existsSync(configPath)) {
     return { ...DEFAULT_MCP_CONFIG };
   }
   try {
-    const content = fs11.readFileSync(configPath, "utf-8");
+    const content = fs7.readFileSync(configPath, "utf-8");
     return parseMCPConfig(content);
   } catch {
     return { ...DEFAULT_MCP_CONFIG };
@@ -626,12 +775,12 @@ function loadMCPConfig() {
 }
 function saveMCPConfig(config) {
   const configPath = getMCPConfigPath();
-  const dir = path11.dirname(configPath);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(configPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
   const content = serializeMCPConfig(config);
-  fs11.writeFileSync(configPath, content);
+  fs7.writeFileSync(configPath, content);
 }
 function parseMCPConfig(content) {
   const config = { ...DEFAULT_MCP_CONFIG, projects: [] };
@@ -769,6 +918,10 @@ function setProjectConfig(config, name, expose, permissions) {
   }
   return config;
 }
+function removeProjectConfig(config, name) {
+  config.projects = config.projects.filter((p) => p.name !== name);
+  return config;
+}
 function isProjectExposed(config, name) {
   const project = config.projects.find((p) => p.name === name);
   if (project) {
@@ -794,12 +947,12 @@ __export(logger_exports, {
   getLogFilePath: () => getLogFilePath,
   logger: () => logger
 });
-import * as fs12 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 +983,11 @@ ${JSON.stringify(data, null, 2)}`;
         }
         logMessage += "\n";
         try {
-          const dir = path12.dirname(this.logPath);
-          if (!fs12.existsSync(dir)) {
-            fs12.mkdirSync(dir, { recursive: true });
+          const dir = path9.dirname(this.logPath);
+          if (!fs8.existsSync(dir)) {
+            fs8.mkdirSync(dir, { recursive: true });
           }
-          fs12.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 +1011,8 @@ ${JSON.stringify(data, null, 2)}`;
 });
 
 // src/mcp/resources.ts
-import * as fs13 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 +1039,11 @@ function getProjectContext(projectName) {
   if (!project?.knowledgePath) {
     return null;
   }
-  const contextPath = path13.join(project.knowledgePath, "project-context.md");
-  if (!fs13.existsSync(contextPath)) {
+  const contextPath = path10.join(project.knowledgePath, "project-context.md");
+  if (!fs9.existsSync(contextPath)) {
     return null;
   }
-  return fs13.readFileSync(contextPath, "utf-8");
+  return fs9.readFileSync(contextPath, "utf-8");
 }
 function getProjectTasks(projectName) {
   const config = loadMCPConfig();
@@ -903,18 +1056,18 @@ function getProjectTasks(projectName) {
   }
   const projects = scanForProjects();
   const project = projects.find((p) => p.name === projectName);
-  if (!project?.tasksPath || !fs13.existsSync(project.tasksPath)) {
+  if (!project?.tasksPath || !fs9.existsSync(project.tasksPath)) {
     return [];
   }
   const tasks = [];
   try {
-    const taskDirs = fs13.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 (fs13.existsSync(metaPath)) {
+      const metaPath = path10.join(project.tasksPath, dir.name, "meta.json");
+      if (fs9.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs13.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
           tasks.push(meta);
         } catch {
         }
@@ -933,11 +1086,11 @@ function searchKnowledge(query) {
     const permissions = getProjectPermissions(config, project.name);
     if (!permissions.knowledge || !project.knowledgePath) continue;
     try {
-      const files = fs13.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 = fs13.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 +1258,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,8 +1511,8 @@ var init_server = __esm({
 });
 
 // src/mcp/install.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import * as os from "os";
 function checkInstallStatus(workspacePath) {
   return {
@@ -1369,37 +1523,37 @@ function checkInstallStatus(workspacePath) {
   };
 }
 function checkAntigravityConfig() {
-  if (!fs14.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  if (!fs10.existsSync(ANTIGRAVITY_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs14.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    const content = JSON.parse(fs10.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkClaudeConfig() {
-  if (!fs14.existsSync(CLAUDE_CONFIG)) return false;
+  if (!fs10.existsSync(CLAUDE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs14.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs10.readFileSync(CLAUDE_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeGlobalConfig() {
-  if (!fs14.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  if (!fs10.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs14.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    const content = JSON.parse(fs10.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     return !!content["mcp.servers"]?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path14.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs14.existsSync(configPath)) return false;
+  const configPath = path11.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs10.existsSync(configPath)) return false;
   try {
-    const content = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
     return !!content.servers?.["rrce"];
   } catch {
     return false;
@@ -1424,14 +1578,14 @@ function installToConfig(target, workspacePath) {
   }
 }
 function installToAntigravity() {
-  const dir = path14.dirname(ANTIGRAVITY_CONFIG);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path11.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs14.existsSync(ANTIGRAVITY_CONFIG)) {
+  if (fs10.existsSync(ANTIGRAVITY_CONFIG)) {
     try {
-      config = JSON.parse(fs14.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+      config = JSON.parse(fs10.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -1441,21 +1595,21 @@ function installToAntigravity() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs14.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    fs10.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToClaude() {
-  const dir = path14.dirname(CLAUDE_CONFIG);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path11.dirname(CLAUDE_CONFIG);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs14.existsSync(CLAUDE_CONFIG)) {
+  if (fs10.existsSync(CLAUDE_CONFIG)) {
     try {
-      config = JSON.parse(fs14.readFileSync(CLAUDE_CONFIG, "utf-8"));
+      config = JSON.parse(fs10.readFileSync(CLAUDE_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -1465,21 +1619,21 @@ function installToClaude() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs14.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    fs10.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeGlobal() {
-  const dir = path14.dirname(VSCODE_GLOBAL_CONFIG);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path11.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
   let settings = {};
-  if (fs14.existsSync(VSCODE_GLOBAL_CONFIG)) {
+  if (fs10.existsSync(VSCODE_GLOBAL_CONFIG)) {
     try {
-      settings = JSON.parse(fs14.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+      settings = JSON.parse(fs10.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -1489,22 +1643,22 @@ function installToVSCodeGlobal() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs14.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    fs10.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path14.join(workspacePath, ".vscode");
-  const configPath = path14.join(vscodeDir, "mcp.json");
-  if (!fs14.existsSync(vscodeDir)) {
-    fs14.mkdirSync(vscodeDir, { recursive: true });
+  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 (fs14.existsSync(configPath)) {
+  if (fs10.existsSync(configPath)) {
     try {
-      config = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
+      config = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
     } catch {
     }
   }
@@ -1514,7 +1668,7 @@ function installToVSCodeWorkspace(workspacePath) {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs14.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs10.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
@@ -1538,9 +1692,229 @@ 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");
-    VSCODE_GLOBAL_CONFIG = path14.join(os.homedir(), ".config/Code/User/settings.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");
+  }
+});
+
+// src/mcp/ui/Header.tsx
+import "react";
+import { Box, Text } from "ink";
+import { jsx } from "react/jsx-runtime";
+var Header;
+var init_Header = __esm({
+  "src/mcp/ui/Header.tsx"() {
+    "use strict";
+    Header = () => /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingBottom: 1, children: /* @__PURE__ */ jsx(Box, { borderStyle: "double", borderColor: "cyan", paddingX: 2, justifyContent: "center", children: /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: " RRCE MCP Hub " }) }) });
+  }
+});
+
+// src/mcp/ui/StatusBoard.tsx
+import "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var StatusBoard;
+var init_StatusBoard = __esm({
+  "src/mcp/ui/StatusBoard.tsx"() {
+    "use strict";
+    StatusBoard = ({ exposedLabel, port, pid }) => {
+      return /* @__PURE__ */ jsx2(Box2, { borderStyle: "single", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsxs(Text2, { children: [
+        "\u{1F4CB} ",
+        /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: exposedLabel }),
+        " ",
+        "\u2502",
+        " Port: ",
+        /* @__PURE__ */ jsx2(Text2, { color: "green", children: port }),
+        " ",
+        "\u2502",
+        " PID: ",
+        /* @__PURE__ */ jsx2(Text2, { color: "green", children: pid })
+      ] }) });
+    };
+  }
+});
+
+// src/mcp/ui/LogViewer.tsx
+import "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var LogViewer;
+var init_LogViewer = __esm({
+  "src/mcp/ui/LogViewer.tsx"() {
+    "use strict";
+    LogViewer = ({ logs, height }) => {
+      const visibleLogs = logs.slice(-height);
+      const emptyLines = Math.max(0, height - visibleLogs.length);
+      const padding = Array(emptyLines).fill("");
+      return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "dim", paddingX: 1, height: height + 2, flexGrow: 1, children: [
+        padding.map((_, i) => /* @__PURE__ */ jsx3(Text3, { children: " " }, `empty-${i}`)),
+        visibleLogs.map((log, i) => /* @__PURE__ */ jsx3(Text3, { wrap: "truncate-end", children: log }, `log-${i}`))
+      ] });
+    };
+  }
+});
+
+// src/mcp/ui/CommandBar.tsx
+import "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var CommandBar;
+var init_CommandBar = __esm({
+  "src/mcp/ui/CommandBar.tsx"() {
+    "use strict";
+    CommandBar = () => {
+      return /* @__PURE__ */ jsx4(Box4, { borderStyle: "single", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsxs3(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "q" }),
+        ":Quit  ",
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "p" }),
+        ":Projects  ",
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "i" }),
+        ":Install  ",
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "r" }),
+        ":Reload  ",
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "c" }),
+        ":Clear  ",
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "?" }),
+        ":Help"
+      ] }) });
+    };
+  }
+});
+
+// src/mcp/ui/Dashboard.tsx
+import "react";
+import { Box as Box5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var Dashboard;
+var init_Dashboard = __esm({
+  "src/mcp/ui/Dashboard.tsx"() {
+    "use strict";
+    init_Header();
+    init_StatusBoard();
+    init_LogViewer();
+    init_CommandBar();
+    Dashboard = ({ logs, exposedLabel, port, pid, logHeight }) => {
+      return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", padding: 0, children: [
+        /* @__PURE__ */ jsx5(Header, {}),
+        /* @__PURE__ */ jsx5(LogViewer, { logs, height: logHeight }),
+        /* @__PURE__ */ jsx5(StatusBoard, { exposedLabel, port, pid }),
+        /* @__PURE__ */ jsx5(CommandBar, {})
+      ] });
+    };
+  }
+});
+
+// src/mcp/ui/App.tsx
+var App_exports = {};
+__export(App_exports, {
+  App: () => App
+});
+import { useState, useEffect as useEffect2 } from "react";
+import { useInput, useApp } from "ink";
+import fs11 from "fs";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var App;
+var init_App = __esm({
+  "src/mcp/ui/App.tsx"() {
+    "use strict";
+    init_Dashboard();
+    init_config();
+    init_detection();
+    init_logger();
+    init_server();
+    App = ({ onExit, onConfigure, onInstall, initialPort }) => {
+      const { exit } = useApp();
+      const [logs, setLogs] = useState([]);
+      const [serverInfo, setServerInfo] = useState({
+        port: initialPort,
+        pid: process.pid,
+        running: false
+      });
+      const config = loadMCPConfig();
+      const projects = scanForProjects();
+      const exposedProjects = projects.filter((p) => {
+        const cfg = config.projects.find((c) => c.name === p.name);
+        return cfg?.expose ?? config.defaults.includeNew;
+      });
+      const exposedNames = exposedProjects.map((p) => p.name).slice(0, 5);
+      const exposedLabel = exposedNames.length > 0 ? exposedNames.join(", ") + (exposedProjects.length > 5 ? ` (+${exposedProjects.length - 5} more)` : "") : "(none)";
+      useEffect2(() => {
+        const start = async () => {
+          const status = getMCPServerStatus();
+          if (!status.running) {
+            try {
+              const res = await startMCPServer();
+              setServerInfo((prev) => ({ ...prev, running: true, port: res.port, pid: res.pid }));
+            } catch (e) {
+              setLogs((prev) => [...prev, `Error starting server: ${e}`]);
+            }
+          } else {
+            setServerInfo((prev) => ({ ...prev, running: true, port: status.port || initialPort, pid: status.pid || process.pid }));
+          }
+        };
+        start();
+        return () => {
+        };
+      }, []);
+      useEffect2(() => {
+        const logPath = getLogFilePath();
+        let lastSize = 0;
+        if (fs11.existsSync(logPath)) {
+          const stats = fs11.statSync(logPath);
+          lastSize = stats.size;
+        }
+        const interval = setInterval(() => {
+          if (fs11.existsSync(logPath)) {
+            const stats = fs11.statSync(logPath);
+            if (stats.size > lastSize) {
+              const buffer = Buffer.alloc(stats.size - lastSize);
+              const fd = fs11.openSync(logPath, "r");
+              fs11.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs11.closeSync(fd);
+              const newContent = buffer.toString("utf-8");
+              const newLines = newContent.split("\n").filter((l) => l.trim());
+              setLogs((prev) => {
+                const next = [...prev, ...newLines];
+                return next.slice(-50);
+              });
+              lastSize = stats.size;
+            }
+          }
+        }, 500);
+        return () => clearInterval(interval);
+      }, []);
+      useInput((input, key) => {
+        if (input === "q" || key.ctrl && input === "c") {
+          stopMCPServer();
+          onExit();
+        }
+        if (input === "p") {
+          onConfigure();
+        }
+        if (input === "i") {
+          onInstall();
+        }
+        if (input === "c") {
+          setLogs([]);
+        }
+        if (input === "r") {
+          setLogs((prev) => [...prev, "[INFO] Config reload requested..."]);
+        }
+      });
+      const termHeight = process.stdout.rows || 24;
+      const logHeight = Math.max(5, termHeight - 12);
+      return /* @__PURE__ */ jsx6(
+        Dashboard,
+        {
+          logs,
+          exposedLabel,
+          port: serverInfo.port,
+          pid: serverInfo.pid,
+          logHeight
+        }
+      );
+    };
   }
 });
 
@@ -1549,15 +1923,19 @@ var mcp_exports = {};
 __export(mcp_exports, {
   runMCP: () => runMCP
 });
-import { intro, outro as outro5, select as select3, multiselect as multiselect3, confirm as confirm4, spinner as spinner5, note as note6, cancel as cancel5, isCancel as isCancel6, text as text2 } from "@clack/prompts";
-import pc7 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) {
       case "start":
-        await startMCPServer();
-        await new Promise(() => {
-        });
+        if (process.stdout.isTTY) {
+          await handleStartServer();
+        } else {
+          await startMCPServer();
+          await new Promise(() => {
+          });
+        }
         return;
       case "stop":
         await handleStopServer();
@@ -1570,57 +1948,60 @@ async function runMCP(subcommand2) {
         return;
     }
   }
-  intro(pc7.bgCyan(pc7.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) {
-      outro5(pc7.yellow("MCP requires a global storage path. Setup cancelled."));
+      outro(pc3.yellow("MCP requires a global storage path. Setup cancelled."));
       return;
     }
   }
-  const status = checkInstallStatus(workspacePath);
   const installed = isInstalledAnywhere(workspacePath);
   if (!installed) {
-    note6(
-      `${pc7.bold("Welcome to RRCE MCP Hub!")}
+    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 confirm4({
+    const shouldInstall = await confirm({
       message: "Install MCP server to your IDE(s)?",
       initialValue: true
     });
-    if (shouldInstall && !isCancel6(shouldInstall)) {
+    if (shouldInstall && !isCancel2(shouldInstall)) {
       await handleInstallWizard(workspacePath);
-      await handleConfigure();
-      const shouldStart = await confirm4({
+      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 && !isCancel6(shouldStart)) {
+      if (shouldStart && !isCancel2(shouldStart)) {
         await handleStartServer();
       }
     }
-    outro5(pc7.green("MCP Hub setup complete!"));
+    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) {
-    note6("MCP is installed but no projects are exposed. Let's configure that.", "Configuration Needed");
+    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 ? pc7.green("\u25CF Running") : pc7.dim("\u25CB Stopped");
+    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 select3({
+    const action = await select2({
       message: "What would you like to do?",
       options: [
         { value: "start", label: `\u25B6\uFE0F  Start MCP server`, hint: serverLabel },
@@ -1631,8 +2012,8 @@ project knowledge in real-time. Let's get you set up.`,
         { value: "exit", label: "\u21A9  Exit", hint: "Return to shell" }
       ]
     });
-    if (isCancel6(action)) {
-      cancel5("MCP Hub closed.");
+    if (isCancel2(action)) {
+      cancel("MCP Hub closed.");
       return;
     }
     switch (action) {
@@ -1656,7 +2037,7 @@ project knowledge in real-time. Let's get you set up.`,
         break;
     }
   }
-  outro5(pc7.green("MCP Hub closed."));
+  outro(pc3.green("MCP Hub closed."));
 }
 async function handleInstallWizard(workspacePath) {
   const status = checkInstallStatus(workspacePath);
@@ -1664,25 +2045,25 @@ async function handleInstallWizard(workspacePath) {
     {
       value: "antigravity",
       label: "Antigravity IDE",
-      hint: status.antigravity ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")
+      hint: status.antigravity ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")
     },
     {
       value: "vscode-global",
-      label: "VSCode (Global)",
-      hint: status.vscodeGlobal ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")
+      label: "VSCode (Global Settings)",
+      hint: status.vscodeGlobal ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")
     },
     {
       value: "vscode-workspace",
-      label: "VSCode (This Workspace)",
-      hint: status.vscodeWorkspace ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")
+      label: "VSCode (Workspace Config)",
+      hint: status.vscodeWorkspace ? pc3.green("\u2713 Installed") : pc3.dim("Not installed")
     },
     {
       value: "claude",
       label: "Claude Desktop",
-      hint: status.claude ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")
+      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: [
@@ -1693,188 +2074,96 @@ async function handleInstallWizard(workspacePath) {
     ],
     required: false
   });
-  if (isCancel6(selected)) return;
+  if (isCancel2(selected)) return;
   const targets = selected;
   const results = [];
   for (const target of targets) {
     const success = installToConfig(target, workspacePath);
     const label = getTargetLabel(target);
-    results.push(`${label}: ${success ? pc7.green("\u2713 Success") : pc7.red("\u2717 Failed")}`);
+    results.push(`${label}: ${success ? pc3.green("\u2713 Success") : pc3.red("\u2717 Failed")}`);
   }
   if (results.length > 0) {
-    note6(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 React7 = await import("react");
+  const { render } = await import("ink");
+  const { App: App2 } = await Promise.resolve().then(() => (init_App(), App_exports));
+  const { loadMCPConfig: loadMCPConfig2, saveMCPConfig: saveMCPConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const config = loadMCPConfig2();
   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 confirm4({
+    const shouldConfig = await confirm({
       message: "No projects are currently exposed. Configure now?",
       initialValue: true
     });
-    if (shouldConfig && !isCancel6(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 initialPort = 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;
+    const newPort = parseInt(portInput, 10);
+    if (newPort !== config.server.port) {
+      config.server.port = newPort;
+      saveMCPConfig2(config);
+      initialPort = newPort;
     }
-  });
-  if (isCancel6(portInput)) return;
-  const newPort = parseInt(portInput, 10);
-  if (newPort !== config.server.port) {
-    config.server.port = newPort;
-    saveMCPConfig(config);
   }
   console.clear();
-  const logPath = getLogFilePath2();
-  const workspacePath = detectWorkspaceRoot();
-  const exposedNames = exposedProjects.map((p) => p.name).slice(0, 5);
-  const exposedLabel = exposedNames.length > 0 ? exposedNames.join(", ") + (exposedProjects.length > 5 ? ` (+${exposedProjects.length - 5} more)` : "") : pc7.dim("(none)");
-  const render = (logs = []) => {
-    console.clear();
-    console.log(pc7.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(pc7.cyan("\u2551") + pc7.bold(pc7.white("                    RRCE MCP Hub Running                      ")) + pc7.cyan("\u2551"));
-    console.log(pc7.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(pc7.cyan("\u2551") + " ".repeat(63) + pc7.cyan("\u2551"));
-    }
-    for (const line of logLines) {
-      const truncated = line.substring(0, 61).padEnd(61);
-      console.log(pc7.cyan("\u2551") + " " + pc7.dim(truncated) + " " + pc7.cyan("\u2551"));
-    }
-    console.log(pc7.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(pc7.cyan("\u2551") + pc7.yellow(infoLine) + " " + pc7.cyan("\u2551"));
-    console.log(pc7.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(pc7.cyan("\u2551") + pc7.dim(cmdLine.padEnd(63)) + pc7.cyan("\u2551"));
-    console.log(pc7.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"));
-  };
-  let logBuffer = [];
-  render(logBuffer);
-  try {
-    await startMCPServer();
-    let lastSize = 0;
-    if (fs16.existsSync(logPath)) {
-      const stats = fs16.statSync(logPath);
-      lastSize = stats.size;
-    }
-    let isRunning = true;
-    if (process.stdin.setRawMode) {
-      process.stdin.setRawMode(true);
-      process.stdin.resume();
-      process.stdin.setEncoding("utf8");
-    }
-    return new Promise((resolve) => {
-      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("");
-      };
-      const onKey = async (key) => {
-        if (key === "" || key.toLowerCase() === "q") {
-          cleanup();
-          resolve();
-          return;
-        }
-        if (key.toLowerCase() === "p") {
-          cleanup();
-          console.clear();
-          await handleConfigure();
-          resolve();
-          return;
-        }
-        if (key.toLowerCase() === "i") {
-          cleanup();
-          console.clear();
-          await handleInstallWizard(workspacePath);
-          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(() => {
-        if (!isRunning) return;
-        if (fs16.existsSync(logPath)) {
-          const stats = fs16.statSync(logPath);
-          if (stats.size > lastSize) {
-            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);
-    });
-  } catch (error) {
-    if (process.stdin.setRawMode) {
-      process.stdin.setRawMode(false);
+  let keepRunning = true;
+  while (keepRunning) {
+    let nextAction = "exit";
+    const app = render(React7.createElement(App2, {
+      initialPort,
+      onExit: () => {
+        nextAction = "exit";
+      },
+      onConfigure: () => {
+        nextAction = "configure";
+      },
+      onInstall: () => {
+        nextAction = "install";
+      }
+    }));
+    await app.waitUntilExit();
+    if (nextAction === "exit") {
+      keepRunning = false;
+    } else if (nextAction === "configure") {
+      console.clear();
+      await handleConfigure();
+    } else if (nextAction === "install") {
+      console.clear();
+      const workspacePath = detectWorkspaceRoot();
+      await handleInstallWizard(workspacePath);
     }
-    console.error(pc7.red("\nFailed to start server:"));
-    console.error(error);
   }
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs16 = await import("fs");
+  const fs17 = await import("fs");
   const path16 = await import("path");
-  note6(
-    `MCP Hub requires a ${pc7.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 ${pc7.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"
   );
@@ -1883,13 +2172,13 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs16.existsSync(resolvedPath)) {
-      fs16.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs17.existsSync(resolvedPath)) {
+      fs17.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
-    note6(
-      `${pc7.green("\u2713")} Global path configured: ${pc7.cyan(resolvedPath)}
+    note2(
+      `${pc3.green("\u2713")} Global path configured: ${pc3.cyan(resolvedPath)}
 
 MCP config will be stored at:
 ${path16.join(resolvedPath, "mcp.yaml")}`,
@@ -1897,15 +2186,15 @@ ${path16.join(resolvedPath, "mcp.yaml")}`,
     );
     return true;
   } catch (error) {
-    note6(
-      `${pc7.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 = spinner5();
+  const s = spinner();
   s.start("Loading projects...");
   const config = loadMCPConfig();
   const projects = scanForProjects();
@@ -1913,47 +2202,47 @@ async function handleShowStatus() {
   const installStatus = checkInstallStatus(workspacePath);
   s.stop("Projects loaded");
   if (projects.length === 0) {
-    note6('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 = [
-    `${pc7.bold("Installation Status")}`,
+    `${pc3.bold("Installation Status")}`,
     "",
-    `  Antigravity:      ${installStatus.antigravity ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
-    `  VSCode (Global):  ${installStatus.vscodeGlobal ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
-    `  VSCode (Workspace): ${installStatus.vscodeWorkspace ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
-    `  Claude Desktop:   ${installStatus.claude ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
+    `  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")}`,
     "",
-    `${pc7.bold("Project Status")}`,
+    `${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 ? pc7.green("\u2713 exposed") : pc7.dim("\u25CB hidden");
-    const source = pc7.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(pc7.dim(`Config: ${getMCPConfigPath()}`));
+  lines.push(pc3.dim(`Config: ${getMCPConfigPath()}`));
   const serverStatus = getMCPServerStatus();
   if (serverStatus.running) {
-    lines.push(pc7.green(`Server: running on port ${serverStatus.port}`));
+    lines.push(pc3.green(`Server: running on port ${serverStatus.port}`));
   } else {
-    lines.push(pc7.dim("Server: not running"));
+    lines.push(pc3.dim("Server: not running"));
   }
-  note6(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 = spinner5();
+  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) {
-    note6('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) => {
@@ -1961,7 +2250,7 @@ async function handleConfigure() {
     const isExposed = projectConfig?.expose ?? config.defaults.includeNew;
     return {
       value: project.name,
-      label: `${project.name} ${pc7.dim(`(${project.source})`)}`,
+      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
       hint: project.dataPath
     };
   });
@@ -1969,13 +2258,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 (isCancel6(selected)) {
+  if (isCancel2(selected)) {
     return;
   }
   const selectedNames = selected;
@@ -1987,8 +2276,8 @@ async function handleConfigure() {
   saveMCPConfig(config);
   logger2.info("Configure: Config saved", config);
   const exposedCount = selectedNames.length;
-  note6(
-    `${pc7.green("\u2713")} Configuration saved!
+  note2(
+    `${pc3.green("\u2713")} Configuration saved!
 
 Exposed projects: ${exposedCount}
 Hidden projects: ${projects.length - exposedCount}`,
@@ -1998,57 +2287,57 @@ Hidden projects: ${projects.length - exposedCount}`,
 async function handleStopServer() {
   const status = getMCPServerStatus();
   if (!status.running) {
-    note6("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 (isCancel6(confirmed) || !confirmed) {
+  if (isCancel2(confirmed) || !confirmed) {
     return;
   }
   stopMCPServer();
-  note6(pc7.green("MCP server stopped."), "Server Stopped");
+  note2(pc3.green("MCP server stopped."), "Server Stopped");
 }
 function showHelp() {
   const help = `
-${pc7.bold("RRCE MCP Hub")} - Cross-project AI assistant server
+${pc3.bold("RRCE MCP Hub")} - Cross-project AI assistant server
 
-${pc7.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.
 
-${pc7.bold("MENU OPTIONS")}
-  ${pc7.cyan("Start MCP server")}      Start the server for AI access
-  ${pc7.cyan("Configure projects")}    Choose which projects to expose
-  ${pc7.cyan("Install to IDE")}        Add to Antigravity, VSCode, or Claude
-  ${pc7.cyan("View status")}           See which projects are exposed
+${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
 
-${pc7.bold("DIRECT COMMANDS")}
-  ${pc7.dim("rrce-workflow mcp start")}    Start server directly
-  ${pc7.dim("rrce-workflow mcp stop")}     Stop server directly
-  ${pc7.dim("rrce-workflow mcp status")}   Show status directly
-  ${pc7.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
 
-${pc7.bold("IDE INSTALLATION")}
-  ${pc7.cyan("Antigravity")}    ~/.gemini/antigravity/mcp_config.json
-  ${pc7.cyan("VSCode Global")} ~/.config/Code/User/settings.json
-  ${pc7.cyan("VSCode Workspace")} .vscode/mcp.json
-  ${pc7.cyan("Claude Desktop")} ~/.config/claude/claude_desktop_config.json
+${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
 
-${pc7.bold("SERVER COMMANDS")} (while running)
-  ${pc7.cyan("q")} Stop and quit       ${pc7.cyan("p")} Reconfigure projects
-  ${pc7.cyan("i")} Install to IDE      ${pc7.cyan("r")} Reload config
-  ${pc7.cyan("c")} Clear logs          ${pc7.cyan("?")} Show help
+${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
 
-${pc7.bold("RESOURCES EXPOSED")}
-  ${pc7.cyan("rrce://projects")}              List all exposed projects
-  ${pc7.cyan("rrce://projects/{name}/context")}  Get project context
-  ${pc7.cyan("rrce://projects/{name}/tasks")}    Get project tasks
+${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
 `;
-  note6(help.trim(), "Help");
+  note2(help.trim(), "Help");
 }
 var init_mcp = __esm({
   "src/mcp/index.ts"() {
@@ -2061,154 +2350,16 @@ var init_mcp = __esm({
   }
 });
 
-// src/commands/wizard/index.ts
-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";
-
-// 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 fs12 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" },
@@ -2216,7 +2367,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" },
@@ -2228,44 +2379,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);
     }
   }
@@ -2289,7 +2440,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:`);
@@ -2302,17 +2453,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);
   }
 }
@@ -2320,14 +2480,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");
@@ -2339,8 +2499,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
 
@@ -2368,7 +2528,7 @@ linked_projects:
 `;
     });
   }
-  fs7.writeFileSync(workspaceConfigPath, configContent);
+  fs12.writeFileSync(workspaceConfigPath, configContent);
   if (config.addToGitignore) {
     updateGitignore(workspacePath, config.storageMode, config.tools);
   }
@@ -2380,8 +2540,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];
@@ -2392,7 +2552,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/");
@@ -2408,8 +2568,8 @@ function updateGitignore(workspacePath, storageMode, tools) {
   }
   try {
     let content = "";
-    if (fs7.existsSync(gitignorePath)) {
-      content = fs7.readFileSync(gitignorePath, "utf-8");
+    if (fs12.existsSync(gitignorePath)) {
+      content = fs12.readFileSync(gitignorePath, "utf-8");
     }
     const lines = content.split("\n").map((line) => line.trim());
     const newEntries = [];
@@ -2434,57 +2594,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);
+    fs12.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 fs13 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 = fs13.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -2511,60 +2680,67 @@ linked_projects:
 `;
     });
   }
-  fs8.writeFileSync(configFilePath, configContent);
+  fs13.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 fs14 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) => fs14.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);
     }
@@ -2573,28 +2749,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 fs15 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();
@@ -2603,7 +2784,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)
@@ -2612,20 +2793,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 = fs15.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -2644,17 +2825,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];
@@ -2664,9 +2845,23 @@ 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
-init_mcp();
+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 fs16 from "fs";
 async function runWizard() {
   intro2(pc8.cyan(pc8.inverse(" RRCE-Workflow Setup ")));
   const s = spinner6();
@@ -2686,18 +2881,18 @@ Workspace: ${pc8.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs15.existsSync(configFilePath);
+  const isAlreadyConfigured = fs16.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs15.readFileSync(configFilePath, "utf-8");
+      const configContent = fs16.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs15.existsSync(localDataPath);
+  const hasLocalData = fs16.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     menuOptions.push({
@@ -2748,6 +2943,22 @@ Workspace: ${pc8.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();
@@ -2767,9 +2978,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,
@@ -2786,6 +3002,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: