rrce-workflow 0.2.23 → 0.2.25

package/dist/index.js

@@ -133,6 +133,239 @@ var init_paths = __esm({
   }
 });
 
+// src/lib/detection.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function scanForProjects(options = {}) {
+  const { excludeWorkspace, workspacePath } = options;
+  const projects = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  const globalProjects = scanGlobalStorage(excludeWorkspace);
+  for (const project of globalProjects) {
+    if (!seenPaths.has(project.dataPath)) {
+      seenPaths.add(project.dataPath);
+      projects.push(project);
+    }
+  }
+  const homeProjects = scanHomeDirectory(workspacePath);
+  for (const project of homeProjects) {
+    if (!seenPaths.has(project.dataPath)) {
+      seenPaths.add(project.dataPath);
+      projects.push(project);
+    }
+  }
+  return projects;
+}
+function scanGlobalStorage(excludeWorkspace) {
+  const rrceHome = getDefaultRRCEHome();
+  const workspacesDir = path2.join(rrceHome, "workspaces");
+  const projects = [];
+  if (!fs2.existsSync(workspacesDir)) {
+    return projects;
+  }
+  try {
+    const entries = fs2.readdirSync(workspacesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === excludeWorkspace) continue;
+      const projectDataPath = path2.join(workspacesDir, entry.name);
+      const knowledgePath = path2.join(projectDataPath, "knowledge");
+      const refsPath = path2.join(projectDataPath, "refs");
+      const tasksPath = path2.join(projectDataPath, "tasks");
+      projects.push({
+        name: entry.name,
+        path: projectDataPath,
+        // For global projects, path is the data path
+        dataPath: projectDataPath,
+        source: "global",
+        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
+      });
+    }
+  } catch {
+  }
+  return projects;
+}
+function scanHomeDirectory(excludePath) {
+  const home = process.env.HOME;
+  if (!home) return [];
+  const projects = [];
+  const maxDepth = 5;
+  function scanDir(dirPath, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const fullPath = path2.join(dirPath, entry.name);
+        if (excludePath && fullPath === excludePath) continue;
+        if (entry.name === ".rrce-workflow") {
+          const configPath = path2.join(fullPath, "config.yaml");
+          if (fs2.existsSync(configPath)) {
+            const projectPath = dirPath;
+            const projectName = path2.basename(projectPath);
+            const config = parseWorkspaceConfig(configPath);
+            const knowledgePath = path2.join(fullPath, "knowledge");
+            const refsPath = path2.join(fullPath, "refs");
+            const tasksPath = path2.join(fullPath, "tasks");
+            projects.push({
+              name: config?.name || projectName,
+              path: projectPath,
+              dataPath: fullPath,
+              source: "local",
+              storageMode: config?.storageMode,
+              knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+              refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+              tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
+            });
+          }
+          continue;
+        }
+        if (SKIP_DIRECTORIES.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && entry.name !== ".rrce-workflow") continue;
+        scanDir(fullPath, depth + 1);
+      }
+    } catch {
+    }
+  }
+  scanDir(home, 0);
+  return projects;
+}
+function parseWorkspaceConfig(configPath) {
+  try {
+    const content = fs2.readFileSync(configPath, "utf-8");
+    const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
+    const modeMatch = content.match(/mode:\s*(global|workspace)/);
+    const linkedProjects = [];
+    const linkedMatch = content.match(/linked_projects:\s*\n((?:\s+-\s+[^\n]+\n?)+)/);
+    if (linkedMatch && linkedMatch[1]) {
+      const lines = linkedMatch[1].split("\n");
+      for (const line of lines) {
+        const projectMatch = line.match(/^\s+-\s+(.+)$/);
+        if (projectMatch && projectMatch[1]) {
+          linkedProjects.push(projectMatch[1].trim());
+        }
+      }
+    }
+    return {
+      name: nameMatch?.[1]?.trim() || path2.basename(path2.dirname(path2.dirname(configPath))),
+      storageMode: modeMatch?.[1] || "global",
+      linkedProjects: linkedProjects.length > 0 ? linkedProjects : void 0
+    };
+  } catch {
+    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";
@@ -321,1716 +554,1936 @@ var init_tui_utils = __esm({
   }
 });
 
-// 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/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/lib/git.ts
-import { execSync } from "child_process";
-function getGitUser() {
+// 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 result = execSync("git config user.name", { encoding: "utf-8" });
-    return result.trim() || null;
+    const content = fs12.readFileSync(configPath, "utf-8");
+    return parseMCPConfig(content);
   } catch {
-    return null;
+    return { ...DEFAULT_MCP_CONFIG };
   }
 }
-
-// src/commands/wizard/index.ts
-init_paths();
-
-// src/lib/detection.ts
-init_paths();
-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 = [];
-  const seenPaths = /* @__PURE__ */ new Set();
-  const globalProjects = scanGlobalStorage(excludeWorkspace);
-  for (const project of globalProjects) {
-    if (!seenPaths.has(project.dataPath)) {
-      seenPaths.add(project.dataPath);
-      projects.push(project);
-    }
-  }
-  const homeProjects = scanHomeDirectory(workspacePath);
-  for (const project of homeProjects) {
-    if (!seenPaths.has(project.dataPath)) {
-      seenPaths.add(project.dataPath);
-      projects.push(project);
-    }
+function saveMCPConfig(config) {
+  const configPath = getMCPConfigPath();
+  const dir = path11.dirname(configPath);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
-  return projects;
+  const content = serializeMCPConfig(config);
+  fs12.writeFileSync(configPath, content);
 }
-function scanGlobalStorage(excludeWorkspace) {
-  const rrceHome = getDefaultRRCEHome();
-  const workspacesDir = path2.join(rrceHome, "workspaces");
-  const projects = [];
-  if (!fs2.existsSync(workspacesDir)) {
-    return projects;
-  }
-  try {
-    const entries = fs2.readdirSync(workspacesDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name === excludeWorkspace) continue;
-      const projectDataPath = path2.join(workspacesDir, entry.name);
-      const knowledgePath = path2.join(projectDataPath, "knowledge");
-      const refsPath = path2.join(projectDataPath, "refs");
-      const tasksPath = path2.join(projectDataPath, "tasks");
-      projects.push({
-        name: entry.name,
-        path: projectDataPath,
-        // For global projects, path is the data path
-        dataPath: projectDataPath,
-        source: "global",
-        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
-        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
-        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
-      });
+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";
+      }
     }
-  } catch {
-  }
-  return projects;
-}
-function scanHomeDirectory(excludePath) {
-  const home = process.env.HOME;
-  if (!home) return [];
-  const projects = [];
-  const maxDepth = 5;
-  function scanDir(dirPath, depth) {
-    if (depth > maxDepth) return;
-    try {
-      const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const fullPath = path2.join(dirPath, entry.name);
-        if (excludePath && fullPath === excludePath) continue;
-        if (entry.name === ".rrce-workflow") {
-          const configPath = path2.join(fullPath, "config.yaml");
-          if (fs2.existsSync(configPath)) {
-            const projectPath = dirPath;
-            const projectName = path2.basename(projectPath);
-            const config = parseWorkspaceConfig(configPath);
-            const knowledgePath = path2.join(fullPath, "knowledge");
-            const refsPath = path2.join(fullPath, "refs");
-            const tasksPath = path2.join(fullPath, "tasks");
-            projects.push({
-              name: config?.name || projectName,
-              path: projectPath,
-              dataPath: fullPath,
-              source: "local",
-              storageMode: config?.storageMode,
-              knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
-              refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
-              tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
-            });
-          }
-          continue;
+    if (currentSection === "projects") {
+      const projectNameMatch = line.match(/^\s+-\s+name:\s*["']?([^"'\n]+)["']?/);
+      if (projectNameMatch) {
+        if (currentProject && currentProject.name) {
+          config.projects.push(currentProject);
         }
-        if (SKIP_DIRECTORIES.has(entry.name)) continue;
-        if (entry.name.startsWith(".") && entry.name !== ".rrce-workflow") continue;
-        scanDir(fullPath, depth + 1);
+        currentProject = {
+          name: projectNameMatch[1].trim(),
+          expose: true,
+          permissions: { ...DEFAULT_PERMISSIONS }
+        };
+        inPermissions = false;
+        continue;
       }
-    } catch {
-    }
-  }
-  scanDir(home, 0);
-  return projects;
-}
-function parseWorkspaceConfig(configPath) {
-  try {
-    const content = fs2.readFileSync(configPath, "utf-8");
-    const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
-    const modeMatch = content.match(/mode:\s*(global|workspace)/);
-    const linkedProjects = [];
-    const linkedMatch = content.match(/linked_projects:\s*\n((?:\s+-\s+[^\n]+\n?)+)/);
-    if (linkedMatch && linkedMatch[1]) {
-      const lines = linkedMatch[1].split("\n");
-      for (const line of lines) {
-        const projectMatch = line.match(/^\s+-\s+(.+)$/);
-        if (projectMatch && projectMatch[1]) {
-          linkedProjects.push(projectMatch[1].trim());
+      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";
         }
       }
     }
-    return {
-      name: nameMatch?.[1]?.trim() || path2.basename(path2.dirname(path2.dirname(configPath))),
-      storageMode: modeMatch?.[1] || "global",
-      linkedProjects: linkedProjects.length > 0 ? linkedProjects : void 0
-    };
-  } catch {
-    return null;
   }
+  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
 
-// src/commands/wizard/setup-flow.ts
-init_paths();
-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/lib/prompts.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
+server:
+  port: ${config.server.port}
+  autoStart: ${config.server.autoStart}
 
-// 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()
-});
+defaults:
+  includeNew: ${config.defaults.includeNew}
+  permissions:
+    knowledge: ${config.defaults.permissions.knowledge}
+    tasks: ${config.defaults.permissions.tasks}
+    refs: ${config.defaults.permissions.refs}
 
-// 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;
+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 {
-      frontmatter: parsed.data,
-      content: content.trim(),
-      filePath
-    };
-  } catch (error) {
-    console.error(`Error reading prompt file ${filePath}:`, error);
-    return null;
   }
+  return content;
 }
-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);
+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 prompts;
-}
-function getAgentCoreDir() {
-  return path3.join(__dirname, "..", "agent-core");
-}
-function getAgentCorePromptsDir() {
-  return path3.join(getAgentCoreDir(), "prompts");
+  return config;
 }
-
-// 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 isProjectExposed(config, name) {
+  const project = config.projects.find((p) => p.name === name);
+  if (project) {
+    return project.expose;
   }
+  return config.defaults.includeNew;
 }
-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);
-    }
-  }
+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/commands/wizard/vscode.ts
-init_paths();
-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)) {
+// 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 detectActiveProject() {
+  const exposed = getExposedProjects();
+  const cwd = process.cwd();
+  const matches = exposed.filter((p) => cwd.startsWith(p.path));
+  matches.sort((a, b) => b.path.length - a.path.length);
+  return matches[0];
+}
+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 content = fs5.readFileSync(workspaceFilePath, "utf-8");
-      workspace = JSON.parse(content);
+      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 {
-      workspace = { folders: [], settings: {} };
     }
-  } else {
-    workspace = { folders: [], settings: {} };
   }
-  if (!workspace.settings) {
-    workspace.settings = {};
+  return results;
+}
+var init_resources = __esm({
+  "src/mcp/resources.ts"() {
+    "use strict";
+    init_config();
+    init_detection();
   }
-  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)`
+});
+
+// src/mcp/prompts.ts
+function getAllPrompts() {
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  return prompts.map((p) => {
+    const args = [];
+    if (p.frontmatter["required-args"]) {
+      args.push(...p.frontmatter["required-args"].map((a) => ({
+        name: a.name,
+        description: a.prompt || a.name,
+        required: true
+      })));
+    }
+    if (p.frontmatter["optional-args"]) {
+      args.push(...p.frontmatter["optional-args"].map((a) => ({
+        name: a.name,
+        description: a.prompt || a.name,
+        required: false
+      })));
+    }
+    return {
+      name: p.frontmatter.name,
+      description: p.frontmatter.description,
+      arguments: args,
+      content: p.content
+    };
+  });
+}
+function getPromptDef(name) {
+  return getAllPrompts().find((p) => p.name === name);
+}
+function renderPrompt(content, args) {
+  let rendered = content;
+  for (const [key, val] of Object.entries(args)) {
+    rendered = rendered.replace(new RegExp(`{{${key}}}`, "g"), val);
+  }
+  return rendered;
+}
+var init_prompts2 = __esm({
+  "src/mcp/prompts.ts"() {
+    "use strict";
+    init_prompts();
+  }
+});
+
+// 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";
+async function startMCPServer() {
+  try {
+    logger.info("Starting MCP Server...");
+    process.on("uncaughtException", (error) => {
+      logger.error("Uncaught Exception", error);
+      console.error("Uncaught Exception:", error);
     });
-  } else {
-    workspace.folders[mainFolderIndex] = {
-      path: ".",
-      name: `\u{1F3E0} ${workspaceName} (workspace)`
+    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;
   }
-  const referenceFolderPaths = [];
-  const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === "object";
-  if (isDetectedProjects) {
-    const projects = linkedProjects;
+}
+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 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}]`
+      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"
         });
       }
-    }
-  } 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 (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"
         });
       }
     }
-  }
-  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;
+    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;
     }
-    workspace.settings["files.readonlyInclude"] = {
-      ...cleanedReadonly,
-      ...readonlyPatterns
-    };
-  }
-  fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
+  });
 }
-
-// src/commands/wizard/setup-flow.ts
-init_tui_utils();
-async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
-  const s = spinner();
-  const config = await group(
-    {
-      storageMode: () => select2({
-        message: "Where should workflow data be stored?",
-        options: [
-          { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Cross-project access, clean workspace" },
-          { value: "workspace", label: "Workspace (.rrce-workflow/)", hint: "Self-contained, version with repo" }
-        ],
-        initialValue: "global"
-      }),
-      tools: () => multiselect({
-        message: "Which AI tools do you use?",
-        options: [
-          { value: "copilot", label: "GitHub Copilot", hint: "VSCode" },
-          { value: "antigravity", label: "Antigravity IDE" }
-        ],
-        required: false
-      }),
-      linkedProjects: () => {
-        if (existingProjects.length === 0) {
-          return Promise.resolve([]);
+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"]
         }
-        return multiselect({
-          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(
-              project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
-            )
-          })),
-          required: false
-        });
       },
-      addToGitignore: () => confirm({
-        message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
-        initialValue: true
-      }),
-      confirm: () => confirm({
-        message: "Create configuration?",
-        initialValue: true
-      })
-    },
-    {
-      onCancel: () => {
-        cancel("Setup process cancelled.");
-        process.exit(0);
+      {
+        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;
     }
-  );
-  if (!config.confirm) {
-    outro("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.");
-      process.exit(1);
-    }
-  }
-  s.start("Generating configuration");
-  try {
-    await generateConfiguration({
-      storageMode: config.storageMode,
-      globalPath: customGlobalPath,
-      tools: config.tools,
-      linkedProjects: config.linkedProjects,
-      addToGitignore: config.addToGitignore
-    }, workspacePath, workspaceName, existingProjects);
-    s.stop("Configuration generated");
-    const dataPaths = getDataPaths(
-      config.storageMode,
-      workspaceName,
-      workspacePath,
-      customGlobalPath
-    );
-    const summary = [
-      `Storage: ${config.storageMode}`
-    ];
-    if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc3.cyan(customGlobalPath)}`);
-    }
-    if (dataPaths.length > 0) {
-      summary.push(`Data paths:`);
-      dataPaths.forEach((p) => summary.push(`  - ${p}`));
-    }
-    const selectedTools = config.tools;
-    if (selectedTools.length > 0) {
-      summary.push(`Tools: ${selectedTools.join(", ")}`);
-    }
-    const linkedProjects = config.linkedProjects;
-    if (linkedProjects.length > 0) {
-      summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
-      summary.push(`Workspace file: ${pc3.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.`));
-    } else {
-      outro(pc3.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)}`);
-    process.exit(1);
-  }
+  });
 }
-async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
-  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"));
-  }
-  const agentCoreDir = getAgentCoreDir();
-  syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", dataPaths);
-  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-  if (config.tools.includes("copilot")) {
-    const copilotPath = getAgentPromptPath(workspacePath, "copilot");
-    ensureDir(copilotPath);
-    copyPromptsToDir(prompts, copilotPath, ".agent.md");
-  }
-  if (config.tools.includes("antigravity")) {
-    const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
-    ensureDir(antigravityPath);
-    copyPromptsToDir(prompts, antigravityPath, ".md");
-  }
-  const workspaceConfigPath = path8.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path8.dirname(workspaceConfigPath));
-  let configContent = `# RRCE-Workflow Configuration
-version: 1
-
-storage:
-  mode: ${config.storageMode}`;
-  if (config.globalPath && config.globalPath !== getDefaultRRCEHome()) {
-    configContent += `
-  globalPath: "${config.globalPath}"`;
-  }
-  configContent += `
-
-project:
-  name: "${workspaceName}"
-
-tools:
-  copilot: ${config.tools.includes("copilot")}
-  antigravity: ${config.tools.includes("antigravity")}
+function registerPromptHandlers(server) {
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    logger.debug("Listing prompts");
+    const prompts = getAllPrompts();
+    return {
+      prompts: 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);
+    const promptDef = getPromptDef(name);
+    if (!promptDef) {
+      logger.error(`Prompt not found: ${name}`);
+      throw new Error(`Prompt not found: ${name}`);
+    }
+    try {
+      const providedArgs = args || {};
+      const missingArgs = promptDef.arguments.filter((a) => a.required && !providedArgs[a.name]).map((a) => a.name);
+      if (missingArgs.length > 0) {
+        throw new Error(`Missing required arguments: ${missingArgs.join(", ")}`);
+      }
+      const renderArgs = {};
+      for (const [key, val] of Object.entries(providedArgs)) {
+        renderArgs[key] = String(val);
+      }
+      const content = renderPrompt(promptDef.content, renderArgs);
+      const projects = getExposedProjects();
+      const activeProject = detectActiveProject();
+      const projectList = projects.map((p) => {
+        const isActive = activeProject && p.dataPath === activeProject.dataPath;
+        return `- ${p.name} (${p.source}) ${isActive ? "**[ACTIVE]**" : ""}`;
+      }).join("\n");
+      let contextPreamble = `
+Context - Available Projects (MCP Hub):
+${projectList}
 `;
-  if (config.linkedProjects.length > 0) {
-    configContent += `
-linked_projects:
+      if (activeProject) {
+        contextPreamble += `
+Current Active Workspace: ${activeProject.name} (${activeProject.path})
 `;
-    config.linkedProjects.forEach((name) => {
-      configContent += `  - ${name}
+        contextPreamble += `IMPORTANT: Treat '${activeProject.path}' as the {{WORKSPACE_ROOT}}. All relative path operations (file reads/writes) MUST be performed relative to this directory.
 `;
-    });
-  }
-  fs7.writeFileSync(workspaceConfigPath, configContent);
-  if (config.addToGitignore) {
-    updateGitignore(workspacePath, config.storageMode, config.tools);
-  }
-  if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
-    const selectedProjects = allProjects.filter(
-      (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
-    );
-    generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
+      }
+      contextPreamble += `
+Note: If the user's request refers to a project not listed here, ask them to expose it via 'rrce-workflow mcp configure'.
+
+---
+`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: contextPreamble + content
+            }
+          }
+        ]
+      };
+    } 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 getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path8.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
-  switch (mode) {
-    case "global":
-      return [globalPath];
-    case "workspace":
-      return [workspacePath];
-    default:
-      return [globalPath];
+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 fs15 from "fs";
+import * as path14 from "path";
+import * as os from "os";
+function checkInstallStatus() {
+  return {
+    antigravity: checkConfigFile(ANTIGRAVITY_CONFIG),
+    claude: checkConfigFile(CLAUDE_CONFIG)
+  };
 }
-function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path8.join(workspacePath, ".gitignore");
-  const entries = [];
-  if (storageMode === "workspace") {
-    entries.push(".rrce-workflow/");
+function checkConfigFile(configPath) {
+  if (!fs15.existsSync(configPath)) return false;
+  try {
+    const content = JSON.parse(fs15.readFileSync(configPath, "utf-8"));
+    return !!content.mcpServers?.["rrce"];
+  } catch {
+    return false;
   }
-  if (tools.includes("copilot")) {
-    entries.push(".github/agents/");
+}
+function installToConfig(target) {
+  const configPath = target === "antigravity" ? ANTIGRAVITY_CONFIG : CLAUDE_CONFIG;
+  const dir = path14.dirname(configPath);
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
   }
-  if (tools.includes("antigravity")) {
-    entries.push(".agent/");
+  let config = { mcpServers: {} };
+  if (fs15.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs15.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
   }
-  if (entries.length === 0) {
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+    // -y to avoid interactive prompts
+  };
+  try {
+    fs15.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return true;
+  } catch {
     return false;
   }
-  try {
-    let content = "";
-    if (fs7.existsSync(gitignorePath)) {
-      content = fs7.readFileSync(gitignorePath, "utf-8");
+}
+var ANTIGRAVITY_CONFIG, CLAUDE_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");
+  }
+});
+
+// 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;
     }
-    const lines = content.split("\n").map((line) => line.trim());
-    const newEntries = [];
-    for (const entry of entries) {
-      const entryWithoutSlash = entry.replace(/\/$/, "");
-      const commentedEntry = `# ${entry}`;
-      const commentedEntryNoSlash = `# ${entryWithoutSlash}`;
-      if (!lines.some(
-        (line) => line === entry || line === entryWithoutSlash || line === commentedEntry || line === commentedEntryNoSlash
-      )) {
-        newEntries.push(entry);
-      }
+  }
+  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;
     }
-    if (newEntries.length === 0) {
-      return false;
+  }
+  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 newContent = content;
-    if (!newContent.endsWith("\n") && newContent !== "") {
-      newContent += "\n";
+  }
+  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;
     }
-    if (newContent === "" || !content.includes("# rrce-workflow")) {
-      newContent += "\n# rrce-workflow generated folders (uncomment to ignore)\n";
+    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;
     }
-    newContent += newEntries.map((e) => `# ${e}`).join("\n") + "\n";
-    fs7.writeFileSync(gitignorePath, newContent);
-    return true;
-  } catch {
-    return false;
   }
+  outro6(pc8.green("MCP Hub closed."));
 }
-
-// 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";
-async function runLinkProjectsFlow(workspacePath, workspaceName) {
-  const projects = scanForProjects({
-    excludeWorkspace: workspaceName,
-    workspacePath
+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 (projects.length === 0) {
-    outro2(pc4.yellow("No other projects found. Try setting up another project first."));
-    return;
+  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")}`);
   }
-  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const linkedProjects = await multiselect2({
-    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(
-        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
-      )
-    })),
-    required: true
-  });
-  if (isCancel3(linkedProjects)) {
-    cancel2("Cancelled.");
-    process.exit(0);
+  if (results.length > 0) {
+    note7(results.join("\n"), "Installation Results");
   }
-  const selectedKeys = linkedProjects;
-  if (selectedKeys.length === 0) {
-    outro2("No projects selected.");
-    return;
+}
+async function handleStartServer() {
+  const fs16 = await import("fs");
+  const { getLogFilePath: getLogFilePath2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+  const config = loadMCPConfig();
+  const exposedCount = config.projects.filter((p) => p.expose).length;
+  if (exposedCount === 0 && !config.defaults.includeNew) {
+    const shouldConfig = await confirm4({
+      message: "No projects are currently exposed. Configure now?",
+      initialValue: true
+    });
+    if (shouldConfig && !isCancel7(shouldConfig)) {
+      await handleConfigure();
+    }
   }
-  const selectedProjects = projects.filter(
-    (p) => selectedKeys.includes(`${p.name}:${p.source}`)
-  );
-  const s = spinner2();
-  s.start("Linking projects");
-  const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs8.readFileSync(configFilePath, "utf-8");
-  if (configContent.includes("linked_projects:")) {
-    const lines = configContent.split("\n");
-    const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
-    if (linkedIndex !== -1) {
-      let insertIndex = linkedIndex + 1;
-      while (insertIndex < lines.length && lines[insertIndex]?.startsWith("  - ")) {
-        insertIndex++;
-      }
-      for (const project of selectedProjects) {
-        const entry = `  - ${project.name}:${project.source}`;
-        if (!configContent.includes(entry)) {
-          lines.splice(insertIndex, 0, entry);
-          insertIndex++;
-        }
-      }
-      configContent = lines.join("\n");
+  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";
     }
-  } else {
-    configContent += `
-linked_projects:
-`;
-    selectedProjects.forEach((project) => {
-      configContent += `  - ${project.name}:${project.source}
-`;
+  });
+  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 (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 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 (fs16.existsSync(logPath)) {
+          const stats = fs16.statSync(logPath);
+          if (stats.size > lastSize) {
+            const stream = fs16.createReadStream(logPath, {
+              start: lastSize,
+              end: stats.size,
+              encoding: "utf-8"
+            });
+            stream.on("data", (chunk) => {
+              process.stderr.write(chunk);
+            });
+            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);
   }
-  fs8.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})`)}`),
-    ``,
-    `Workspace file: ${pc4.cyan(workspaceFile)}`
-  ];
-  note3(summary.join("\n"), "Link Summary");
-  outro2(pc4.green(`\u2713 Projects linked! Open ${pc4.bold(workspaceFile)} in VSCode to access linked data.`));
 }
+async function handleConfigureGlobalPath() {
+  const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
+  const fs16 = await import("fs");
+  const path16 = await import("path");
+  note7(
+    `MCP Hub requires a ${pc8.bold("global storage path")} to store its configuration
+and coordinate across projects.
 
-// 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";
-async function runSyncToGlobalFlow(workspacePath, workspaceName) {
-  const localPath = getLocalWorkspacePath(workspacePath);
-  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
-  const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
-  const existingDirs = subdirs.filter(
-    (dir) => fs9.existsSync(path9.join(localPath, dir))
+Your current setup uses ${pc8.cyan("workspace")} mode, which stores data
+locally in each project. MCP needs a central location.`,
+    "Global Path Required"
   );
-  if (existingDirs.length === 0) {
-    outro3(pc5.yellow("No data found in workspace storage to sync."));
-    return;
+  const resolvedPath = await resolveGlobalPath2();
+  if (!resolvedPath) {
+    return false;
   }
-  note4(
-    `The following will be copied to global storage:
-${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
+  try {
+    if (!fs16.existsSync(resolvedPath)) {
+      fs16.mkdirSync(resolvedPath, { recursive: true });
+    }
+    const config = loadMCPConfig();
+    saveMCPConfig(config);
+    note7(
+      `${pc8.green("\u2713")} Global path configured: ${pc8.cyan(resolvedPath)}
 
-Destination: ${pc5.cyan(globalPath)}`,
-    "Sync Preview"
-  );
-  const shouldSync = await confirm2({
-    message: "Proceed with sync to global storage?",
-    initialValue: true
-  });
-  if (isCancel4(shouldSync) || !shouldSync) {
-    outro3("Sync cancelled.");
+MCP config will be stored at:
+${path16.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 s = spinner3();
-  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);
-      ensureDir(destDir);
-      copyDirRecursive(srcDir, destDir);
-    }
-    s.stop("Sync complete");
-    const summary = [
-      `Synced directories:`,
-      ...existingDirs.map((d) => `  \u2713 ${d}/`),
-      ``,
-      `Global path: ${pc5.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!"));
-  } catch (error) {
-    s.stop("Error occurred");
-    cancel3(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
+  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}`);
   }
-}
-
-// src/commands/wizard/update-flow.ts
-init_paths();
-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";
-async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
-  const s = spinner4();
-  s.start("Checking for updates");
-  try {
-    const agentCoreDir = getAgentCoreDir();
-    const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-    const mode = currentStorageMode || "global";
-    const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-    const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
-    s.stop("Updates found");
-    note5(
-      `The following will be updated from the package:
-  \u2022 prompts/ (${prompts.length} agent prompts)
-  \u2022 templates/ (output templates)
-
-Target locations:
-${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
-      "Update Preview"
-    );
-    const shouldUpdate = await confirm3({
-      message: "Proceed with update?",
-      initialValue: true
-    });
-    if (isCancel5(shouldUpdate) || !shouldUpdate) {
-      outro4("Update cancelled.");
-      return;
-    }
-    s.start("Updating from package");
-    for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path10.join(agentCoreDir, "templates"), "templates", [dataPath]);
-    }
-    const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs10.readFileSync(configFilePath, "utf-8");
-    if (configContent.includes("copilot: true")) {
-      const copilotPath = getAgentPromptPath(workspacePath, "copilot");
-      ensureDir(copilotPath);
-      copyPromptsToDir(prompts, copilotPath, ".agent.md");
-    }
-    if (configContent.includes("antigravity: true")) {
-      const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
-      ensureDir(antigravityPath);
-      copyPromptsToDir(prompts, antigravityPath, ".md");
-    }
-    s.stop("Update complete");
-    const summary = [
-      `Updated:`,
-      `  \u2713 ${prompts.length} agent prompts`,
-      `  \u2713 Output templates`,
-      ``,
-      `Your configuration and knowledge files were preserved.`
-    ];
-    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)}`);
-    process.exit(1);
+  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");
 }
-function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path10.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
-  switch (mode) {
-    case "global":
-      return [globalPath];
-    case "workspace":
-      return [workspacePath];
-    default:
-      return [globalPath];
+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;
   }
-}
-
-// src/commands/wizard/index.ts
-async function runWizard() {
-  intro(pc7.cyan(pc7.inverse(" RRCE-Workflow Setup ")));
-  const s = spinner5();
-  s.start("Detecting environment");
-  const workspacePath = detectWorkspaceRoot();
-  const workspaceName = getWorkspaceName(workspacePath);
-  const gitUser = getGitUser();
-  await new Promise((r) => setTimeout(r, 800));
-  s.stop("Environment detected");
-  note6(
-    `Git User:  ${pc7.bold(gitUser || "(not found)")}
-Workspace: ${pc7.bold(workspaceName)}`,
-    "Context"
-  );
-  const detectedProjects = scanForProjects({
-    excludeWorkspace: workspaceName,
-    workspacePath
+  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 configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs11.existsSync(configFilePath);
-  let currentStorageMode = null;
-  if (isAlreadyConfigured) {
-    try {
-      const configContent = fs11.readFileSync(configFilePath, "utf-8");
-      const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
-      currentStorageMode = modeMatch?.[1] ?? null;
-    } catch {
-    }
+  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 localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs11.existsSync(localDataPath);
-  if (isAlreadyConfigured) {
-    const menuOptions = [];
-    if (detectedProjects.length > 0) {
-      menuOptions.push({
-        value: "link",
-        label: "Link other project knowledge",
-        hint: `${detectedProjects.length} projects detected (global + sibling)`
-      });
-    }
-    if (currentStorageMode === "workspace" && hasLocalData) {
-      menuOptions.push({
-        value: "sync-global",
-        label: "Sync to global storage",
-        hint: "Share knowledge with other projects"
-      });
-    }
-    menuOptions.push({ value: "update", label: "Update from package", hint: "Get latest prompts & templates" });
-    menuOptions.push({ value: "exit", label: "Exit" });
-    const action = await select3({
-      message: "This workspace is already configured. What would you like to do?",
-      options: menuOptions
-    });
-    if (isCancel6(action) || action === "exit") {
-      outro5("Exited.");
-      process.exit(0);
-    }
-    if (action === "link") {
-      await runLinkProjectsFlow(workspacePath, workspaceName);
-      return;
-    }
-    if (action === "sync-global") {
-      await runSyncToGlobalFlow(workspacePath, workspaceName);
-      return;
-    }
-    if (action === "update") {
-      await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
-      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);
   }
-  await runSetupFlow(workspacePath, workspaceName, detectedProjects);
-}
+  saveMCPConfig(config);
+  logger2.info("Configure: Config saved", config);
+  const exposedCount = selectedNames.length;
+  note7(
+    `${pc8.green("\u2713")} Configuration saved!
 
-// src/commands/selector.ts
-import { intro as intro2, select as select4, note as note7, cancel as cancel6, isCancel as isCancel7, outro as outro6 } from "@clack/prompts";
-import pc8 from "picocolors";
-import * as path11 from "path";
-async function runSelector() {
-  const workspaceName = path11.basename(process.cwd());
-  intro2(pc8.cyan(pc8.inverse(` RRCE-Workflow | ${workspaceName} `)));
-  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-  if (prompts.length === 0) {
-    cancel6("No agents found. Run `rrce-workflow` to set up.");
-    process.exit(0);
+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 selection = await select4({
-    message: "Select an agent:",
-    options: prompts.map((p) => ({
-      value: p,
-      label: p.frontmatter.name,
-      hint: p.frontmatter.description
-    }))
+  const confirmed = await confirm4({
+    message: "Stop the MCP server?",
+    initialValue: true
   });
-  if (isCancel7(selection)) {
-    cancel6("Selection cancelled.");
-    process.exit(0);
+  if (isCancel7(confirmed) || !confirmed) {
+    return;
   }
-  const prompt = selection;
-  note7(
-    `Use this agent in your IDE by invoking:
-${pc8.bold(pc8.cyan(`@${prompt.frontmatter.name}`))}`,
-    "Agent Selected"
-  );
-  outro6("Done");
+  stopMCPServer();
+  note7(pc8.green("MCP server stopped."), "Server Stopped");
 }
+function showHelp() {
+  const help = `
+${pc8.bold("RRCE MCP Hub")} - Cross-project AI assistant server
 
-// src/mcp/index.ts
-import { intro as intro3, outro as outro7, select as select5, multiselect as multiselect3, confirm as confirm4, spinner as spinner6, note as note8, cancel as cancel7, isCancel as isCancel8 } from "@clack/prompts";
-import pc9 from "picocolors";
+${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/mcp/config.ts
-init_paths();
-import * as fs12 from "fs";
-import * as path12 from "path";
+${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/mcp/types.ts
-var DEFAULT_MCP_CONFIG = {
-  server: {
-    port: 3e3,
-    autoStart: false
-  },
-  projects: [],
-  defaults: {
-    includeNew: true,
-    permissions: {
-      knowledge: true,
-      tasks: true,
-      refs: true
-    }
-  }
-};
-var DEFAULT_PERMISSIONS = {
-  knowledge: true,
-  tasks: true,
-  refs: true
-};
+${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/mcp/config.ts
-function getMCPConfigPath() {
-  const workspaceRoot = detectWorkspaceRoot();
-  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path12.join(rrceHome, "mcp.yaml");
-}
-function ensureMCPGlobalPath() {
-  const workspaceRoot = detectWorkspaceRoot();
-  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  if (rrceHome.startsWith(".") || rrceHome.includes(".rrce-workflow/")) {
-    const configPath = path12.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."
-        };
-      }
+${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 {
-    configured: true,
-    path: rrceHome
-  };
+}`)}
+
+${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 loadMCPConfig() {
-  const configPath = getMCPConfigPath();
-  if (!fs12.existsSync(configPath)) {
-    return { ...DEFAULT_MCP_CONFIG };
+var init_mcp = __esm({
+  "src/mcp/index.ts"() {
+    "use strict";
+    init_config();
+    init_detection();
+    init_server();
+    init_install();
   }
+});
+
+// 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 content = fs12.readFileSync(configPath, "utf-8");
-    return parseMCPConfig(content);
+    const result = execSync("git config user.name", { encoding: "utf-8" });
+    return result.trim() || null;
   } catch {
-    return { ...DEFAULT_MCP_CONFIG };
-  }
-}
-function saveMCPConfig(config) {
-  const configPath = getMCPConfigPath();
-  const dir = path12.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 portMatch = content.match(/port:\s*(\d+)/);
-  if (portMatch?.[1]) config.server.port = parseInt(portMatch[1], 10);
-  const autoStartMatch = content.match(/autoStart:\s*(true|false)/);
-  if (autoStartMatch) config.server.autoStart = autoStartMatch[1] === "true";
-  const includeNewMatch = content.match(/includeNew:\s*(true|false)/);
-  if (includeNewMatch) config.defaults.includeNew = includeNewMatch[1] === "true";
-  const projectsMatch = content.match(/projects:\s*\n((?:\s+-[\s\S]*?(?=\n\w|\n*$))+)/);
-  if (projectsMatch?.[1]) {
-    const projectsContent = projectsMatch[1];
-    const projectBlocks = projectsContent.split(/\n\s+-\s+name:/).filter(Boolean);
-    for (const block of projectBlocks) {
-      const nameMatch = block.match(/(?:^|\n\s*)name:\s*[\"']?([^\"'\n]+)[\"']?/) || block.match(/^[\"']?([^\"'\n:]+)[\"']?/);
-      const exposeMatch = block.match(/expose:\s*(true|false)/);
-      if (nameMatch?.[1]) {
-        const permissions = parsePermissions(block);
-        config.projects.push({
-          name: nameMatch[1].trim(),
-          expose: exposeMatch ? exposeMatch[1] === "true" : true,
-          permissions
-        });
-      }
-    }
+    return null;
   }
-  return config;
 }
-function parsePermissions(block) {
-  const permissions = { ...DEFAULT_PERMISSIONS };
-  const knowledgeMatch = block.match(/knowledge:\s*(true|false)/);
-  if (knowledgeMatch) permissions.knowledge = knowledgeMatch[1] === "true";
-  const tasksMatch = block.match(/tasks:\s*(true|false)/);
-  if (tasksMatch) permissions.tasks = tasksMatch[1] === "true";
-  const refsMatch = block.match(/refs:\s*(true|false)/);
-  if (refsMatch) permissions.refs = refsMatch[1] === "true";
-  return permissions;
-}
-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}
+// src/commands/wizard/index.ts
+init_paths();
+init_detection();
 
-defaults:
-  includeNew: ${config.defaults.includeNew}
-  permissions:
-    knowledge: ${config.defaults.permissions.knowledge}
-    tasks: ${config.defaults.permissions.tasks}
-    refs: ${config.defaults.permissions.refs}
+// 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";
 
-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}
-`;
-    }
+// 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);
   }
-  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 };
+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);
     }
-  } 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;
 }
 
-// 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 fs14 from "fs";
-import * as path14 from "path";
-
-// src/mcp/resources.ts
-import * as fs13 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 (!fs13.existsSync(contextPath)) {
-    return null;
-  }
-  return fs13.readFileSync(contextPath, "utf-8");
-}
-function getProjectTasks(projectName) {
-  const config = loadMCPConfig();
-  if (!isProjectExposed(config, projectName)) {
-    return [];
+// 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: {} };
   }
-  const permissions = getProjectPermissions(config, projectName);
-  if (!permissions.tasks) {
-    return [];
+  if (!workspace.settings) {
+    workspace.settings = {};
   }
-  const projects = scanForProjects();
-  const project = projects.find((p) => p.name === projectName);
-  if (!project?.tasksPath || !fs13.existsSync(project.tasksPath)) {
-    return [];
+  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 tasks = [];
-  try {
-    const taskDirs = fs13.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)) {
-        try {
-          const meta = JSON.parse(fs13.readFileSync(metaPath, "utf-8"));
-          tasks.push(meta);
-        } catch {
-        }
+  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}]`
+        });
       }
     }
-  } 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 = fs13.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 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
-          });
-        }
+  } 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]`
+        });
       }
-    } catch {
     }
   }
-  return results;
-}
-
-// src/mcp/prompts.ts
-var 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 }
-    ]
+  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
+    };
   }
-];
-
-// src/mcp/server.ts
-var serverState = { running: false };
-var mcpServer = null;
-async function startMCPServer() {
-  const config = loadMCPConfig();
-  mcpServer = new Server(
-    { name: "rrce-mcp-hub", version: "1.0.0" },
-    { capabilities: { resources: {}, tools: {}, prompts: {} } }
-  );
-  registerResourceHandlers(mcpServer);
-  registerToolHandlers(mcpServer);
-  registerPromptHandlers(mcpServer);
-  const transport = new StdioServerTransport();
-  await mcpServer.connect(transport);
-  serverState = { running: true, port: config.server.port, pid: process.pid };
-  console.error(`RRCE MCP Hub started (pid: ${process.pid})`);
-  console.error(`Exposed projects: ${getExposedProjects().map((p) => p.name).join(", ")}`);
-  return { port: config.server.port, pid: process.pid };
+  fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
-function registerResourceHandlers(server) {
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    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"
+
+// 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: () => select2({
+        message: "Where should workflow data be stored?",
+        options: [
+          { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Cross-project access, clean workspace" },
+          { value: "workspace", label: "Workspace (.rrce-workflow/)", hint: "Self-contained, version with repo" }
+        ],
+        initialValue: "global"
+      }),
+      tools: () => multiselect({
+        message: "Which AI tools do you use?",
+        options: [
+          { value: "copilot", label: "GitHub Copilot", hint: "VSCode" },
+          { value: "antigravity", label: "Antigravity IDE" }
+        ],
+        required: false
+      }),
+      linkedProjects: () => {
+        if (existingProjects.length === 0) {
+          return Promise.resolve([]);
+        }
+        return multiselect({
+          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(
+              project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
+            )
+          })),
+          required: false
         });
+      },
+      addToGitignore: () => confirm({
+        message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
+        initialValue: true
+      }),
+      confirm: () => confirm({
+        message: "Create configuration?",
+        initialValue: true
+      })
+    },
+    {
+      onCancel: () => {
+        cancel("Setup process cancelled.");
+        process.exit(0);
       }
     }
-    return { resources };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const { uri } = request.params;
-    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)
-        }]
-      };
+  );
+  if (!config.confirm) {
+    outro("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.");
+      process.exit(1);
     }
-    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
-        }]
-      };
+  }
+  s.start("Generating configuration");
+  try {
+    await generateConfiguration({
+      storageMode: config.storageMode,
+      globalPath: customGlobalPath,
+      tools: config.tools,
+      linkedProjects: config.linkedProjects,
+      addToGitignore: config.addToGitignore
+    }, workspacePath, workspaceName, existingProjects);
+    s.stop("Configuration generated");
+    const dataPaths = getDataPaths(
+      config.storageMode,
+      workspaceName,
+      workspacePath,
+      customGlobalPath
+    );
+    const summary = [
+      `Storage: ${config.storageMode}`
+    ];
+    if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
+      summary.push(`Global path: ${pc3.cyan(customGlobalPath)}`);
     }
-    throw new Error(`Unknown resource: ${uri}`);
-  });
-}
-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;
-    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) {
-          return { content: [{ type: "text", text: `No project context found for "${args.project}"` }], isError: true };
-        }
-        return { content: [{ type: "text", text: context }] };
-      }
-      default:
-        throw new Error(`Unknown tool: ${name}`);
+    if (dataPaths.length > 0) {
+      summary.push(`Data paths:`);
+      dataPaths.forEach((p) => summary.push(`  - ${p}`));
     }
-  });
-}
-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;
-    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 (!fs14.existsSync(promptPath)) throw new Error(`Prompt file not found: ${promptDef.file}`);
-    let promptContent = fs14.readFileSync(promptPath, "utf-8");
-    if (args) {
-      for (const [key, value] of Object.entries(args)) {
-        promptContent = promptContent.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), String(value));
-      }
+    const selectedTools = config.tools;
+    if (selectedTools.length > 0) {
+      summary.push(`Tools: ${selectedTools.join(", ")}`);
     }
-    return {
-      description: promptDef.description,
-      messages: [{ role: "user", content: { type: "text", text: promptContent } }]
-    };
-  });
+    const linkedProjects = config.linkedProjects;
+    if (linkedProjects.length > 0) {
+      summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
+      summary.push(`Workspace file: ${pc3.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.`));
+    } else {
+      outro(pc3.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)}`);
+    process.exit(1);
+  }
 }
-function stopMCPServer() {
-  if (mcpServer) {
-    mcpServer.close();
-    mcpServer = null;
+async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
+  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"));
+  }
+  const agentCoreDir = getAgentCoreDir();
+  syncMetadataToAll(agentCoreDir, dataPaths);
+  copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", dataPaths);
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  if (config.tools.includes("copilot")) {
+    const copilotPath = getAgentPromptPath(workspacePath, "copilot");
+    ensureDir(copilotPath);
+    copyPromptsToDir(prompts, copilotPath, ".agent.md");
+  }
+  if (config.tools.includes("antigravity")) {
+    const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
+    ensureDir(antigravityPath);
+    copyPromptsToDir(prompts, antigravityPath, ".md");
+  }
+  const workspaceConfigPath = path8.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path8.dirname(workspaceConfigPath));
+  let configContent = `# RRCE-Workflow Configuration
+version: 1
+
+storage:
+  mode: ${config.storageMode}`;
+  if (config.globalPath && config.globalPath !== getDefaultRRCEHome()) {
+    configContent += `
+  globalPath: "${config.globalPath}"`;
+  }
+  configContent += `
+
+project:
+  name: "${workspaceName}"
+
+tools:
+  copilot: ${config.tools.includes("copilot")}
+  antigravity: ${config.tools.includes("antigravity")}
+`;
+  if (config.linkedProjects.length > 0) {
+    configContent += `
+linked_projects:
+`;
+    config.linkedProjects.forEach((name) => {
+      configContent += `  - ${name}
+`;
+    });
+  }
+  fs7.writeFileSync(workspaceConfigPath, configContent);
+  if (config.addToGitignore) {
+    updateGitignore(workspacePath, config.storageMode, config.tools);
+  }
+  if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
+    const selectedProjects = allProjects.filter(
+      (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
+    );
+    generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
   }
-  serverState = { running: false };
-  console.error("RRCE MCP Hub stopped");
 }
-function getMCPServerStatus() {
-  return { ...serverState };
+function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
+  const globalPath = path8.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
+  switch (mode) {
+    case "global":
+      return [globalPath];
+    case "workspace":
+      return [workspacePath];
+    default:
+      return [globalPath];
+  }
 }
-
-// src/mcp/index.ts
-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;
-    }
+function updateGitignore(workspacePath, storageMode, tools) {
+  const gitignorePath = path8.join(workspacePath, ".gitignore");
+  const entries = [];
+  if (storageMode === "workspace") {
+    entries.push(".rrce-workflow/");
   }
-  intro3(pc9.bgCyan(pc9.black(" RRCE MCP Hub ")));
-  const globalPathCheck = await ensureMCPGlobalPath();
-  if (!globalPathCheck.configured) {
-    const configured = await handleConfigureGlobalPath();
-    if (!configured) {
-      outro7(pc9.yellow("MCP requires a global storage path. Setup cancelled."));
-      return;
-    }
+  if (tools.includes("copilot")) {
+    entries.push(".github/agents/");
   }
-  let running = true;
-  while (running) {
-    const action = await select5({
-      message: "What would you like to do?",
-      options: [
-        { value: "status", label: "\u{1F4CB} View project status", hint: "See which projects are exposed" },
-        { value: "configure", label: "\u2699\uFE0F  Configure projects", hint: "Choose which projects to expose" },
-        { value: "start", label: "\u25B6\uFE0F  Start MCP server", hint: "Start the MCP server" },
-        { value: "stop", label: "\u23F9\uFE0F  Stop MCP server", hint: "Stop the running server" },
-        { value: "help", label: "\u2753 Help", hint: "Learn about MCP Hub" },
-        { value: "exit", label: "\u21A9  Exit", hint: "Return to shell" }
-      ]
-    });
-    if (isCancel8(action)) {
-      cancel7("MCP Hub closed.");
-      return;
-    }
-    switch (action) {
-      case "status":
-        await handleShowStatus();
-        break;
-      case "configure":
-        await handleConfigure();
-        break;
-      case "start":
-        await handleStartServer();
-        running = false;
-        break;
-      case "stop":
-        await handleStopServer();
-        break;
-      case "help":
-        showHelp();
-        break;
-      case "exit":
-        running = false;
-        break;
-    }
+  if (tools.includes("antigravity")) {
+    entries.push(".agent/");
   }
-  outro7(pc9.green("MCP Hub closed."));
-}
-async function handleConfigureGlobalPath() {
-  const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs15 = await import("fs");
-  const path15 = await import("path");
-  note8(
-    `MCP Hub requires a ${pc9.bold("global storage path")} to store its configuration
-and coordinate across projects.
-
-Your current setup uses ${pc9.cyan("workspace")} mode, which stores data
-locally in each project. MCP needs a central location.`,
-    "Global Path Required"
-  );
-  const resolvedPath = await resolveGlobalPath2();
-  if (!resolvedPath) {
+  if (entries.length === 0) {
     return false;
   }
   try {
-    if (!fs15.existsSync(resolvedPath)) {
-      fs15.mkdirSync(resolvedPath, { recursive: true });
+    let content = "";
+    if (fs7.existsSync(gitignorePath)) {
+      content = fs7.readFileSync(gitignorePath, "utf-8");
     }
-    const config = loadMCPConfig();
-    saveMCPConfig(config);
-    note8(
-      `${pc9.green("\u2713")} Global path configured: ${pc9.cyan(resolvedPath)}
-
-MCP config will be stored at:
-${path15.join(resolvedPath, "mcp.yaml")}`,
-      "Configuration Saved"
-    );
+    const lines = content.split("\n").map((line) => line.trim());
+    const newEntries = [];
+    for (const entry of entries) {
+      const entryWithoutSlash = entry.replace(/\/$/, "");
+      const commentedEntry = `# ${entry}`;
+      const commentedEntryNoSlash = `# ${entryWithoutSlash}`;
+      if (!lines.some(
+        (line) => line === entry || line === entryWithoutSlash || line === commentedEntry || line === commentedEntryNoSlash
+      )) {
+        newEntries.push(entry);
+      }
+    }
+    if (newEntries.length === 0) {
+      return false;
+    }
+    let newContent = content;
+    if (!newContent.endsWith("\n") && newContent !== "") {
+      newContent += "\n";
+    }
+    if (newContent === "" || !content.includes("# rrce-workflow")) {
+      newContent += "\n# rrce-workflow generated folders (uncomment to ignore)\n";
+    }
+    newContent += newEntries.map((e) => `# ${e}`).join("\n") + "\n";
+    fs7.writeFileSync(gitignorePath, newContent);
     return true;
-  } catch (error) {
-    note8(
-      `${pc9.red("\u2717")} Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
-      "Error"
-    );
+  } catch {
     return false;
   }
 }
-async function handleShowStatus() {
-  const s = spinner6();
-  s.start("Loading projects...");
-  const config = loadMCPConfig();
-  const projects = scanForProjects();
-  s.stop("Projects loaded");
+
+// 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();
+async function runLinkProjectsFlow(workspacePath, workspaceName) {
+  const projects = scanForProjects({
+    excludeWorkspace: workspaceName,
+    workspacePath
+  });
   if (projects.length === 0) {
-    note8('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
+    outro2(pc4.yellow("No other projects found. Try setting up another project first."));
     return;
   }
-  const lines = [
-    `${pc9.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 ? pc9.green("\u2713 exposed") : pc9.dim("\u25CB hidden");
-    const source = pc9.dim(`(${project.source})`);
-    lines.push(`  ${status}  ${project.name} ${source}`);
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const linkedProjects = await multiselect2({
+    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(
+        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
+      )
+    })),
+    required: true
+  });
+  if (isCancel3(linkedProjects)) {
+    cancel2("Cancelled.");
+    process.exit(0);
   }
-  lines.push("");
-  lines.push(pc9.dim(`Config: ${getMCPConfigPath()}`));
-  const serverStatus = getMCPServerStatus();
-  if (serverStatus.running) {
-    lines.push(pc9.green(`Server: running on port ${serverStatus.port}`));
+  const selectedKeys = linkedProjects;
+  if (selectedKeys.length === 0) {
+    outro2("No projects selected.");
+    return;
+  }
+  const selectedProjects = projects.filter(
+    (p) => selectedKeys.includes(`${p.name}:${p.source}`)
+  );
+  const s = spinner2();
+  s.start("Linking projects");
+  const configFilePath = getConfigPath(workspacePath);
+  let configContent = fs8.readFileSync(configFilePath, "utf-8");
+  if (configContent.includes("linked_projects:")) {
+    const lines = configContent.split("\n");
+    const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
+    if (linkedIndex !== -1) {
+      let insertIndex = linkedIndex + 1;
+      while (insertIndex < lines.length && lines[insertIndex]?.startsWith("  - ")) {
+        insertIndex++;
+      }
+      for (const project of selectedProjects) {
+        const entry = `  - ${project.name}:${project.source}`;
+        if (!configContent.includes(entry)) {
+          lines.splice(insertIndex, 0, entry);
+          insertIndex++;
+        }
+      }
+      configContent = lines.join("\n");
+    }
   } else {
-    lines.push(pc9.dim("Server: not running"));
+    configContent += `
+linked_projects:
+`;
+    selectedProjects.forEach((project) => {
+      configContent += `  - ${project.name}:${project.source}
+`;
+    });
   }
-  note8(lines.join("\n"), "MCP Hub Status");
+  fs8.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})`)}`),
+    ``,
+    `Workspace file: ${pc4.cyan(workspaceFile)}`
+  ];
+  note3(summary.join("\n"), "Link Summary");
+  outro2(pc4.green(`\u2713 Projects linked! Open ${pc4.bold(workspaceFile)} in VSCode to access linked data.`));
 }
-async function handleConfigure() {
-  const s = spinner6();
-  s.start("Scanning for projects...");
-  const config = loadMCPConfig();
-  const projects = scanForProjects();
-  s.stop("Projects found");
-  if (projects.length === 0) {
-    note8('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} ${pc9.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 (isCancel8(selected)) {
+
+// 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";
+async function runSyncToGlobalFlow(workspacePath, workspaceName) {
+  const localPath = getLocalWorkspacePath(workspacePath);
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
+  const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
+  const existingDirs = subdirs.filter(
+    (dir) => fs9.existsSync(path9.join(localPath, dir))
+  );
+  if (existingDirs.length === 0) {
+    outro3(pc5.yellow("No data found in workspace storage to sync."));
     return;
   }
-  const selectedNames = selected;
-  for (const project of projects) {
-    const shouldExpose = selectedNames.includes(project.name);
-    setProjectConfig(config, project.name, shouldExpose);
-  }
-  saveMCPConfig(config);
-  const exposedCount = selectedNames.length;
-  note8(
-    `${pc9.green("\u2713")} Configuration saved!
+  note4(
+    `The following will be copied to global storage:
+${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 
-Exposed projects: ${exposedCount}
-Hidden projects: ${projects.length - exposedCount}`,
-    "Configuration Updated"
+Destination: ${pc5.cyan(globalPath)}`,
+    "Sync Preview"
   );
+  const shouldSync = await confirm2({
+    message: "Proceed with sync to global storage?",
+    initialValue: true
+  });
+  if (isCancel4(shouldSync) || !shouldSync) {
+    outro3("Sync cancelled.");
+    return;
+  }
+  const s = spinner3();
+  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);
+      ensureDir(destDir);
+      copyDirRecursive(srcDir, destDir);
+    }
+    s.stop("Sync complete");
+    const summary = [
+      `Synced directories:`,
+      ...existingDirs.map((d) => `  \u2713 ${d}/`),
+      ``,
+      `Global path: ${pc5.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!"));
+  } catch (error) {
+    s.stop("Error occurred");
+    cancel3(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
 }
-async function handleStartServer() {
-  const s = spinner6();
-  s.start("Starting MCP server...");
+
+// 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";
+async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
+  const s = spinner4();
+  s.start("Checking for updates");
   try {
-    const result = await startMCPServer();
-    s.stop(pc9.green(`MCP server started on port ${result.port}`));
-    note8(
-      `The MCP server is now running.
+    const agentCoreDir = getAgentCoreDir();
+    const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+    const mode = currentStorageMode || "global";
+    const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+    const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
+    s.stop("Updates found");
+    note5(
+      `The following will be updated from the package:
+  \u2022 prompts/ (${prompts.length} agent prompts)
+  \u2022 templates/ (output templates)
 
-To connect from Claude Desktop, add to your config:
-` + pc9.cyan(`~/.config/claude/claude_desktop_config.json`),
-      "Server Started"
+Target locations:
+${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
+      "Update Preview"
     );
+    const shouldUpdate = await confirm3({
+      message: "Proceed with update?",
+      initialValue: true
+    });
+    if (isCancel5(shouldUpdate) || !shouldUpdate) {
+      outro4("Update cancelled.");
+      return;
+    }
+    s.start("Updating from package");
+    for (const dataPath of dataPaths) {
+      copyDirToAllStoragePaths(path10.join(agentCoreDir, "templates"), "templates", [dataPath]);
+    }
+    const configFilePath = getConfigPath(workspacePath);
+    const configContent = fs10.readFileSync(configFilePath, "utf-8");
+    if (configContent.includes("copilot: true")) {
+      const copilotPath = getAgentPromptPath(workspacePath, "copilot");
+      ensureDir(copilotPath);
+      copyPromptsToDir(prompts, copilotPath, ".agent.md");
+    }
+    if (configContent.includes("antigravity: true")) {
+      const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
+      ensureDir(antigravityPath);
+      copyPromptsToDir(prompts, antigravityPath, ".md");
+    }
+    s.stop("Update complete");
+    const summary = [
+      `Updated:`,
+      `  \u2713 ${prompts.length} agent prompts`,
+      `  \u2713 Output templates`,
+      ``,
+      `Your configuration and knowledge files were preserved.`
+    ];
+    note5(summary.join("\n"), "Update Summary");
+    outro4(pc6.green("\u2713 Successfully updated from package!"));
   } catch (error) {
-    s.stop(pc9.red("Failed to start server"));
-    note8(
-      `Error: ${error instanceof Error ? error.message : String(error)}`,
-      "Server Error"
-    );
+    s.stop("Error occurred");
+    cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
   }
 }
-async function handleStopServer() {
-  const status = getMCPServerStatus();
-  if (!status.running) {
-    note8("MCP server is not running.", "Status");
-    return;
-  }
-  const confirmed = await confirm4({
-    message: "Stop the MCP server?",
-    initialValue: true
-  });
-  if (isCancel8(confirmed) || !confirmed) {
-    return;
+function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
+  const globalPath = path10.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
+  switch (mode) {
+    case "global":
+      return [globalPath];
+    case "workspace":
+      return [workspacePath];
+    default:
+      return [globalPath];
   }
-  stopMCPServer();
-  note8(pc9.green("MCP server stopped."), "Server Stopped");
 }
-function showHelp() {
-  const help = `
-${pc9.bold("RRCE MCP Hub")} - Cross-project AI assistant server
-
-${pc9.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.
-
-${pc9.bold("MENU OPTIONS")}
-  ${pc9.cyan("View project status")}   See which projects are exposed
-  ${pc9.cyan("Configure projects")}    Choose which projects to expose
-  ${pc9.cyan("Start MCP server")}      Start the server for AI access
-  ${pc9.cyan("Stop MCP server")}       Stop the running server
 
-${pc9.bold("DIRECT COMMANDS")}
-  ${pc9.dim("rrce-workflow mcp start")}    Start server directly
-  ${pc9.dim("rrce-workflow mcp stop")}     Stop server directly
-  ${pc9.dim("rrce-workflow mcp status")}   Show status directly
-  ${pc9.dim("rrce-workflow mcp help")}     Show this help
-
-${pc9.bold("CLAUDE DESKTOP SETUP")}
-Add to ${pc9.cyan("~/.config/claude/claude_desktop_config.json")}:
-${pc9.dim(`{
-  "mcpServers": {
-    "rrce": {
-      "command": "npx",
-      "args": ["rrce-workflow", "mcp", "start"]
+// src/commands/wizard/index.ts
+async function runWizard() {
+  intro(pc7.cyan(pc7.inverse(" RRCE-Workflow Setup ")));
+  const s = spinner5();
+  s.start("Detecting environment");
+  const workspacePath = detectWorkspaceRoot();
+  const workspaceName = getWorkspaceName(workspacePath);
+  const gitUser = getGitUser();
+  await new Promise((r) => setTimeout(r, 800));
+  s.stop("Environment detected");
+  note6(
+    `Git User:  ${pc7.bold(gitUser || "(not found)")}
+Workspace: ${pc7.bold(workspaceName)}`,
+    "Context"
+  );
+  const detectedProjects = scanForProjects({
+    excludeWorkspace: workspaceName,
+    workspacePath
+  });
+  const configFilePath = getConfigPath(workspacePath);
+  const isAlreadyConfigured = fs11.existsSync(configFilePath);
+  let currentStorageMode = null;
+  if (isAlreadyConfigured) {
+    try {
+      const configContent = fs11.readFileSync(configFilePath, "utf-8");
+      const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
+      currentStorageMode = modeMatch?.[1] ?? null;
+    } catch {
     }
   }
-}`)}
-
-${pc9.bold("RESOURCES EXPOSED")}
-  ${pc9.cyan("rrce://projects")}              List all exposed projects
-  ${pc9.cyan("rrce://projects/{name}/context")}  Get project context
-  ${pc9.cyan("rrce://projects/{name}/tasks")}    Get project tasks
+  const localDataPath = getLocalWorkspacePath(workspacePath);
+  const hasLocalData = fs11.existsSync(localDataPath);
+  if (isAlreadyConfigured) {
+    const menuOptions = [];
+    if (detectedProjects.length > 0) {
+      menuOptions.push({
+        value: "link",
+        label: "Link other project knowledge",
+        hint: `${detectedProjects.length} projects detected (global + sibling)`
+      });
+    }
+    if (currentStorageMode === "workspace" && hasLocalData) {
+      menuOptions.push({
+        value: "sync-global",
+        label: "Sync to global storage",
+        hint: "Share knowledge with other projects"
+      });
+    }
+    menuOptions.push({ value: "update", label: "Update from package", hint: "Get latest prompts & templates" });
+    menuOptions.push({ value: "exit", label: "Exit" });
+    const action = await select3({
+      message: "This workspace is already configured. What would you like to do?",
+      options: menuOptions
+    });
+    if (isCancel6(action) || action === "exit") {
+      outro5("Exited.");
+      process.exit(0);
+    }
+    if (action === "link") {
+      await runLinkProjectsFlow(workspacePath, workspaceName);
+      return;
+    }
+    if (action === "sync-global") {
+      await runSyncToGlobalFlow(workspacePath, workspaceName);
+      return;
+    }
+    if (action === "update") {
+      await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
+      return;
+    }
+  }
+  await runSetupFlow(workspacePath, workspaceName, detectedProjects);
+}
 
-${pc9.bold("PROMPTS (Agent Commands)")}
-  ${pc9.cyan("init")}      Initialize project context
-  ${pc9.cyan("research")}  Research requirements for a task
-  ${pc9.cyan("plan")}      Create execution plan
-  ${pc9.cyan("execute")}   Implement planned work
-  ${pc9.cyan("docs")}      Generate documentation
-  ${pc9.cyan("sync")}      Sync knowledge with codebase
-`;
-  note8(help.trim(), "Help");
+// src/commands/selector.ts
+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 path15 from "path";
+async function runSelector() {
+  const workspaceName = path15.basename(process.cwd());
+  intro3(pc9.cyan(pc9.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  if (prompts.length === 0) {
+    cancel7("No agents found. Run `rrce-workflow` to set up.");
+    process.exit(0);
+  }
+  const selection = await select5({
+    message: "Select an agent:",
+    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 (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;
+  note8(
+    `Use this agent in your IDE by invoking:
+${pc9.bold(pc9.cyan(`@${prompt.frontmatter.name}`))}`,
+    "Agent Selected"
+  );
+  outro7("Done");
 }
 
 // src/index.ts
+init_mcp();
 var command = process.argv[2];
 var subcommand = process.argv[3];
 if (!command || command === "wizard") {