rrce-workflow 0.2.22 → 0.2.24

package/dist/index.js

@@ -1,24 +1,16 @@
-// src/commands/wizard/index.ts
-import { intro, select as select2, spinner as spinner5, note as note5, outro as outro5, isCancel as isCancel5 } from "@clack/prompts";
-import pc6 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;
-  }
-}
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/lib/paths.ts
 import * as fs from "fs";
 import * as path from "path";
-var RRCE_HOME = process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
-var RRCE_WORKSPACE = process.env.RRCE_WORKSPACE;
 function detectWorkspaceRoot() {
   if (RRCE_WORKSPACE) {
     return RRCE_WORKSPACE;
@@ -132,30 +124,18 @@ function getEffectiveRRCEHome(workspaceRoot) {
   }
   return getDefaultRRCEHome();
 }
+var RRCE_HOME, RRCE_WORKSPACE;
+var init_paths = __esm({
+  "src/lib/paths.ts"() {
+    "use strict";
+    RRCE_HOME = process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
+    RRCE_WORKSPACE = process.env.RRCE_WORKSPACE;
+  }
+});
 
 // src/lib/detection.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".cache",
-  ".npm",
-  ".yarn",
-  ".pnpm",
-  ".local",
-  ".config",
-  ".vscode",
-  ".vscode-server",
-  "Library",
-  "Applications",
-  ".Trash",
-  "snap",
-  ".cargo",
-  ".rustup",
-  ".go",
-  ".docker"
-]);
 function scanForProjects(options = {}) {
   const { excludeWorkspace, workspacePath } = options;
   const projects = [];
@@ -277,84 +257,1509 @@ function parseWorkspaceConfig(configPath) {
     return null;
   }
 }
+var SKIP_DIRECTORIES;
+var init_detection = __esm({
+  "src/lib/detection.ts"() {
+    "use strict";
+    init_paths();
+    SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".cache",
+      ".npm",
+      ".yarn",
+      ".pnpm",
+      ".local",
+      ".config",
+      ".vscode",
+      ".vscode-server",
+      "Library",
+      "Applications",
+      ".Trash",
+      "snap",
+      ".cargo",
+      ".rustup",
+      ".go",
+      ".docker"
+    ]);
+  }
+});
+
+// src/types/prompt.ts
+import { z } from "zod";
+var PromptArgSchema, AutoIdentitySchema, PromptFrontmatterSchema;
+var init_prompt = __esm({
+  "src/types/prompt.ts"() {
+    "use strict";
+    PromptArgSchema = z.object({
+      name: z.string(),
+      default: z.string().optional(),
+      prompt: z.string().optional()
+    });
+    AutoIdentitySchema = z.object({
+      user: z.string(),
+      model: z.string()
+    });
+    PromptFrontmatterSchema = z.object({
+      name: z.string(),
+      description: z.string(),
+      "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
+      tools: z.array(z.string()).optional(),
+      "required-args": z.array(PromptArgSchema).optional(),
+      "optional-args": z.array(PromptArgSchema).optional(),
+      "auto-identity": AutoIdentitySchema.optional()
+    });
+  }
+});
+
+// src/lib/prompts.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+function parsePromptFile(filePath) {
+  try {
+    const fileContent = fs3.readFileSync(filePath, "utf-8");
+    const { data, content } = matter(fileContent);
+    const parsed = PromptFrontmatterSchema.safeParse(data);
+    if (!parsed.success) {
+      console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
+      return null;
+    }
+    return {
+      frontmatter: parsed.data,
+      content: content.trim(),
+      filePath
+    };
+  } catch (error) {
+    console.error(`Error reading prompt file ${filePath}:`, error);
+    return null;
+  }
+}
+function loadPromptsFromDir(dirPath) {
+  if (!fs3.existsSync(dirPath)) {
+    return [];
+  }
+  const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
+  const prompts = [];
+  for (const file of files) {
+    const prompt = parsePromptFile(path3.join(dirPath, file));
+    if (prompt) {
+      prompts.push(prompt);
+    }
+  }
+  return prompts;
+}
+function getAgentCoreDir() {
+  return path3.join(__dirname, "..", "agent-core");
+}
+function getAgentCorePromptsDir() {
+  return path3.join(getAgentCoreDir(), "prompts");
+}
+var __filename, __dirname;
+var init_prompts = __esm({
+  "src/lib/prompts.ts"() {
+    "use strict";
+    init_prompt();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path3.dirname(__filename);
+  }
+});
+
+// src/lib/autocomplete-prompt.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as readline from "readline";
+import pc from "picocolors";
+function directoryPrompt(opts) {
+  return new Promise((resolve) => {
+    process.stdout.write(`${pc.cyan("\u25C6")}  ${opts.message}
+`);
+    process.stdout.write(`${pc.cyan("\u2502")}  `);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      completer: completeDirectory,
+      terminal: true
+    });
+    if (opts.defaultValue) {
+      rl.write(opts.defaultValue);
+    }
+    rl.on("line", (input) => {
+      const value = input.trim();
+      const expandedPath = value.startsWith("~") ? value.replace(/^~/, process.env.HOME || "") : value;
+      if (opts.validate) {
+        const error = opts.validate(expandedPath);
+        if (error) {
+          process.stdout.write(`${pc.yellow("\u2502")}  ${pc.yellow(error)}
+`);
+          process.stdout.write(`${pc.cyan("\u2502")}  `);
+          rl.write(value);
+          return;
+        }
+      }
+      rl.close();
+      process.stdout.write(`${pc.green("\u2713")}  ${pc.dim(expandedPath)}
+`);
+      resolve(expandedPath);
+    });
+    rl.on("close", () => {
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve(/* @__PURE__ */ Symbol("cancel"));
+    });
+  });
+}
+function completeDirectory(line) {
+  const expanded = line.startsWith("~") ? line.replace(/^~/, process.env.HOME || "") : line;
+  try {
+    let dirToScan;
+    let prefix;
+    let basePath;
+    if (expanded === "" || expanded === "/") {
+      dirToScan = expanded || "/";
+      prefix = "";
+      basePath = expanded;
+    } else if (expanded.endsWith("/")) {
+      dirToScan = expanded;
+      prefix = "";
+      basePath = expanded;
+    } else {
+      dirToScan = path6.dirname(expanded);
+      prefix = path6.basename(expanded).toLowerCase();
+      basePath = dirToScan === "/" ? "/" : dirToScan + "/";
+    }
+    if (!fs6.existsSync(dirToScan)) {
+      return [[], line];
+    }
+    const entries = fs6.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
+      if (!entry.isDirectory()) return false;
+      if (entry.name.startsWith(".") && !prefix.startsWith(".")) return false;
+      return prefix === "" || entry.name.toLowerCase().startsWith(prefix);
+    }).map((entry) => {
+      const fullPath = path6.join(dirToScan, entry.name);
+      const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
+      return displayPath + "/";
+    }).sort();
+    if (entries.length === 1) {
+      return [entries, line];
+    }
+    if (entries.length > 1) {
+      const commonPrefix = getCommonPrefix(entries);
+      if (commonPrefix.length > line.length) {
+        return [[commonPrefix], line];
+      }
+    }
+    return [entries, line];
+  } catch {
+    return [[], line];
+  }
+}
+function getCommonPrefix(strings) {
+  if (strings.length === 0) return "";
+  if (strings.length === 1) return strings[0] || "";
+  let prefix = strings[0] || "";
+  for (let i = 1; i < strings.length; i++) {
+    const str = strings[i] || "";
+    while (prefix.length > 0 && !str.startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+    }
+  }
+  return prefix;
+}
+function isCancelled(value) {
+  return typeof value === "symbol";
+}
+var init_autocomplete_prompt = __esm({
+  "src/lib/autocomplete-prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/tui-utils.ts
+var tui_utils_exports = {};
+__export(tui_utils_exports, {
+  resolveGlobalPath: () => resolveGlobalPath
+});
+import { select, note, isCancel } from "@clack/prompts";
+import pc2 from "picocolors";
+import * as path7 from "path";
+async function resolveGlobalPath() {
+  const defaultPath = getDefaultRRCEHome();
+  const isDefaultWritable = checkWriteAccess(defaultPath);
+  const options = [
+    {
+      value: "default",
+      label: `Default (${defaultPath})`,
+      hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
+    },
+    {
+      value: "custom",
+      label: "Custom path",
+      hint: "Specify your own directory"
+    }
+  ];
+  const choice = await select({
+    message: "Global storage location:",
+    options,
+    initialValue: isDefaultWritable ? "default" : "custom"
+  });
+  if (isCancel(choice)) {
+    return void 0;
+  }
+  if (choice === "default") {
+    if (!isDefaultWritable) {
+      note(
+        `${pc2.yellow("\u26A0")} Cannot write to default path:
+  ${pc2.dim(defaultPath)}
+
+This can happen when running via npx/bunx in restricted environments.
+Please choose a custom path instead.`,
+        "Write Access Issue"
+      );
+      return resolveGlobalPath();
+    }
+    return defaultPath;
+  }
+  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const customPath = await directoryPrompt({
+    message: "Enter custom global path (Tab to autocomplete):",
+    defaultValue: suggestedPath,
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Path cannot be empty";
+      }
+      if (!checkWriteAccess(value)) {
+        return `Cannot write to ${value}. Please choose a writable path.`;
+      }
+      return void 0;
+    }
+  });
+  if (isCancelled(customPath)) {
+    return void 0;
+  }
+  let expandedPath = customPath;
+  if (!expandedPath.endsWith(".rrce-workflow")) {
+    expandedPath = path7.join(expandedPath, ".rrce-workflow");
+  }
+  return expandedPath;
+}
+var init_tui_utils = __esm({
+  "src/lib/tui-utils.ts"() {
+    "use strict";
+    init_paths();
+    init_autocomplete_prompt();
+  }
+});
+
+// src/mcp/types.ts
+var DEFAULT_MCP_CONFIG, DEFAULT_PERMISSIONS;
+var init_types = __esm({
+  "src/mcp/types.ts"() {
+    "use strict";
+    DEFAULT_MCP_CONFIG = {
+      server: {
+        port: 3e3,
+        autoStart: false
+      },
+      projects: [],
+      defaults: {
+        includeNew: true,
+        permissions: {
+          knowledge: true,
+          tasks: true,
+          refs: true
+        }
+      }
+    };
+    DEFAULT_PERMISSIONS = {
+      knowledge: true,
+      tasks: true,
+      refs: true
+    };
+  }
+});
+
+// src/mcp/config.ts
+import * as fs12 from "fs";
+import * as path11 from "path";
+function getMCPConfigPath() {
+  const workspaceRoot = detectWorkspaceRoot();
+  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
+  return path11.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 modeMatch = content.match(/mode:\s*(global|workspace)/);
+      if (modeMatch?.[1] === "workspace") {
+        return {
+          configured: false,
+          path: rrceHome,
+          reason: "Workspace mode configured. MCP requires a global storage path."
+        };
+      }
+    }
+  }
+  return {
+    configured: true,
+    path: rrceHome
+  };
+}
+function loadMCPConfig() {
+  const configPath = getMCPConfigPath();
+  if (!fs12.existsSync(configPath)) {
+    return { ...DEFAULT_MCP_CONFIG };
+  }
+  try {
+    const content = fs12.readFileSync(configPath, "utf-8");
+    return parseMCPConfig(content);
+  } catch {
+    return { ...DEFAULT_MCP_CONFIG };
+  }
+}
+function saveMCPConfig(config) {
+  const configPath = getMCPConfigPath();
+  const dir = path11.dirname(configPath);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
+  }
+  const content = serializeMCPConfig(config);
+  fs12.writeFileSync(configPath, content);
+}
+function parseMCPConfig(content) {
+  const config = { ...DEFAULT_MCP_CONFIG, projects: [] };
+  const lines = content.split("\n");
+  let currentSection = null;
+  let currentProject = null;
+  let inPermissions = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "") continue;
+    if (line.match(/^server:/)) {
+      currentSection = "server";
+      currentProject = null;
+      inPermissions = false;
+      continue;
+    }
+    if (line.match(/^defaults:/)) {
+      currentSection = "defaults";
+      currentProject = null;
+      inPermissions = false;
+      continue;
+    }
+    if (line.match(/^projects:/)) {
+      currentSection = "projects";
+      currentProject = null;
+      inPermissions = false;
+      continue;
+    }
+    if (currentSection === "server") {
+      const portMatch = trimmed.match(/^port:\s*(\d+)/);
+      if (portMatch?.[1]) config.server.port = parseInt(portMatch[1], 10);
+      const autoStartMatch = trimmed.match(/^autoStart:\s*(true|false)/);
+      if (autoStartMatch) config.server.autoStart = autoStartMatch[1] === "true";
+    }
+    if (currentSection === "defaults") {
+      const includeNewMatch = trimmed.match(/^includeNew:\s*(true|false)/);
+      if (includeNewMatch) config.defaults.includeNew = includeNewMatch[1] === "true";
+      if (trimmed === "permissions:") {
+        inPermissions = true;
+        continue;
+      }
+      if (inPermissions) {
+        const knowledgeMatch = trimmed.match(/^knowledge:\s*(true|false)/);
+        if (knowledgeMatch) config.defaults.permissions.knowledge = knowledgeMatch[1] === "true";
+        const tasksMatch = trimmed.match(/^tasks:\s*(true|false)/);
+        if (tasksMatch) config.defaults.permissions.tasks = tasksMatch[1] === "true";
+        const refsMatch = trimmed.match(/^refs:\s*(true|false)/);
+        if (refsMatch) config.defaults.permissions.refs = refsMatch[1] === "true";
+      }
+    }
+    if (currentSection === "projects") {
+      const projectNameMatch = line.match(/^\s+-\s+name:\s*["']?([^"'\n]+)["']?/);
+      if (projectNameMatch) {
+        if (currentProject && currentProject.name) {
+          config.projects.push(currentProject);
+        }
+        currentProject = {
+          name: projectNameMatch[1].trim(),
+          expose: true,
+          permissions: { ...DEFAULT_PERMISSIONS }
+        };
+        inPermissions = false;
+        continue;
+      }
+      if (currentProject) {
+        const exposeMatch = trimmed.match(/^expose:\s*(true|false)/);
+        if (exposeMatch) {
+          currentProject.expose = exposeMatch[1] === "true";
+        }
+        if (trimmed === "permissions:") {
+          inPermissions = true;
+          continue;
+        }
+        if (inPermissions) {
+          const knowledgeMatch = trimmed.match(/^knowledge:\s*(true|false)/);
+          if (knowledgeMatch) currentProject.permissions.knowledge = knowledgeMatch[1] === "true";
+          const tasksMatch = trimmed.match(/^tasks:\s*(true|false)/);
+          if (tasksMatch) currentProject.permissions.tasks = tasksMatch[1] === "true";
+          const refsMatch = trimmed.match(/^refs:\s*(true|false)/);
+          if (refsMatch) currentProject.permissions.refs = refsMatch[1] === "true";
+        }
+      }
+    }
+  }
+  if (currentProject && currentProject.name) {
+    config.projects.push(currentProject);
+  }
+  return config;
+}
+function serializeMCPConfig(config) {
+  let content = `# RRCE MCP Hub Configuration
+# Manages which projects are exposed via MCP
+
+server:
+  port: ${config.server.port}
+  autoStart: ${config.server.autoStart}
+
+defaults:
+  includeNew: ${config.defaults.includeNew}
+  permissions:
+    knowledge: ${config.defaults.permissions.knowledge}
+    tasks: ${config.defaults.permissions.tasks}
+    refs: ${config.defaults.permissions.refs}
+
+projects:
+`;
+  if (config.projects.length === 0) {
+    content += '  # No projects configured yet. Run "rrce-workflow mcp" to add projects.\n';
+  } else {
+    for (const project of config.projects) {
+      content += `  - name: "${project.name}"
+    expose: ${project.expose}
+    permissions:
+      knowledge: ${project.permissions.knowledge}
+      tasks: ${project.permissions.tasks}
+      refs: ${project.permissions.refs}
+`;
+    }
+  }
+  return content;
+}
+function setProjectConfig(config, name, expose, permissions) {
+  const existing = config.projects.find((p) => p.name === name);
+  if (existing) {
+    existing.expose = expose;
+    if (permissions) {
+      existing.permissions = { ...existing.permissions, ...permissions };
+    }
+  } else {
+    config.projects.push({
+      name,
+      expose,
+      permissions: permissions ? { ...DEFAULT_PERMISSIONS, ...permissions } : { ...DEFAULT_PERMISSIONS }
+    });
+  }
+  return config;
+}
+function isProjectExposed(config, name) {
+  const project = config.projects.find((p) => p.name === name);
+  if (project) {
+    return project.expose;
+  }
+  return config.defaults.includeNew;
+}
+function getProjectPermissions(config, name) {
+  const project = config.projects.find((p) => p.name === name);
+  return project?.permissions ?? config.defaults.permissions;
+}
+var init_config = __esm({
+  "src/mcp/config.ts"() {
+    "use strict";
+    init_paths();
+    init_types();
+  }
+});
+
+// src/mcp/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  getLogFilePath: () => getLogFilePath,
+  logger: () => logger
+});
+import * as fs13 from "fs";
+import * as path12 from "path";
+function getLogFilePath() {
+  const workspaceRoot = detectWorkspaceRoot();
+  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
+  return path12.join(rrceHome, "mcp-server.log");
+}
+var Logger, logger;
+var init_logger = __esm({
+  "src/mcp/logger.ts"() {
+    "use strict";
+    init_paths();
+    Logger = class {
+      logPath;
+      constructor() {
+        this.logPath = getLogFilePath();
+      }
+      write(level, message, data) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        let logMessage = `[${timestamp}] [${level}] ${message}`;
+        if (data) {
+          if (data instanceof Error) {
+            logMessage += `
+${data.stack || data.message}`;
+          } else {
+            try {
+              logMessage += `
+${JSON.stringify(data, null, 2)}`;
+            } catch (e) {
+              logMessage += `
+[Circular or invalid data]`;
+            }
+          }
+        }
+        logMessage += "\n";
+        try {
+          const dir = path12.dirname(this.logPath);
+          if (!fs13.existsSync(dir)) {
+            fs13.mkdirSync(dir, { recursive: true });
+          }
+          fs13.appendFileSync(this.logPath, logMessage);
+        } catch (e) {
+          console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
+          console.error(logMessage);
+        }
+      }
+      info(message, data) {
+        this.write("INFO", message, data);
+      }
+      error(message, error) {
+        this.write("ERROR", message, error);
+      }
+      warn(message, data) {
+        this.write("WARN", message, data);
+      }
+      debug(message, data) {
+        this.write("DEBUG", message, data);
+      }
+    };
+    logger = new Logger();
+  }
+});
+
+// src/mcp/resources.ts
+import * as fs14 from "fs";
+import * as path13 from "path";
+function getExposedProjects() {
+  const config = loadMCPConfig();
+  const allProjects = scanForProjects();
+  return allProjects.filter((project) => isProjectExposed(config, project.name));
+}
+function getProjectContext(projectName) {
+  const config = loadMCPConfig();
+  if (!isProjectExposed(config, projectName)) {
+    return null;
+  }
+  const permissions = getProjectPermissions(config, projectName);
+  if (!permissions.knowledge) {
+    return null;
+  }
+  const projects = scanForProjects();
+  const project = projects.find((p) => p.name === projectName);
+  if (!project?.knowledgePath) {
+    return null;
+  }
+  const contextPath = path13.join(project.knowledgePath, "project-context.md");
+  if (!fs14.existsSync(contextPath)) {
+    return null;
+  }
+  return fs14.readFileSync(contextPath, "utf-8");
+}
+function getProjectTasks(projectName) {
+  const config = loadMCPConfig();
+  if (!isProjectExposed(config, projectName)) {
+    return [];
+  }
+  const permissions = getProjectPermissions(config, projectName);
+  if (!permissions.tasks) {
+    return [];
+  }
+  const projects = scanForProjects();
+  const project = projects.find((p) => p.name === projectName);
+  if (!project?.tasksPath || !fs14.existsSync(project.tasksPath)) {
+    return [];
+  }
+  const tasks = [];
+  try {
+    const taskDirs = fs14.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)) {
+        try {
+          const meta = JSON.parse(fs14.readFileSync(metaPath, "utf-8"));
+          tasks.push(meta);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return tasks;
+}
+function searchKnowledge(query) {
+  const config = loadMCPConfig();
+  const projects = getExposedProjects();
+  const results = [];
+  const queryLower = query.toLowerCase();
+  for (const project of projects) {
+    const permissions = getProjectPermissions(config, project.name);
+    if (!permissions.knowledge || !project.knowledgePath) continue;
+    try {
+      const files = fs14.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 lines = content.split("\n");
+        const matches = [];
+        for (const line of lines) {
+          if (line.toLowerCase().includes(queryLower)) {
+            matches.push(line.trim());
+          }
+        }
+        if (matches.length > 0) {
+          results.push({
+            project: project.name,
+            file,
+            matches: matches.slice(0, 5)
+            // Limit to 5 matches per file
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+var init_resources = __esm({
+  "src/mcp/resources.ts"() {
+    "use strict";
+    init_config();
+    init_detection();
+  }
+});
+
+// src/mcp/prompts.ts
+var AGENT_PROMPTS;
+var init_prompts2 = __esm({
+  "src/mcp/prompts.ts"() {
+    "use strict";
+    AGENT_PROMPTS = [
+      {
+        name: "init",
+        description: "Initialize project context by analyzing codebase structure, tech stack, and conventions",
+        file: "init.md",
+        arguments: [
+          { name: "PROJECT_NAME", description: "Project name (optional, auto-detected if omitted)", required: false }
+        ]
+      },
+      {
+        name: "research",
+        description: "Research and clarify requirements for a new task",
+        file: "research_discussion.md",
+        arguments: [
+          { name: "REQUEST", description: "Description of the task or feature to research", required: true },
+          { name: "TASK_SLUG", description: "Kebab-case identifier for the task", required: true },
+          { name: "TITLE", description: "Human-readable title for the task", required: false }
+        ]
+      },
+      {
+        name: "plan",
+        description: "Create an actionable execution plan from research findings",
+        file: "planning_orchestrator.md",
+        arguments: [
+          { name: "TASK_SLUG", description: "Task slug to create plan for", required: true }
+        ]
+      },
+      {
+        name: "execute",
+        description: "Implement the planned work with code and tests",
+        file: "executor.md",
+        arguments: [
+          { name: "TASK_SLUG", description: "Task slug to execute", required: true },
+          { name: "BRANCH", description: "Git branch reference (optional)", required: false }
+        ]
+      },
+      {
+        name: "docs",
+        description: "Generate documentation for completed work",
+        file: "documentation.md",
+        arguments: [
+          { name: "DOC_TYPE", description: "Type of documentation (api, architecture, runbook, changelog)", required: true },
+          { name: "TASK_SLUG", description: "Task slug if documenting specific task", required: false }
+        ]
+      },
+      {
+        name: "sync",
+        description: "Reconcile knowledge base with actual codebase state",
+        file: "sync.md",
+        arguments: [
+          { name: "SCOPE", description: "Specific path or module to sync (optional)", required: false }
+        ]
+      }
+    ];
+  }
+});
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs15 from "fs";
+import * as path14 from "path";
+async function startMCPServer() {
+  try {
+    logger.info("Starting MCP Server...");
+    process.on("uncaughtException", (error) => {
+      logger.error("Uncaught Exception", error);
+      console.error("Uncaught Exception:", error);
+    });
+    process.on("unhandledRejection", (reason) => {
+      logger.error("Unhandled Rejection", reason);
+      console.error("Unhandled Rejection:", reason);
+    });
+    const config = loadMCPConfig();
+    mcpServer = new Server(
+      { name: "rrce-mcp-hub", version: "1.0.0" },
+      { capabilities: { resources: {}, tools: {}, prompts: {} } }
+    );
+    mcpServer.onerror = (error) => {
+      logger.error("MCP Server Error", error);
+    };
+    registerResourceHandlers(mcpServer);
+    registerToolHandlers(mcpServer);
+    registerPromptHandlers(mcpServer);
+    const transport = new StdioServerTransport();
+    await mcpServer.connect(transport);
+    serverState = { running: true, port: config.server.port, pid: process.pid };
+    const exposed = getExposedProjects().map((p) => p.name).join(", ");
+    logger.info(`RRCE MCP Hub started (pid: ${process.pid})`, { exposedProjects: exposed });
+    console.error(`RRCE MCP Hub started (pid: ${process.pid})`);
+    console.error(`Exposed projects: ${exposed}`);
+    return { port: config.server.port, pid: process.pid };
+  } catch (error) {
+    logger.error("Failed to start MCP server", error);
+    throw error;
+  }
+}
+function registerResourceHandlers(server) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    logger.debug("Listing resources");
+    const projects = getExposedProjects();
+    const resources = [];
+    resources.push({
+      uri: "rrce://projects",
+      name: "Project List",
+      description: "List of all RRCE projects exposed via MCP",
+      mimeType: "application/json"
+    });
+    for (const project of projects) {
+      const config = loadMCPConfig();
+      const permissions = getProjectPermissions(config, project.name);
+      if (permissions.knowledge) {
+        resources.push({
+          uri: `rrce://projects/${project.name}/context`,
+          name: `${project.name} - Project Context`,
+          description: `Project context and architecture for ${project.name}`,
+          mimeType: "text/markdown"
+        });
+      }
+      if (permissions.tasks) {
+        resources.push({
+          uri: `rrce://projects/${project.name}/tasks`,
+          name: `${project.name} - Tasks`,
+          description: `Task list and status for ${project.name}`,
+          mimeType: "application/json"
+        });
+      }
+    }
+    return { resources };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    logger.info(`Reading resource: ${uri}`);
+    try {
+      if (uri === "rrce://projects") {
+        const projects = getExposedProjects();
+        return {
+          contents: [{
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(projects.map((p) => ({ name: p.name, source: p.source, path: p.path })), null, 2)
+          }]
+        };
+      }
+      const projectMatch = uri.match(/^rrce:\/\/projects\/([^/]+)\/(.+)$/);
+      if (projectMatch) {
+        const [, projectName, resourceType] = projectMatch;
+        const content = resourceType === "context" ? getProjectContext(projectName) : JSON.stringify(getProjectTasks(projectName), null, 2);
+        if (content === null) throw new Error(`Resource not found: ${uri}`);
+        return {
+          contents: [{
+            uri,
+            mimeType: resourceType === "tasks" ? "application/json" : "text/markdown",
+            text: content
+          }]
+        };
+      }
+      throw new Error(`Unknown resource: ${uri}`);
+    } catch (error) {
+      logger.error(`Failed to read resource: ${uri}`, error);
+      throw error;
+    }
+  });
+}
+function registerToolHandlers(server) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "search_knowledge",
+        description: "Search across all exposed project knowledge bases",
+        inputSchema: {
+          type: "object",
+          properties: { query: { type: "string", description: "Search query to find in knowledge files" } },
+          required: ["query"]
+        }
+      },
+      {
+        name: "list_projects",
+        description: "List all projects exposed via MCP",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_project_context",
+        description: "Get the project context/architecture for a specific project",
+        inputSchema: {
+          type: "object",
+          properties: { project: { type: "string", description: "Name of the project to get context for" } },
+          required: ["project"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info(`Calling tool: ${name}`, args);
+    try {
+      switch (name) {
+        case "search_knowledge": {
+          const results = searchKnowledge(args.query);
+          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        case "list_projects": {
+          const projects = getExposedProjects();
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(projects.map((p) => ({ name: p.name, source: p.source, path: p.path })), null, 2)
+            }]
+          };
+        }
+        case "get_project_context": {
+          const context = getProjectContext(args.project);
+          if (!context) {
+            const msg = `No project context found for "${args.project}"`;
+            logger.warn(msg);
+            return { content: [{ type: "text", text: msg }], isError: true };
+          }
+          return { content: [{ type: "text", text: context }] };
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      logger.error(`Tool execution failed: ${name}`, error);
+      throw error;
+    }
+  });
+}
+function registerPromptHandlers(server) {
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: AGENT_PROMPTS.map((p) => ({
+      name: p.name,
+      description: p.description,
+      arguments: p.arguments.map((a) => ({ name: a.name, description: a.description, required: a.required }))
+    }))
+  }));
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info(`Getting prompt: ${name}`, args);
+    try {
+      const promptDef = AGENT_PROMPTS.find((p) => p.name === name);
+      if (!promptDef) throw new Error(`Unknown prompt: ${name}`);
+      const promptsDir = getAgentCorePromptsDir();
+      const promptPath = path14.join(promptsDir, promptDef.file);
+      if (!fs15.existsSync(promptPath)) throw new Error(`Prompt file not found: ${promptDef.file}`);
+      let promptContent = fs15.readFileSync(promptPath, "utf-8");
+      if (args) {
+        for (const [key, value] of Object.entries(args)) {
+          promptContent = promptContent.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), String(value));
+        }
+      }
+      return {
+        description: promptDef.description,
+        messages: [{ role: "user", content: { type: "text", text: promptContent } }]
+      };
+    } catch (error) {
+      logger.error(`Failed to get prompt: ${name}`, error);
+      throw error;
+    }
+  });
+}
+function stopMCPServer() {
+  if (mcpServer) {
+    logger.info("Stopping MCP Server...");
+    mcpServer.close();
+    mcpServer = null;
+  }
+  serverState = { running: false };
+  logger.info("RRCE MCP Hub stopped");
+  console.error("RRCE MCP Hub stopped");
+}
+function getMCPServerStatus() {
+  return { ...serverState };
+}
+var serverState, mcpServer;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    init_resources();
+    init_prompts2();
+    init_prompts();
+    serverState = { running: false };
+    mcpServer = null;
+  }
+});
+
+// src/mcp/install.ts
+import * as fs16 from "fs";
+import * as path15 from "path";
+import * as os from "os";
+function checkInstallStatus() {
+  return {
+    antigravity: checkConfigFile(ANTIGRAVITY_CONFIG),
+    claude: checkConfigFile(CLAUDE_CONFIG)
+  };
+}
+function checkConfigFile(configPath) {
+  if (!fs16.existsSync(configPath)) return false;
+  try {
+    const content = JSON.parse(fs16.readFileSync(configPath, "utf-8"));
+    return !!content.mcpServers?.["rrce"];
+  } catch {
+    return false;
+  }
+}
+function installToConfig(target) {
+  const configPath = target === "antigravity" ? ANTIGRAVITY_CONFIG : CLAUDE_CONFIG;
+  const dir = path15.dirname(configPath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
+  }
+  let config = { mcpServers: {} };
+  if (fs16.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs16.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+    // -y to avoid interactive prompts
+  };
+  try {
+    fs16.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG;
+var init_install = __esm({
+  "src/mcp/install.ts"() {
+    "use strict";
+    ANTIGRAVITY_CONFIG = path15.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path15.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+  }
+});
+
+// src/mcp/index.ts
+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";
+async function runMCP(subcommand2) {
+  if (subcommand2) {
+    switch (subcommand2) {
+      case "start":
+        await startMCPServer();
+        await new Promise(() => {
+        });
+        return;
+      case "stop":
+        await handleStopServer();
+        return;
+      case "status":
+        await handleShowStatus();
+        return;
+      case "help":
+        showHelp();
+        return;
+    }
+  }
+  intro2(pc8.bgCyan(pc8.black(" RRCE MCP Hub ")));
+  const globalPathCheck = await ensureMCPGlobalPath();
+  if (!globalPathCheck.configured) {
+    const configured = await handleConfigureGlobalPath();
+    if (!configured) {
+      outro6(pc8.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?",
+      initialValue: true
+    });
+    if (shouldInstall && !isCancel7(shouldInstall)) {
+      await handleInstallWizard();
+    }
+  }
+  let running = true;
+  while (running) {
+    const serverStatus = getMCPServerStatus();
+    const serverLabel = serverStatus.running ? pc8.green("Running") : pc8.dim("Stopped");
+    const action = await select4({
+      message: "What would you like to do?",
+      options: [
+        { value: "start", label: `\u25B6\uFE0F  Start MCP server`, hint: `Current status: ${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: "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.");
+      return;
+    }
+    switch (action) {
+      case "start":
+        await handleStartServer();
+        break;
+      case "configure":
+        await handleConfigure();
+        break;
+      case "install":
+        await handleInstallWizard();
+        break;
+      case "status":
+        await handleShowStatus();
+        break;
+      case "help":
+        showHelp();
+        break;
+      case "exit":
+        running = false;
+        break;
+    }
+  }
+  outro6(pc8.green("MCP Hub closed."));
+}
+async function handleInstallWizard() {
+  const status = checkInstallStatus();
+  const options = [
+    { value: "antigravity", label: "Antigravity IDE", hint: status.antigravity ? "Installed" : "Not installed" },
+    { value: "claude", label: "Claude Desktop", hint: status.claude ? "Installed" : "Not installed" }
+  ];
+  const selected = await multiselect3({
+    message: "Select where to install RRCE MCP Server:",
+    options,
+    initialValues: [
+      ...status.antigravity ? ["antigravity"] : [],
+      ...status.claude ? ["claude"] : []
+    ],
+    required: false
+  });
+  if (isCancel7(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")}`);
+  }
+  if (results.length > 0) {
+    note7(results.join("\n"), "Installation Results");
+  }
+}
+async function handleStartServer() {
+  const fs17 = 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({
+      message: "No projects are currently exposed. Configure now?",
+      initialValue: true
+    });
+    if (shouldConfig && !isCancel7(shouldConfig)) {
+      await handleConfigure();
+    }
+  }
+  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";
+    }
+  });
+  if (isCancel7(portInput)) return;
+  const newPort = parseInt(portInput, 10);
+  if (newPort !== config.server.port) {
+    config.server.port = newPort;
+    saveMCPConfig(config);
+  }
+  console.clear();
+  const logPath = getLogFilePath2();
+  const renderHeader = () => {
+    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`);
+  };
+  renderHeader();
+  renderFooter();
+  try {
+    await startMCPServer();
+    let lastSize = 0;
+    if (fs17.existsSync(logPath)) {
+      const stats = fs17.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 onKey = async (key) => {
+        if (key === "" || key.toLowerCase() === "q") {
+          cleanup();
+          resolve();
+        }
+        if (key.toLowerCase() === "p" || key.toLowerCase() === "g") {
+          cleanup();
+          resolve();
+        }
+      };
+      process.stdin.on("data", onKey);
+      const interval = setInterval(() => {
+        if (!isRunning) return;
+        if (fs17.existsSync(logPath)) {
+          const stats = fs17.statSync(logPath);
+          if (stats.size > lastSize) {
+            const stream = fs17.createReadStream(logPath, {
+              start: lastSize,
+              end: stats.size,
+              encoding: "utf-8"
+            });
+            stream.on("data", (chunk) => {
+              process.stderr.write(chunk);
+            });
+            lastSize = stats.size;
+          }
+        }
+      }, 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(error);
+  }
+}
+async function handleConfigureGlobalPath() {
+  const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
+  const fs17 = await import("fs");
+  const path17 = await import("path");
+  note7(
+    `MCP Hub requires a ${pc8.bold("global storage path")} to store its configuration
+and coordinate across projects.
+
+Your current setup uses ${pc8.cyan("workspace")} mode, which stores data
+locally in each project. MCP needs a central location.`,
+    "Global Path Required"
+  );
+  const resolvedPath = await resolveGlobalPath2();
+  if (!resolvedPath) {
+    return false;
+  }
+  try {
+    if (!fs17.existsSync(resolvedPath)) {
+      fs17.mkdirSync(resolvedPath, { recursive: true });
+    }
+    const config = loadMCPConfig();
+    saveMCPConfig(config);
+    note7(
+      `${pc8.green("\u2713")} Global path configured: ${pc8.cyan(resolvedPath)}
+
+MCP config will be stored at:
+${path17.join(resolvedPath, "mcp.yaml")}`,
+      "Configuration Saved"
+    );
+    return true;
+  } catch (error) {
+    note7(
+      `${pc8.red("\u2717")} Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
+      "Error"
+    );
+    return false;
+  }
+}
+async function handleShowStatus() {
+  const s = spinner6();
+  s.start("Loading projects...");
+  const config = loadMCPConfig();
+  const projects = scanForProjects();
+  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");
+    return;
+  }
+  const lines = [
+    `${pc8.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})`);
+    lines.push(`  ${status}  ${project.name} ${source}`);
+  }
+  lines.push("");
+  lines.push(pc8.dim(`Config: ${getMCPConfigPath()}`));
+  const serverStatus = getMCPServerStatus();
+  if (serverStatus.running) {
+    lines.push(pc8.green(`Server: running on port ${serverStatus.port}`));
+  } else {
+    lines.push(pc8.dim("Server: not running"));
+  }
+  note7(lines.join("\n"), "MCP Hub Status");
+}
+async function handleConfigure() {
+  const { logger: logger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+  const s = spinner6();
+  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");
+    return;
+  }
+  const options = projects.map((project) => {
+    const projectConfig = config.projects.find((p) => p.name === project.name);
+    const isExposed = projectConfig?.expose ?? config.defaults.includeNew;
+    return {
+      value: project.name,
+      label: `${project.name} ${pc8.dim(`(${project.source})`)}`,
+      hint: project.dataPath
+    };
+  });
+  const currentlyExposed = projects.filter((p) => {
+    const cfg = config.projects.find((c) => c.name === p.name);
+    return cfg?.expose ?? config.defaults.includeNew;
+  }).map((p) => p.name);
+  const selected = await multiselect3({
+    message: "Select projects to expose via MCP:",
+    options,
+    initialValues: currentlyExposed,
+    required: false
+  });
+  if (isCancel7(selected)) {
+    return;
+  }
+  const selectedNames = selected;
+  logger2.info("Configure: User selected projects", selectedNames);
+  for (const project of projects) {
+    const shouldExpose = selectedNames.includes(project.name);
+    setProjectConfig(config, project.name, shouldExpose);
+  }
+  saveMCPConfig(config);
+  logger2.info("Configure: Config saved", config);
+  const exposedCount = selectedNames.length;
+  note7(
+    `${pc8.green("\u2713")} Configuration saved!
+
+Exposed projects: ${exposedCount}
+Hidden projects: ${projects.length - exposedCount}`,
+    "Configuration Updated"
+  );
+}
+async function handleStopServer() {
+  const status = getMCPServerStatus();
+  if (!status.running) {
+    note7("MCP server is not running.", "Status");
+    return;
+  }
+  const confirmed = await confirm4({
+    message: "Stop the MCP server?",
+    initialValue: true
+  });
+  if (isCancel7(confirmed) || !confirmed) {
+    return;
+  }
+  stopMCPServer();
+  note7(pc8.green("MCP server stopped."), "Server Stopped");
+}
+function showHelp() {
+  const help = `
+${pc8.bold("RRCE MCP Hub")} - Cross-project AI assistant server
 
-// src/commands/wizard/setup-flow.ts
-import { group, select, multiselect, confirm, spinner, note, outro, cancel, isCancel } from "@clack/prompts";
-import pc2 from "picocolors";
-import * as fs7 from "fs";
-import * as path7 from "path";
+${pc8.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.
 
-// src/lib/prompts.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
+${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
 
-// src/types/prompt.ts
-import { z } from "zod";
-var PromptArgSchema = z.object({
-  name: z.string(),
-  default: z.string().optional(),
-  prompt: z.string().optional()
-});
-var AutoIdentitySchema = z.object({
-  user: z.string(),
-  model: z.string()
-});
-var PromptFrontmatterSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
-  tools: z.array(z.string()).optional(),
-  "required-args": z.array(PromptArgSchema).optional(),
-  "optional-args": z.array(PromptArgSchema).optional(),
-  "auto-identity": AutoIdentitySchema.optional()
-});
+${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
 
-// src/lib/prompts.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
-function parsePromptFile(filePath) {
-  try {
-    const fileContent = fs3.readFileSync(filePath, "utf-8");
-    const { data, content } = matter(fileContent);
-    const parsed = PromptFrontmatterSchema.safeParse(data);
-    if (!parsed.success) {
-      console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
-      return null;
+${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"]
     }
-    return {
-      frontmatter: parsed.data,
-      content: content.trim(),
-      filePath
-    };
-  } catch (error) {
-    console.error(`Error reading prompt file ${filePath}:`, error);
-    return null;
   }
+}`)}
+
+${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
+
+${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
+`;
+  note7(help.trim(), "Help");
 }
-function loadPromptsFromDir(dirPath) {
-  if (!fs3.existsSync(dirPath)) {
-    return [];
+var init_mcp = __esm({
+  "src/mcp/index.ts"() {
+    "use strict";
+    init_config();
+    init_detection();
+    init_server();
+    init_install();
   }
-  const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
-  const prompts = [];
-  for (const file of files) {
-    const prompt = parsePromptFile(path3.join(dirPath, file));
-    if (prompt) {
-      prompts.push(prompt);
-    }
+});
+
+// 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;
   }
-  return prompts;
-}
-function getAgentCoreDir() {
-  return path3.join(__dirname, "..", "agent-core");
-}
-function getAgentCorePromptsDir() {
-  return path3.join(getAgentCoreDir(), "prompts");
 }
 
+// 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) {
@@ -381,6 +1786,8 @@ function copyDirRecursive(src, dest) {
 }
 
 // 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) {
@@ -463,119 +1870,14 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
   fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
 
-// src/lib/autocomplete-prompt.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
-import * as readline from "readline";
-import pc from "picocolors";
-function directoryPrompt(opts) {
-  return new Promise((resolve) => {
-    process.stdout.write(`${pc.cyan("\u25C6")}  ${opts.message}
-`);
-    process.stdout.write(`${pc.cyan("\u2502")}  `);
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      completer: completeDirectory,
-      terminal: true
-    });
-    if (opts.defaultValue) {
-      rl.write(opts.defaultValue);
-    }
-    rl.on("line", (input) => {
-      const value = input.trim();
-      const expandedPath = value.startsWith("~") ? value.replace(/^~/, process.env.HOME || "") : value;
-      if (opts.validate) {
-        const error = opts.validate(expandedPath);
-        if (error) {
-          process.stdout.write(`${pc.yellow("\u2502")}  ${pc.yellow(error)}
-`);
-          process.stdout.write(`${pc.cyan("\u2502")}  `);
-          rl.write(value);
-          return;
-        }
-      }
-      rl.close();
-      process.stdout.write(`${pc.green("\u2713")}  ${pc.dim(expandedPath)}
-`);
-      resolve(expandedPath);
-    });
-    rl.on("close", () => {
-    });
-    rl.on("SIGINT", () => {
-      rl.close();
-      process.stdout.write("\n");
-      resolve(/* @__PURE__ */ Symbol("cancel"));
-    });
-  });
-}
-function completeDirectory(line) {
-  const expanded = line.startsWith("~") ? line.replace(/^~/, process.env.HOME || "") : line;
-  try {
-    let dirToScan;
-    let prefix;
-    let basePath;
-    if (expanded === "" || expanded === "/") {
-      dirToScan = expanded || "/";
-      prefix = "";
-      basePath = expanded;
-    } else if (expanded.endsWith("/")) {
-      dirToScan = expanded;
-      prefix = "";
-      basePath = expanded;
-    } else {
-      dirToScan = path6.dirname(expanded);
-      prefix = path6.basename(expanded).toLowerCase();
-      basePath = dirToScan === "/" ? "/" : dirToScan + "/";
-    }
-    if (!fs6.existsSync(dirToScan)) {
-      return [[], line];
-    }
-    const entries = fs6.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
-      if (!entry.isDirectory()) return false;
-      if (entry.name.startsWith(".") && !prefix.startsWith(".")) return false;
-      return prefix === "" || entry.name.toLowerCase().startsWith(prefix);
-    }).map((entry) => {
-      const fullPath = path6.join(dirToScan, entry.name);
-      const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
-      return displayPath + "/";
-    }).sort();
-    if (entries.length === 1) {
-      return [entries, line];
-    }
-    if (entries.length > 1) {
-      const commonPrefix = getCommonPrefix(entries);
-      if (commonPrefix.length > line.length) {
-        return [[commonPrefix], line];
-      }
-    }
-    return [entries, line];
-  } catch {
-    return [[], line];
-  }
-}
-function getCommonPrefix(strings) {
-  if (strings.length === 0) return "";
-  if (strings.length === 1) return strings[0] || "";
-  let prefix = strings[0] || "";
-  for (let i = 1; i < strings.length; i++) {
-    const str = strings[i] || "";
-    while (prefix.length > 0 && !str.startsWith(prefix)) {
-      prefix = prefix.slice(0, -1);
-    }
-  }
-  return prefix;
-}
-function isCancelled(value) {
-  return typeof value === "symbol";
-}
-
 // src/commands/wizard/setup-flow.ts
+init_detection();
+init_tui_utils();
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const s = spinner();
   const config = await group(
     {
-      storageMode: () => select({
+      storageMode: () => select2({
         message: "Where should workflow data be stored?",
         options: [
           { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Cross-project access, clean workspace" },
@@ -600,8 +1902,8 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
           options: existingProjects.map((project) => ({
             value: `${project.name}:${project.source}`,
             // Unique key
-            label: `${project.name} ${pc2.dim(`(${project.source})`)}`,
-            hint: pc2.dim(
+            label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
+            hint: pc3.dim(
               project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
             )
           })),
@@ -656,7 +1958,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       `Storage: ${config.storageMode}`
     ];
     if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc2.cyan(customGlobalPath)}`);
+      summary.push(`Global path: ${pc3.cyan(customGlobalPath)}`);
     }
     if (dataPaths.length > 0) {
       summary.push(`Data paths:`);
@@ -669,13 +1971,13 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     const linkedProjects = config.linkedProjects;
     if (linkedProjects.length > 0) {
       summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
-      summary.push(`Workspace file: ${pc2.cyan(`${workspaceName}.code-workspace`)}`);
+      summary.push(`Workspace file: ${pc3.cyan(`${workspaceName}.code-workspace`)}`);
     }
-    note(summary.join("\n"), "Setup Summary");
+    note2(summary.join("\n"), "Setup Summary");
     if (linkedProjects.length > 0) {
-      outro(pc2.green(`\u2713 Setup complete! Open ${pc2.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+      outro(pc3.green(`\u2713 Setup complete! Open ${pc3.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
     } else {
-      outro(pc2.green(`\u2713 Setup complete! Your agents are ready to use.`));
+      outro(pc3.green(`\u2713 Setup complete! Your agents are ready to use.`));
     }
   } catch (error) {
     s.stop("Error occurred");
@@ -683,77 +1985,18 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     process.exit(1);
   }
 }
-async function resolveGlobalPath() {
-  const defaultPath = getDefaultRRCEHome();
-  const isDefaultWritable = checkWriteAccess(defaultPath);
-  const options = [];
-  options.push({
-    value: "default",
-    label: `Default (${defaultPath})`,
-    hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
-  });
-  options.push({
-    value: "custom",
-    label: "Custom path",
-    hint: "Specify your own directory"
-  });
-  const choice = await select({
-    message: "Global storage location:",
-    options,
-    initialValue: isDefaultWritable ? "default" : "custom"
-  });
-  if (isCancel(choice)) {
-    return void 0;
-  }
-  if (choice === "default") {
-    if (!isDefaultWritable) {
-      note(
-        `${pc2.yellow("\u26A0")} Cannot write to default path:
-  ${pc2.dim(defaultPath)}
-
-This can happen when running via npx/bunx in restricted environments.
-Please choose a custom path instead.`,
-        "Write Access Issue"
-      );
-      return resolveGlobalPath();
-    }
-    return defaultPath;
-  }
-  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
-  const customPath = await directoryPrompt({
-    message: "Enter custom global path (Tab to autocomplete):",
-    defaultValue: suggestedPath,
-    validate: (value) => {
-      if (!value.trim()) {
-        return "Path cannot be empty";
-      }
-      if (!checkWriteAccess(value)) {
-        return `Cannot write to ${value}. Please choose a writable path.`;
-      }
-      return void 0;
-    }
-  });
-  if (isCancelled(customPath)) {
-    return void 0;
-  }
-  let expandedPath = customPath;
-  if (!expandedPath.endsWith(".rrce-workflow")) {
-    expandedPath = path7.join(expandedPath, ".rrce-workflow");
-  }
-  return expandedPath;
-}
 async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path7.join(dataPath, "knowledge"));
-    ensureDir(path7.join(dataPath, "refs"));
-    ensureDir(path7.join(dataPath, "tasks"));
-    ensureDir(path7.join(dataPath, "templates"));
+    ensureDir(path8.join(dataPath, "knowledge"));
+    ensureDir(path8.join(dataPath, "refs"));
+    ensureDir(path8.join(dataPath, "tasks"));
+    ensureDir(path8.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path7.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (config.tools.includes("copilot")) {
     const copilotPath = getAgentPromptPath(workspacePath, "copilot");
@@ -765,8 +2008,8 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
     ensureDir(antigravityPath);
     copyPromptsToDir(prompts, antigravityPath, ".md");
   }
-  const workspaceConfigPath = path7.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path7.dirname(workspaceConfigPath));
+  const workspaceConfigPath = path8.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path8.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -806,8 +2049,8 @@ linked_projects:
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path7.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path7.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path8.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -818,7 +2061,7 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
   }
 }
 function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path7.join(workspacePath, ".gitignore");
+  const gitignorePath = path8.join(workspacePath, ".gitignore");
   const entries = [];
   if (storageMode === "workspace") {
     entries.push(".rrce-workflow/");
@@ -868,16 +2111,18 @@ function updateGitignore(workspacePath, storageMode, tools) {
 }
 
 // src/commands/wizard/link-flow.ts
-import { multiselect as multiselect2, spinner as spinner2, note as note2, outro as outro2, cancel as cancel2, isCancel as isCancel2 } from "@clack/prompts";
-import pc3 from "picocolors";
+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();
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
     workspacePath
   });
   if (projects.length === 0) {
-    outro2(pc3.yellow("No other projects found. Try setting up another project first."));
+    outro2(pc4.yellow("No other projects found. Try setting up another project first."));
     return;
   }
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
@@ -886,14 +2131,14 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     options: projects.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: true
   });
-  if (isCancel2(linkedProjects)) {
+  if (isCancel3(linkedProjects)) {
     cancel2("Cancelled.");
     process.exit(0);
   }
@@ -941,43 +2186,44 @@ linked_projects:
   const workspaceFile = `${workspaceName}.code-workspace`;
   const summary = [
     `Linked projects:`,
-    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc3.dim(`(${p.source})`)}`),
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc4.dim(`(${p.source})`)}`),
     ``,
-    `Workspace file: ${pc3.cyan(workspaceFile)}`
+    `Workspace file: ${pc4.cyan(workspaceFile)}`
   ];
-  note2(summary.join("\n"), "Link Summary");
-  outro2(pc3.green(`\u2713 Projects linked! Open ${pc3.bold(workspaceFile)} in VSCode to access linked data.`));
+  note3(summary.join("\n"), "Link Summary");
+  outro2(pc4.green(`\u2713 Projects linked! Open ${pc4.bold(workspaceFile)} in VSCode to access linked data.`));
 }
 
 // src/commands/wizard/sync-flow.ts
-import { confirm as confirm2, spinner as spinner3, note as note3, outro as outro3, cancel as cancel3, isCancel as isCancel3 } from "@clack/prompts";
-import pc4 from "picocolors";
+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 path8 from "path";
+import * as path9 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs9.existsSync(path8.join(localPath, dir))
+    (dir) => fs9.existsSync(path9.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
-    outro3(pc4.yellow("No data found in workspace storage to sync."));
+    outro3(pc5.yellow("No data found in workspace storage to sync."));
     return;
   }
-  note3(
+  note4(
     `The following will be copied to global storage:
 ${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 
-Destination: ${pc4.cyan(globalPath)}`,
+Destination: ${pc5.cyan(globalPath)}`,
     "Sync Preview"
   );
   const shouldSync = await confirm2({
     message: "Proceed with sync to global storage?",
     initialValue: true
   });
-  if (isCancel3(shouldSync) || !shouldSync) {
+  if (isCancel4(shouldSync) || !shouldSync) {
     outro3("Sync cancelled.");
     return;
   }
@@ -986,8 +2232,8 @@ Destination: ${pc4.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path8.join(localPath, dir);
-      const destDir = path8.join(globalPath, dir);
+      const srcDir = path9.join(localPath, dir);
+      const destDir = path9.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -996,12 +2242,12 @@ Destination: ${pc4.cyan(globalPath)}`,
       `Synced directories:`,
       ...existingDirs.map((d) => `  \u2713 ${d}/`),
       ``,
-      `Global path: ${pc4.cyan(globalPath)}`,
+      `Global path: ${pc5.cyan(globalPath)}`,
       ``,
       `Other projects can now link this knowledge!`
     ];
-    note3(summary.join("\n"), "Sync Summary");
-    outro3(pc4.green("\u2713 Workspace knowledge synced to global storage!"));
+    note4(summary.join("\n"), "Sync Summary");
+    outro3(pc5.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)}`);
@@ -1010,10 +2256,12 @@ Destination: ${pc4.cyan(globalPath)}`,
 }
 
 // src/commands/wizard/update-flow.ts
-import { confirm as confirm3, spinner as spinner4, note as note4, outro as outro4, cancel as cancel4, isCancel as isCancel4 } from "@clack/prompts";
-import pc5 from "picocolors";
+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 path9 from "path";
+import * as path10 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner4();
   s.start("Checking for updates");
@@ -1024,7 +2272,7 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const customGlobalPath = getEffectiveRRCEHome(workspacePath);
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     s.stop("Updates found");
-    note4(
+    note5(
       `The following will be updated from the package:
   \u2022 prompts/ (${prompts.length} agent prompts)
   \u2022 templates/ (output templates)
@@ -1037,13 +2285,13 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       message: "Proceed with update?",
       initialValue: true
     });
-    if (isCancel4(shouldUpdate) || !shouldUpdate) {
+    if (isCancel5(shouldUpdate) || !shouldUpdate) {
       outro4("Update cancelled.");
       return;
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path9.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path10.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
     const configContent = fs10.readFileSync(configFilePath, "utf-8");
@@ -1065,8 +2313,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       ``,
       `Your configuration and knowledge files were preserved.`
     ];
-    note4(summary.join("\n"), "Update Summary");
-    outro4(pc5.green("\u2713 Successfully updated from package!"));
+    note5(summary.join("\n"), "Update Summary");
+    outro4(pc6.green("\u2713 Successfully updated from package!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
@@ -1074,8 +2322,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path9.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path10.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -1088,7 +2336,7 @@ function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot,
 
 // src/commands/wizard/index.ts
 async function runWizard() {
-  intro(pc6.cyan(pc6.inverse(" RRCE-Workflow Setup ")));
+  intro(pc7.cyan(pc7.inverse(" RRCE-Workflow Setup ")));
   const s = spinner5();
   s.start("Detecting environment");
   const workspacePath = detectWorkspaceRoot();
@@ -1096,9 +2344,9 @@ async function runWizard() {
   const gitUser = getGitUser();
   await new Promise((r) => setTimeout(r, 800));
   s.stop("Environment detected");
-  note5(
-    `Git User:  ${pc6.bold(gitUser || "(not found)")}
-Workspace: ${pc6.bold(workspaceName)}`,
+  note6(
+    `Git User:  ${pc7.bold(gitUser || "(not found)")}
+Workspace: ${pc7.bold(workspaceName)}`,
     "Context"
   );
   const detectedProjects = scanForProjects({
@@ -1136,11 +2384,11 @@ Workspace: ${pc6.bold(workspaceName)}`,
     }
     menuOptions.push({ value: "update", label: "Update from package", hint: "Get latest prompts & templates" });
     menuOptions.push({ value: "exit", label: "Exit" });
-    const action = await select2({
+    const action = await select3({
       message: "This workspace is already configured. What would you like to do?",
       options: menuOptions
     });
-    if (isCancel5(action) || action === "exit") {
+    if (isCancel6(action) || action === "exit") {
       outro5("Exited.");
       process.exit(0);
     }
@@ -1161,42 +2409,59 @@ Workspace: ${pc6.bold(workspaceName)}`,
 }
 
 // src/commands/selector.ts
-import { intro as intro2, select as select3, note as note6, cancel as cancel6, isCancel as isCancel6, outro as outro6 } from "@clack/prompts";
-import pc7 from "picocolors";
-import * as path10 from "path";
+init_prompts();
+import { intro as intro3, select as select5, note as note8, cancel as cancel7, isCancel as isCancel8, outro as outro7 } from "@clack/prompts";
+import pc9 from "picocolors";
+import * as path16 from "path";
 async function runSelector() {
-  const workspaceName = path10.basename(process.cwd());
-  intro2(pc7.cyan(pc7.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const workspaceName = path16.basename(process.cwd());
+  intro3(pc9.cyan(pc9.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {
-    cancel6("No agents found. Run `rrce-workflow` to set up.");
+    cancel7("No agents found. Run `rrce-workflow` to set up.");
     process.exit(0);
   }
-  const selection = await select3({
+  const selection = await select5({
     message: "Select an agent:",
-    options: prompts.map((p) => ({
-      value: p,
-      label: p.frontmatter.name,
-      hint: p.frontmatter.description
-    }))
+    options: [
+      {
+        value: "mcp",
+        label: "Manage MCP Hub",
+        hint: "Configure & Start MCP Server"
+      },
+      ...prompts.map((p) => ({
+        value: p,
+        label: p.frontmatter.name,
+        hint: p.frontmatter.description
+      }))
+    ]
   });
-  if (isCancel6(selection)) {
-    cancel6("Selection cancelled.");
+  if (isCancel8(selection)) {
+    cancel7("Selection cancelled.");
     process.exit(0);
   }
+  if (selection === "mcp") {
+    const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+    await runMCP2();
+    return;
+  }
   const prompt = selection;
-  note6(
+  note8(
     `Use this agent in your IDE by invoking:
-${pc7.bold(pc7.cyan(`@${prompt.frontmatter.name}`))}`,
+${pc9.bold(pc9.cyan(`@${prompt.frontmatter.name}`))}`,
     "Agent Selected"
   );
-  outro6("Done");
+  outro7("Done");
 }
 
 // src/index.ts
+init_mcp();
 var command = process.argv[2];
+var subcommand = process.argv[3];
 if (!command || command === "wizard") {
   runWizard();
+} else if (command === "mcp") {
+  runMCP(subcommand);
 } else {
   runSelector();
 }