rrce-workflow 0.2.68 → 0.2.69

package/dist/index.js

@@ -1,5 +1,11 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -672,2168 +678,2240 @@ var init_tui_utils = __esm({
   }
 });
 
-// src/commands/wizard/setup-prompts.ts
-import { select as select2, multiselect, confirm, isCancel as isCancel2, cancel } from "@clack/prompts";
-import pc3 from "picocolors";
-async function promptStorageMode() {
-  const result = await 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"
-  });
-  if (isCancel2(result)) {
-    cancel("Setup cancelled.");
-    process.exit(0);
-  }
-  return result;
+// src/mcp/install.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as os from "os";
+function checkInstallStatus(workspacePath) {
+  return {
+    antigravity: checkAntigravityConfig(),
+    claude: checkClaudeConfig(),
+    vscodeGlobal: checkVSCodeGlobalConfig(),
+    vscodeWorkspace: workspacePath ? checkVSCodeWorkspaceConfig(workspacePath) : false,
+    opencode: checkOpenCodeConfig()
+  };
 }
-async function promptTools() {
-  const result = await multiselect({
-    message: "Which AI tools do you use?",
-    options: [
-      { value: "copilot", label: "GitHub Copilot", hint: "VSCode" },
-      { value: "antigravity", label: "Antigravity IDE" }
-    ],
-    required: false
-  });
-  if (isCancel2(result)) {
-    cancel("Setup cancelled.");
-    process.exit(0);
+function checkAntigravityConfig() {
+  if (!fs5.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  try {
+    const content = JSON.parse(fs5.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    return !!content.mcpServers?.["rrce"];
+  } catch {
+    return false;
   }
-  return result;
 }
-async function promptMCPExposure() {
-  const result = await confirm({
-    message: "Expose this project to MCP (AI Agent) server?",
-    initialValue: true
-  });
-  if (isCancel2(result)) {
-    cancel("Setup cancelled.");
-    process.exit(0);
+function checkClaudeConfig() {
+  if (!fs5.existsSync(CLAUDE_CONFIG)) return false;
+  try {
+    const content = JSON.parse(fs5.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    return !!content.mcpServers?.["rrce"];
+  } catch {
+    return false;
   }
-  return result;
 }
-async function promptLinkedProjects(existingProjects) {
-  if (existingProjects.length === 0) {
-    return [];
-  }
-  const result = await multiselect({
-    message: "Link knowledge from other projects?",
-    options: existingProjects.map((project) => ({
-      value: `${project.name}:${project.source}`,
-      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
-      hint: pc3.dim(
-        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
-      )
-    })),
-    required: false
-  });
-  if (isCancel2(result)) {
-    cancel("Setup cancelled.");
-    process.exit(0);
+function checkVSCodeGlobalConfig() {
+  if (!fs5.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  try {
+    const content = JSON.parse(fs5.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    return !!content["mcp.servers"]?.["rrce"];
+  } catch {
+    return false;
   }
-  return result;
 }
-async function promptGitignore() {
-  const result = await confirm({
-    message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
-    initialValue: false
-  });
-  if (isCancel2(result)) {
-    cancel("Setup cancelled.");
-    process.exit(0);
+function checkVSCodeWorkspaceConfig(workspacePath) {
+  const configPath = path6.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs5.existsSync(configPath)) return false;
+  try {
+    const content = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    return !!content.servers?.["rrce"];
+  } catch {
+    return false;
   }
-  return result;
 }
-async function promptRAG() {
-  const result = await confirm({
-    message: `Enable Semantic Search (Local Mini RAG)?
-${pc3.yellow("\u26A0 First use will download a ~100MB model")}`,
-    initialValue: true
-  });
-  if (isCancel2(result)) {
-    cancel("Setup cancelled.");
-    process.exit(0);
+function checkOpenCodeConfig() {
+  if (!fs5.existsSync(OPENCODE_CONFIG)) return false;
+  try {
+    const content = JSON.parse(fs5.readFileSync(OPENCODE_CONFIG, "utf-8"));
+    return !!content.mcp?.["rrce"];
+  } catch {
+    return false;
   }
-  return result;
 }
-async function promptConfirmation() {
-  const result = await confirm({
-    message: "Create configuration?",
-    initialValue: true
-  });
-  if (isCancel2(result)) {
-    cancel("Setup cancelled.");
-    process.exit(0);
+function isInstalledAnywhere(workspacePath) {
+  const status = checkInstallStatus(workspacePath);
+  return status.antigravity || status.claude || status.vscodeGlobal || status.vscodeWorkspace || status.opencode;
+}
+function installToConfig(target, workspacePath) {
+  switch (target) {
+    case "antigravity":
+      return installToAntigravity();
+    case "claude":
+      return installToClaude();
+    case "vscode-global":
+      return installToVSCodeGlobal();
+    case "vscode-workspace":
+      return workspacePath ? installToVSCodeWorkspace(workspacePath) : false;
+    case "opencode":
+      return installToOpenCode();
+    default:
+      return false;
   }
-  return result;
 }
-var init_setup_prompts = __esm({
-  "src/commands/wizard/setup-prompts.ts"() {
-    "use strict";
+function installToAntigravity() {
+  const dir = path6.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
-});
-
-// 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()
-    });
+  let config = { mcpServers: {} };
+  if (fs5.existsSync(ANTIGRAVITY_CONFIG)) {
+    try {
+      config = JSON.parse(fs5.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    } catch {
+    }
   }
-});
-
-// src/lib/prompts.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-function parsePromptFile(filePath) {
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+  };
   try {
-    const fileContent = fs5.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;
+    fs5.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    return true;
+  } catch {
+    return false;
   }
 }
-function loadPromptsFromDir(dirPath) {
-  if (!fs5.existsSync(dirPath)) {
-    return [];
+function installToClaude() {
+  const dir = path6.dirname(CLAUDE_CONFIG);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
-  const files = fs5.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
-  const prompts = [];
-  for (const file of files) {
-    const prompt = parsePromptFile(path6.join(dirPath, file));
-    if (prompt) {
-      prompts.push(prompt);
+  let config = { mcpServers: {} };
+  if (fs5.existsSync(CLAUDE_CONFIG)) {
+    try {
+      config = JSON.parse(fs5.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    } catch {
     }
   }
-  return prompts;
-}
-function getAgentCoreDir() {
-  if (__dirname.includes("/src/") || __dirname.includes("\\src\\")) {
-    if (fs5.existsSync(path6.join(process.cwd(), "agent-core"))) {
-      return path6.join(process.cwd(), "agent-core");
-    }
-    return path6.resolve(__dirname, "../..", "agent-core");
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+  };
+  try {
+    fs5.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    return true;
+  } catch {
+    return false;
   }
-  return path6.join(__dirname, "..", "agent-core");
 }
-function getAgentCorePromptsDir() {
-  return path6.join(getAgentCoreDir(), "prompts");
-}
-var __filename, __dirname;
-var init_prompts = __esm({
-  "src/lib/prompts.ts"() {
-    "use strict";
-    init_prompt();
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path6.dirname(__filename);
-  }
-});
-
-// src/commands/wizard/utils.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
-function copyPromptsToDir(prompts, targetDir, extension) {
-  for (const prompt of prompts) {
-    const baseName = path7.basename(prompt.filePath, ".md");
-    const targetName = baseName + extension;
-    const targetPath = path7.join(targetDir, targetName);
-    const content = fs6.readFileSync(prompt.filePath, "utf-8");
-    fs6.writeFileSync(targetPath, content);
+function installToVSCodeGlobal() {
+  const dir = path6.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
-}
-function copyDirRecursive(src, dest) {
-  const entries = fs6.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path7.join(src, entry.name);
-    const destPath = path7.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs6.copyFileSync(srcPath, destPath);
+  let settings = {};
+  if (fs5.existsSync(VSCODE_GLOBAL_CONFIG)) {
+    try {
+      settings = JSON.parse(fs5.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    } catch {
     }
   }
+  if (!settings["mcp.servers"]) settings["mcp.servers"] = {};
+  settings["mcp.servers"]["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+  };
+  try {
+    fs5.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
 }
-var init_utils = __esm({
-  "src/commands/wizard/utils.ts"() {
-    "use strict";
-    init_paths();
+function installToVSCodeWorkspace(workspacePath) {
+  const vscodeDir = path6.join(workspacePath, ".vscode");
+  const configPath = path6.join(vscodeDir, "mcp.json");
+  if (!fs5.existsSync(vscodeDir)) {
+    fs5.mkdirSync(vscodeDir, { recursive: true });
   }
-});
-
-// src/commands/wizard/vscode.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
-function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
-  const workspaceFilePath = path8.join(workspacePath, `${workspaceName}.code-workspace`);
-  let workspace;
-  if (fs7.existsSync(workspaceFilePath)) {
+  let config = { servers: {} };
+  if (fs5.existsSync(configPath)) {
     try {
-      const content = fs7.readFileSync(workspaceFilePath, "utf-8");
-      workspace = JSON.parse(content);
+      config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
     } catch {
-      workspace = { folders: [], settings: {} };
     }
-  } else {
-    workspace = { folders: [], settings: {} };
   }
-  if (!workspace.settings) {
-    workspace.settings = {};
+  if (!config.servers) config.servers = {};
+  config.servers["rrce"] = {
+    command: "npx",
+    args: ["-y", "rrce-workflow", "mcp", "start"]
+  };
+  try {
+    fs5.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return true;
+  } catch {
+    return false;
   }
-  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)`
-    };
+}
+function installToOpenCode() {
+  const dir = path6.dirname(OPENCODE_CONFIG);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
-  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 (fs7.existsSync(folderPath)) {
-        referenceFolderPaths.push(folderPath);
-        workspace.folders.push({
-          path: folderPath,
-          name: `\u{1F4C1} ${project.name} [${sourceLabel}]`
-        });
-      }
-    }
-  } else {
-    const projectNames = linkedProjects;
-    const rrceHome = customGlobalPath || getRRCEHome();
-    for (const projectName of projectNames) {
-      const folderPath = path8.join(rrceHome, "workspaces", projectName);
-      if (fs7.existsSync(folderPath)) {
-        referenceFolderPaths.push(folderPath);
-        workspace.folders.push({
-          path: folderPath,
-          name: `\u{1F4C1} ${projectName} [global]`
-        });
-      }
+  let config = {
+    $schema: "https://opencode.ai/config.json"
+  };
+  if (fs5.existsSync(OPENCODE_CONFIG)) {
+    try {
+      config = JSON.parse(fs5.readFileSync(OPENCODE_CONFIG, "utf-8"));
+    } catch (error) {
+      console.error("Warning: Could not parse existing OpenCode config, creating fresh config");
     }
   }
-  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
-    };
+  if (!config.mcp) config.mcp = {};
+  config.mcp["rrce"] = {
+    type: "local",
+    command: ["npx", "-y", "rrce-workflow", "mcp", "start"],
+    enabled: true
+  };
+  try {
+    fs5.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.error("Failed to write OpenCode config:", error instanceof Error ? error.message : String(error));
+    return false;
   }
-  fs7.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
-var init_vscode = __esm({
-  "src/commands/wizard/vscode.ts"() {
-    "use strict";
-    init_paths();
-    init_detection();
-  }
-});
-
-// 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
-    };
+function uninstallFromOpenCode() {
+  if (!fs5.existsSync(OPENCODE_CONFIG)) {
+    console.error("OpenCode config not found");
+    return false;
   }
-});
-
-// src/mcp/config-utils.ts
-function findProjectConfig(config, identifier) {
-  return config.projects.find((p) => {
-    if (identifier.path && p.path) {
-      return p.path === identifier.path;
-    }
-    if (!identifier.path && !p.path) {
-      return p.name === identifier.name;
-    }
-    if (identifier.path && !p.path) {
-      return p.name === identifier.name;
+  try {
+    const config = JSON.parse(fs5.readFileSync(OPENCODE_CONFIG, "utf-8"));
+    if (!config.mcp?.["rrce"]) {
+      console.warn("RRCE not found in OpenCode config");
+      return false;
     }
+    delete config.mcp["rrce"];
+    fs5.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.error("Failed to uninstall from OpenCode:", error instanceof Error ? error.message : String(error));
     return false;
-  });
-}
-var init_config_utils = __esm({
-  "src/mcp/config-utils.ts"() {
-    "use strict";
   }
-});
-
-// src/mcp/config.ts
-var config_exports = {};
-__export(config_exports, {
-  cleanStaleProjects: () => cleanStaleProjects,
-  ensureMCPGlobalPath: () => ensureMCPGlobalPath,
-  getMCPConfigPath: () => getMCPConfigPath,
-  getProjectPermissions: () => getProjectPermissions,
-  isProjectExposed: () => isProjectExposed,
-  loadMCPConfig: () => loadMCPConfig,
-  removeProjectConfig: () => removeProjectConfig,
-  saveMCPConfig: () => saveMCPConfig,
-  setProjectConfig: () => setProjectConfig
-});
-import * as fs8 from "fs";
-import * as path9 from "path";
-import YAML from "yaml";
-function getMCPConfigPath() {
-  const workspaceRoot = detectWorkspaceRoot();
-  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path9.join(rrceHome, "mcp.yaml");
 }
-function ensureMCPGlobalPath() {
-  const workspaceRoot = detectWorkspaceRoot();
-  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  if (rrceHome.startsWith(".") || rrceHome.includes(".rrce-workflow/")) {
-    const configPath = path9.join(workspaceRoot, ".rrce-workflow", "config.yaml");
-    if (fs8.existsSync(configPath)) {
-      const content = fs8.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."
-        };
-      }
+function uninstallFromAntigravity() {
+  if (!fs5.existsSync(ANTIGRAVITY_CONFIG)) {
+    console.error("Antigravity config not found");
+    return false;
+  }
+  try {
+    const config = JSON.parse(fs5.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    if (!config.mcpServers?.["rrce"]) {
+      console.warn("RRCE not found in Antigravity config");
+      return false;
     }
+    delete config.mcpServers["rrce"];
+    fs5.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.error("Failed to uninstall from Antigravity:", error instanceof Error ? error.message : String(error));
+    return false;
   }
-  return {
-    configured: true,
-    path: rrceHome
-  };
 }
-function loadMCPConfig() {
-  const configPath = getMCPConfigPath();
-  if (!fs8.existsSync(configPath)) {
-    return { ...DEFAULT_MCP_CONFIG };
+function uninstallFromClaude() {
+  if (!fs5.existsSync(CLAUDE_CONFIG)) {
+    console.error("Claude Desktop config not found");
+    return false;
   }
   try {
-    const content = fs8.readFileSync(configPath, "utf-8");
-    return parseMCPConfig(content);
-  } catch {
-    return { ...DEFAULT_MCP_CONFIG };
+    const config = JSON.parse(fs5.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    if (!config.mcpServers?.["rrce"]) {
+      console.warn("RRCE not found in Claude Desktop config");
+      return false;
+    }
+    delete config.mcpServers["rrce"];
+    fs5.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.error("Failed to uninstall from Claude Desktop:", error instanceof Error ? error.message : String(error));
+    return false;
   }
 }
-function saveMCPConfig(config) {
-  const configPath = getMCPConfigPath();
-  const dir = path9.dirname(configPath);
-  if (!fs8.existsSync(dir)) {
-    fs8.mkdirSync(dir, { recursive: true });
+function uninstallFromVSCodeGlobal() {
+  if (!fs5.existsSync(VSCODE_GLOBAL_CONFIG)) {
+    console.error("VSCode global config not found");
+    return false;
   }
-  const content = serializeMCPConfig(config);
-  fs8.writeFileSync(configPath, content);
-}
-function parseMCPConfig(content) {
   try {
-    const parsed = YAML.parse(content);
-    const config = {
-      server: {
-        port: parsed?.server?.port ?? DEFAULT_MCP_CONFIG.server.port,
-        autoStart: parsed?.server?.autoStart ?? DEFAULT_MCP_CONFIG.server.autoStart
-      },
-      defaults: {
-        includeNew: parsed?.defaults?.includeNew ?? DEFAULT_MCP_CONFIG.defaults.includeNew,
-        permissions: {
-          knowledge: parsed?.defaults?.permissions?.knowledge ?? DEFAULT_PERMISSIONS.knowledge,
-          tasks: parsed?.defaults?.permissions?.tasks ?? DEFAULT_PERMISSIONS.tasks,
-          refs: parsed?.defaults?.permissions?.refs ?? DEFAULT_PERMISSIONS.refs
-        }
-      },
-      projects: Array.isArray(parsed?.projects) ? parsed.projects.map((p) => ({
-        name: p.name || "",
-        path: p.path,
-        expose: p.expose ?? true,
-        permissions: {
-          knowledge: p.permissions?.knowledge ?? DEFAULT_PERMISSIONS.knowledge,
-          tasks: p.permissions?.tasks ?? DEFAULT_PERMISSIONS.tasks,
-          refs: p.permissions?.refs ?? DEFAULT_PERMISSIONS.refs
-        },
-        semanticSearch: p.semanticSearch
-      })) : []
-    };
-    return config;
-  } catch (err) {
-    return { ...DEFAULT_MCP_CONFIG };
+    const settings = JSON.parse(fs5.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    if (!settings["mcp.servers"]?.["rrce"]) {
+      console.warn("RRCE not found in VSCode global settings");
+      return false;
+    }
+    delete settings["mcp.servers"]["rrce"];
+    fs5.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.error("Failed to uninstall from VSCode (Global):", error instanceof Error ? error.message : String(error));
+    return false;
   }
 }
-function serializeMCPConfig(config) {
-  const header = `# RRCE MCP Hub Configuration
-# Manages which projects are exposed via MCP
-
-`;
-  return header + YAML.stringify(config, {
-    indent: 2,
-    lineWidth: 0
-    // No line wrapping
-  });
-}
-function setProjectConfig(config, name, expose, permissions, projectPath, semanticSearch) {
-  const existing = findProjectConfig(config, { name, path: projectPath });
-  if (existing) {
-    existing.expose = expose;
-    if (projectPath && !existing.path) {
-      existing.path = projectPath;
-    }
-    if (permissions) {
-      existing.permissions = { ...existing.permissions, ...permissions };
-    }
-    if (semanticSearch) {
-      existing.semanticSearch = semanticSearch;
+function uninstallFromVSCodeWorkspace(workspacePath) {
+  const configPath = path6.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs5.existsSync(configPath)) {
+    console.error("VSCode workspace config not found");
+    return false;
+  }
+  try {
+    const config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    if (!config.servers?.["rrce"]) {
+      console.warn("RRCE not found in VSCode workspace config");
+      return false;
     }
-  } else {
-    config.projects.push({
-      name,
-      path: projectPath,
-      expose,
-      permissions: permissions ? { ...DEFAULT_PERMISSIONS, ...permissions } : { ...DEFAULT_PERMISSIONS },
-      semanticSearch
-    });
+    delete config.servers["rrce"];
+    fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    return true;
+  } catch (error) {
+    console.error("Failed to uninstall from VSCode (Workspace):", error instanceof Error ? error.message : String(error));
+    return false;
   }
-  return config;
 }
-function removeProjectConfig(config, name) {
-  config.projects = config.projects.filter((p) => p.name !== name);
-  return config;
+function uninstallFromConfig(target, workspacePath) {
+  switch (target) {
+    case "antigravity":
+      return uninstallFromAntigravity();
+    case "claude":
+      return uninstallFromClaude();
+    case "vscode-global":
+      return uninstallFromVSCodeGlobal();
+    case "vscode-workspace":
+      return workspacePath ? uninstallFromVSCodeWorkspace(workspacePath) : false;
+    case "opencode":
+      return uninstallFromOpenCode();
+    default:
+      return false;
+  }
 }
-function isProjectExposed(config, name, projectPath) {
-  const project = findProjectConfig(config, { name, path: projectPath });
-  if (project) {
-    return project.expose;
+function getTargetLabel(target) {
+  switch (target) {
+    case "antigravity":
+      return "Antigravity IDE";
+    case "claude":
+      return "Claude Desktop";
+    case "vscode-global":
+      return "VSCode (Global)";
+    case "vscode-workspace":
+      return "VSCode (Workspace)";
+    case "opencode":
+      return "OpenCode";
+    default:
+      return target;
   }
-  return config.defaults.includeNew;
 }
-function getProjectPermissions(config, name, projectPath) {
-  const project = findProjectConfig(config, { name, path: projectPath });
-  return project?.permissions ?? config.defaults.permissions;
+function isOpenCodeInstalled() {
+  const configDir = path6.join(os.homedir(), ".config/opencode");
+  const configFile = path6.join(configDir, "opencode.json");
+  return fs5.existsSync(configDir) || fs5.existsSync(configFile);
 }
-function cleanStaleProjects(config) {
-  const rrceHome = getEffectiveGlobalPath();
-  const globalWorkspacesDir = path9.join(rrceHome, "workspaces");
-  const validProjects = [];
-  const removed = [];
-  for (const project of config.projects) {
-    let exists = false;
-    if (project.path) {
-      exists = fs8.existsSync(project.path);
-    } else {
-      const globalPath = path9.join(globalWorkspacesDir, project.name);
-      exists = fs8.existsSync(globalPath);
-    }
-    if (exists) {
-      validProjects.push(project);
-    } else {
-      removed.push(project.name);
-    }
-  }
-  if (removed.length > 0) {
-    config.projects = validProjects;
-  }
-  return { config, removed };
+function isAntigravityInstalled() {
+  const configDir = path6.join(os.homedir(), ".gemini/antigravity");
+  return fs5.existsSync(configDir);
 }
-var init_config = __esm({
-  "src/mcp/config.ts"() {
+function isVSCodeInstalled() {
+  const configDir = path6.join(os.homedir(), ".config/Code/User");
+  return fs5.existsSync(configDir);
+}
+var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG, OPENCODE_CONFIG;
+var init_install = __esm({
+  "src/mcp/install.ts"() {
     "use strict";
-    init_paths();
-    init_types();
-    init_config_utils();
+    ANTIGRAVITY_CONFIG = path6.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path6.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path6.join(os.homedir(), ".config/Code/User/settings.json");
+    OPENCODE_CONFIG = path6.join(os.homedir(), ".config/opencode/opencode.json");
   }
 });
 
-// src/commands/wizard/setup-actions.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
-import pc4 from "picocolors";
-import { note as note2 } from "@clack/prompts";
-function createDirectoryStructure(dataPaths) {
-  for (const dataPath of dataPaths) {
-    ensureDir(dataPath);
-    ensureDir(path10.join(dataPath, "knowledge"));
-    ensureDir(path10.join(dataPath, "refs"));
-    ensureDir(path10.join(dataPath, "tasks"));
-    ensureDir(path10.join(dataPath, "templates"));
-  }
-}
-function installAgentPrompts(config, workspacePath, dataPaths) {
-  const agentCoreDir = getAgentCoreDir();
-  syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path10.join(agentCoreDir, "templates"), "templates", dataPaths);
-  copyDirToAllStoragePaths(path10.join(agentCoreDir, "prompts"), "prompts", dataPaths);
-  if (config.storageMode === "workspace") {
-    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");
-    }
+// src/commands/wizard/setup-prompts.ts
+import { select as select2, multiselect, confirm, isCancel as isCancel2, cancel } from "@clack/prompts";
+import pc3 from "picocolors";
+async function promptStorageMode() {
+  const result = await 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"
+  });
+  if (isCancel2(result)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
   }
+  return result;
 }
-function createWorkspaceConfig(config, workspacePath, workspaceName) {
-  let configPath;
-  if (config.storageMode === "global") {
-    const rrceHome = config.globalPath || getDefaultRRCEHome2();
-    configPath = path10.join(rrceHome, "workspaces", workspaceName, "config.yaml");
-  } else {
-    configPath = path10.join(workspacePath, ".rrce-workflow", "config.yaml");
+async function promptTools() {
+  const options = [];
+  if (isOpenCodeInstalled()) {
+    options.push({ value: "opencode", label: "OpenCode" });
   }
-  ensureDir(path10.dirname(configPath));
-  let content = `# RRCE-Workflow Configuration
-version: 1
-
-storage:
-  mode: ${config.storageMode}`;
-  if (config.globalPath && config.globalPath !== getDefaultRRCEHome2()) {
-    content += `
-  globalPath: "${config.globalPath}"`;
+  if (isVSCodeInstalled()) {
+    options.push({ value: "copilot", label: "GitHub Copilot", hint: "VSCode" });
   }
-  content += `
-
-project:
-  name: "${workspaceName}"
-  sourcePath: "${workspacePath}"
-
-tools:
-  copilot: ${config.storageMode === "workspace" && config.tools.includes("copilot")}
-  antigravity: ${config.storageMode === "workspace" && config.tools.includes("antigravity")}
-`;
-  if (config.enableRAG) {
-    content += `
-semantic_search:
-  enabled: true
-`;
+  if (isAntigravityInstalled()) {
+    options.push({ value: "antigravity", label: "Antigravity IDE" });
   }
-  if (config.linkedProjects.length > 0) {
-    content += `
-linked_projects:
-`;
-    config.linkedProjects.forEach((name) => {
-      content += `  - ${name}
-`;
-    });
+  if (options.length === 0) {
+    options.push({ value: "none", label: "No supported IDEs detected", hint: "Skip" });
   }
-  fs9.writeFileSync(configPath, content);
-}
-async function registerWithMCP(config, workspacePath, workspaceName) {
-  if (!config.exposeToMCP) return;
-  try {
-    const { loadMCPConfig: loadMCPConfig3, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const mcpConfig = loadMCPConfig3();
-    setProjectConfig2(
-      mcpConfig,
-      workspaceName,
-      true,
-      void 0,
-      workspacePath,
-      config.enableRAG ? { enabled: true } : void 0
-    );
-    saveMCPConfig2(mcpConfig);
-  } catch (e) {
-    note2(
-      `${pc4.yellow("\u26A0")} Could not register project with MCP
-Error: ${e instanceof Error ? e.message : String(e)}
-
-You can configure MCP later: ${pc4.cyan("npx rrce-workflow mcp")}`,
-      "MCP Registration Warning"
-    );
+  const result = await multiselect({
+    message: "Which AI tools do you use?",
+    options,
+    required: false
+  });
+  if (isCancel2(result)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
   }
+  return result.filter((t) => t !== "none");
 }
-function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path10.join(customGlobalPath || getDefaultRRCEHome2(), "workspaces", workspaceName);
-  const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
-  switch (mode) {
-    case "global":
-      return [globalPath];
-    case "workspace":
-      return [workspacePath];
-    default:
-      return [globalPath];
+async function promptMCPExposure() {
+  const result = await confirm({
+    message: "Expose this project to MCP (AI Agent) server?",
+    initialValue: true
+  });
+  if (isCancel2(result)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
   }
+  return result;
 }
-var init_setup_actions = __esm({
-  "src/commands/wizard/setup-actions.ts"() {
+async function promptLinkedProjects(existingProjects) {
+  if (existingProjects.length === 0) {
+    return [];
+  }
+  const result = await multiselect({
+    message: "Link knowledge from other projects?",
+    options: existingProjects.map((project) => ({
+      value: `${project.name}:${project.source}`,
+      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
+      hint: pc3.dim(
+        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
+      )
+    })),
+    required: false
+  });
+  if (isCancel2(result)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return result;
+}
+async function promptGitignore() {
+  const result = await confirm({
+    message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
+    initialValue: false
+  });
+  if (isCancel2(result)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return result;
+}
+async function promptRAG() {
+  const result = await confirm({
+    message: `Enable Semantic Search (Local Mini RAG)?
+${pc3.yellow("\u26A0 First use will download a ~100MB model")}`,
+    initialValue: true
+  });
+  if (isCancel2(result)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return result;
+}
+async function promptConfirmation() {
+  const result = await confirm({
+    message: "Create configuration?",
+    initialValue: true
+  });
+  if (isCancel2(result)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return result;
+}
+var init_setup_prompts = __esm({
+  "src/commands/wizard/setup-prompts.ts"() {
     "use strict";
-    init_paths();
-    init_prompts();
-    init_utils();
-    init_vscode();
+    init_install();
   }
 });
 
-// src/commands/wizard/gitignore.ts
-var gitignore_exports = {};
-__export(gitignore_exports, {
-  updateGitignore: () => updateGitignore
-});
-import * as fs10 from "fs";
-import * as path11 from "path";
-function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path11.join(workspacePath, ".gitignore");
-  const entries = [];
-  if (storageMode === "workspace") {
-    entries.push(".rrce-workflow/");
-  }
-  if (tools.includes("copilot")) {
-    entries.push(".github/agents/");
+// 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()
+    });
   }
-  if (tools.includes("antigravity")) {
-    entries.push(".agent/workflows/");
+});
+
+// src/lib/prompts.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+function parsePromptFile(filePath) {
+  try {
+    const fileContent = fs6.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;
   }
-  entries.push("*.code-workspace");
-  if (entries.length === 0) {
-    return false;
+}
+function loadPromptsFromDir(dirPath) {
+  if (!fs6.existsSync(dirPath)) {
+    return [];
   }
-  let existingContent = "";
-  if (fs10.existsSync(gitignorePath)) {
-    existingContent = fs10.readFileSync(gitignorePath, "utf-8");
+  const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
+  const prompts = [];
+  for (const file of files) {
+    const prompt = parsePromptFile(path7.join(dirPath, file));
+    if (prompt) {
+      prompts.push(prompt);
+    }
   }
-  const sectionMarker = "# RRCE-Workflow Generated";
-  if (existingContent.includes(sectionMarker)) {
-    return false;
+  return prompts;
+}
+function getAgentCoreDir() {
+  if (__dirname.includes("/src/") || __dirname.includes("\\src\\")) {
+    if (fs6.existsSync(path7.join(process.cwd(), "agent-core"))) {
+      return path7.join(process.cwd(), "agent-core");
+    }
+    return path7.resolve(__dirname, "../..", "agent-core");
   }
-  const newSection = `
-${sectionMarker}
-# Uncomment the following lines if you want to ignore rrce-workflow generated files:
-${entries.map((e) => `# ${e}`).join("\n")}
-`;
-  const updatedContent = existingContent.trimEnd() + newSection;
-  fs10.writeFileSync(gitignorePath, updatedContent);
-  return true;
+  return path7.join(__dirname, "..", "agent-core");
 }
-var init_gitignore = __esm({
-  "src/commands/wizard/gitignore.ts"() {
+function getAgentCorePromptsDir() {
+  return path7.join(getAgentCoreDir(), "prompts");
+}
+var __filename, __dirname;
+var init_prompts = __esm({
+  "src/lib/prompts.ts"() {
     "use strict";
+    init_prompt();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path7.dirname(__filename);
   }
 });
 
-// src/mcp/logger.ts
-import * as fs11 from "fs";
-import * as path12 from "path";
-function getLogFilePath() {
-  const workspaceRoot = detectWorkspaceRoot();
-  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path12.join(rrceHome, "mcp-server.log");
+// src/commands/wizard/utils.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+function copyPromptsToDir(prompts, targetDir, extension) {
+  for (const prompt of prompts) {
+    const baseName = path8.basename(prompt.filePath, ".md");
+    const targetName = baseName + extension;
+    const targetPath = path8.join(targetDir, targetName);
+    const content = fs7.readFileSync(prompt.filePath, "utf-8");
+    fs7.writeFileSync(targetPath, content);
+  }
 }
-var Logger, logger;
-var init_logger = __esm({
-  "src/mcp/logger.ts"() {
+function copyDirRecursive(src, dest) {
+  const entries = fs7.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path8.join(src, entry.name);
+    const destPath = path8.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      ensureDir(destPath);
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs7.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+var init_utils = __esm({
+  "src/commands/wizard/utils.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 (!fs11.existsSync(dir)) {
-            fs11.mkdirSync(dir, { recursive: true });
-          }
-          fs11.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/services/rag.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
-var INDEX_VERSION, DEFAULT_MODEL, RAGService;
-var init_rag = __esm({
-  "src/mcp/services/rag.ts"() {
-    "use strict";
-    init_logger();
-    INDEX_VERSION = "1.0.0";
-    DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
-    RAGService = class _RAGService {
-      // Static cache for the pipeline to prevent reloading model for every instance
-      static pipelineInstance = null;
-      static activeModelName = null;
-      static loadPromise = null;
-      modelName;
-      indexPath;
-      index = null;
-      constructor(indexPath, modelName = DEFAULT_MODEL) {
-        this.indexPath = indexPath;
-        this.modelName = modelName;
-      }
-      /**
-       * Lazy load the model (Singleton pattern)
-       */
-      async getPipeline() {
-        if (_RAGService.activeModelName === this.modelName && _RAGService.pipelineInstance) {
-          return _RAGService.pipelineInstance;
-        }
-        if (_RAGService.activeModelName === this.modelName && _RAGService.loadPromise) {
-          return _RAGService.loadPromise;
-        }
-        logger.info(`RAG: Initializing model ${this.modelName}...`);
-        _RAGService.activeModelName = this.modelName;
-        _RAGService.loadPromise = (async () => {
-          try {
-            const { pipeline } = await import("@xenova/transformers");
-            const pipe = await pipeline("feature-extraction", this.modelName);
-            _RAGService.pipelineInstance = pipe;
-            logger.info(`RAG: Model ${this.modelName} initialized successfully.`);
-            return pipe;
-          } catch (error) {
-            logger.error(`RAG: Failed to initialize model ${this.modelName}`, error);
-            _RAGService.pipelineInstance = null;
-            _RAGService.activeModelName = null;
-            _RAGService.loadPromise = null;
-            throw error;
-          }
-        })();
-        return _RAGService.loadPromise;
-      }
-      /**
-       * Load index from disk
-       */
-      loadIndex() {
-        if (this.index) return;
-        if (fs12.existsSync(this.indexPath)) {
-          try {
-            const data = fs12.readFileSync(this.indexPath, "utf-8");
-            this.index = JSON.parse(data);
-            logger.info(`RAG: Loaded index from ${this.indexPath} with ${this.index?.chunks.length} chunks.`);
-          } catch (error) {
-            logger.error(`RAG: Failed to load index from ${this.indexPath}`, error);
-            this.index = {
-              version: INDEX_VERSION,
-              baseModel: this.modelName,
-              chunks: []
-            };
-          }
-        } else {
-          this.index = {
-            version: INDEX_VERSION,
-            baseModel: this.modelName,
-            chunks: []
-          };
-          logger.info(`RAG: Created new empty index at ${this.indexPath}`);
-        }
-      }
-      /**
-       * Save index to disk
-       */
-      saveIndex() {
-        if (!this.index) return;
-        try {
-          const dir = path13.dirname(this.indexPath);
-          if (!fs12.existsSync(dir)) {
-            fs12.mkdirSync(dir, { recursive: true });
-          }
-          fs12.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
-          logger.info(`RAG: Saved index to ${this.indexPath} with ${this.index.chunks.length} chunks.`);
-        } catch (error) {
-          logger.error(`RAG: Failed to save index to ${this.indexPath}`, error);
-        }
+// src/commands/wizard/vscode.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
+  const workspaceFilePath = path9.join(workspacePath, `${workspaceName}.code-workspace`);
+  let workspace;
+  if (fs8.existsSync(workspaceFilePath)) {
+    try {
+      const content = fs8.readFileSync(workspaceFilePath, "utf-8");
+      workspace = JSON.parse(content);
+    } catch {
+      workspace = { folders: [], settings: {} };
+    }
+  } else {
+    workspace = { folders: [], settings: {} };
+  }
+  if (!workspace.settings) {
+    workspace.settings = {};
+  }
+  workspace.folders = workspace.folders.filter(
+    (f) => f.path === "." || !f.name?.startsWith("\u{1F4C1}") && !f.name?.startsWith("\u{1F4DA}") && !f.name?.startsWith("\u{1F4CE}") && !f.name?.startsWith("\u{1F4CB}")
+  );
+  const mainFolderIndex = workspace.folders.findIndex((f) => f.path === ".");
+  if (mainFolderIndex === -1) {
+    workspace.folders.unshift({
+      path: ".",
+      name: `\u{1F3E0} ${workspaceName} (workspace)`
+    });
+  } else {
+    workspace.folders[mainFolderIndex] = {
+      path: ".",
+      name: `\u{1F3E0} ${workspaceName} (workspace)`
+    };
+  }
+  const referenceFolderPaths = [];
+  const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === "object";
+  if (isDetectedProjects) {
+    const projects = linkedProjects;
+    for (const project of projects) {
+      const sourceLabel = project.source === "global" ? "global" : "local";
+      const folderPath = project.dataPath;
+      if (fs8.existsSync(folderPath)) {
+        referenceFolderPaths.push(folderPath);
+        workspace.folders.push({
+          path: folderPath,
+          name: `\u{1F4C1} ${project.name} [${sourceLabel}]`
+        });
       }
-      /**
-       * Generate embedding for text
-       */
-      async generateEmbedding(text2) {
-        const pipe = await this.getPipeline();
-        try {
-          const output = await pipe(text2, { pooling: "mean", normalize: true });
-          return Array.from(output.data);
-        } catch (error) {
-          logger.error("RAG: Error generating embedding", error);
-          throw error;
-        }
+    }
+  } else {
+    const projectNames = linkedProjects;
+    const rrceHome = customGlobalPath || getRRCEHome();
+    for (const projectName of projectNames) {
+      const folderPath = path9.join(rrceHome, "workspaces", projectName);
+      if (fs8.existsSync(folderPath)) {
+        referenceFolderPaths.push(folderPath);
+        workspace.folders.push({
+          path: folderPath,
+          name: `\u{1F4C1} ${projectName} [global]`
+        });
       }
-      /**
-       * Index a file (smart: skips if mtime unchanged)
-       * @param filePath Absolute path to the file
-       * @param content File content
-       * @param mtime Optional modification time (if not provided, always re-indexes)
-       * @returns true if file was indexed, false if skipped
-       */
-      async indexFile(filePath, content, mtime) {
-        this.loadIndex();
-        if (!this.index) throw new Error("Index not initialized");
-        if (!this.index.fileMetadata) {
-          this.index.fileMetadata = {};
-        }
-        if (mtime !== void 0 && this.index.fileMetadata[filePath]) {
-          const existingMeta = this.index.fileMetadata[filePath];
-          if (existingMeta.mtime === mtime) {
-            logger.debug(`RAG: Skipping unchanged file ${filePath}`);
-            return false;
-          }
-        }
-        logger.info(`RAG: Indexing file ${filePath}`);
-        this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
-        const chunks = this.chunkContent(content);
-        for (const chunkText of chunks) {
-          const embedding = await this.generateEmbedding(chunkText);
-          this.index.chunks.push({
-            id: `${filePath}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-            filePath,
-            content: chunkText,
-            embedding,
-            mtime
-          });
-        }
-        this.index.fileMetadata[filePath] = {
-          mtime: mtime ?? Date.now(),
-          chunkCount: chunks.length
-        };
-        this.saveIndex();
-        return true;
+    }
+  }
+  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;
       }
-      /**
-       * Remove a file from index
-       */
-      async removeFile(filePath) {
-        this.loadIndex();
-        if (!this.index) return;
-        const initialCount = this.index.chunks.length;
-        this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
-        if (this.index.fileMetadata) {
-          delete this.index.fileMetadata[filePath];
-        }
-        if (this.index.chunks.length !== initialCount) {
-          logger.info(`RAG: Removed file ${filePath} from index (${initialCount - this.index.chunks.length} chunks removed)`);
-          this.saveIndex();
+    }
+    workspace.settings["files.readonlyInclude"] = {
+      ...cleanedReadonly,
+      ...readonlyPatterns
+    };
+  }
+  fs8.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
+}
+var init_vscode = __esm({
+  "src/commands/wizard/vscode.ts"() {
+    "use strict";
+    init_paths();
+    init_detection();
+  }
+});
+
+// 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
         }
       }
-      /**
-       * Get index statistics
-       */
-      getStats() {
-        this.loadIndex();
-        if (!this.index) return { totalChunks: 0, totalFiles: 0 };
-        const fileCount = this.index.fileMetadata ? Object.keys(this.index.fileMetadata).length : 0;
+    };
+    DEFAULT_PERMISSIONS = {
+      knowledge: true,
+      tasks: true,
+      refs: true
+    };
+  }
+});
+
+// src/mcp/config-utils.ts
+function findProjectConfig(config, identifier) {
+  return config.projects.find((p) => {
+    if (identifier.path && p.path) {
+      return p.path === identifier.path;
+    }
+    if (!identifier.path && !p.path) {
+      return p.name === identifier.name;
+    }
+    if (identifier.path && !p.path) {
+      return p.name === identifier.name;
+    }
+    return false;
+  });
+}
+var init_config_utils = __esm({
+  "src/mcp/config-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/config.ts
+var config_exports = {};
+__export(config_exports, {
+  cleanStaleProjects: () => cleanStaleProjects,
+  ensureMCPGlobalPath: () => ensureMCPGlobalPath,
+  getMCPConfigPath: () => getMCPConfigPath,
+  getProjectPermissions: () => getProjectPermissions,
+  isProjectExposed: () => isProjectExposed,
+  loadMCPConfig: () => loadMCPConfig,
+  removeProjectConfig: () => removeProjectConfig,
+  saveMCPConfig: () => saveMCPConfig,
+  setProjectConfig: () => setProjectConfig
+});
+import * as fs9 from "fs";
+import * as path10 from "path";
+import YAML from "yaml";
+function getMCPConfigPath() {
+  const workspaceRoot = detectWorkspaceRoot();
+  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
+  return path10.join(rrceHome, "mcp.yaml");
+}
+function ensureMCPGlobalPath() {
+  const workspaceRoot = detectWorkspaceRoot();
+  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
+  if (rrceHome.startsWith(".") || rrceHome.includes(".rrce-workflow/")) {
+    const configPath = path10.join(workspaceRoot, ".rrce-workflow", "config.yaml");
+    if (fs9.existsSync(configPath)) {
+      const content = fs9.readFileSync(configPath, "utf-8");
+      const modeMatch = content.match(/mode:\s*(global|workspace)/);
+      if (modeMatch?.[1] === "workspace") {
         return {
-          totalChunks: this.index.chunks.length,
-          totalFiles: fileCount,
-          lastFullIndex: this.index.lastFullIndex
+          configured: false,
+          path: rrceHome,
+          reason: "Workspace mode configured. MCP requires a global storage path."
         };
       }
-      /**
-       * Mark the last full index timestamp
-       */
-      markFullIndex() {
-        this.loadIndex();
-        if (!this.index) return;
-        this.index.lastFullIndex = Date.now();
-        this.saveIndex();
-      }
-      /**
-       * Search the index
-       */
-      async search(query, limit = 5) {
-        this.loadIndex();
-        if (!this.index || this.index.chunks.length === 0) {
-          logger.warn("RAG: Search called on empty index");
-          return [];
-        }
-        logger.info(`RAG: Searching for "${query}" (limit: ${limit})`);
-        const queryEmbedding = await this.generateEmbedding(query);
-        const results = this.index.chunks.map((chunk) => {
-          const score = this.cosineSimilarity(queryEmbedding, chunk.embedding);
-          return { ...chunk, score };
-        });
-        results.sort((a, b) => b.score - a.score);
-        const topResults = results.slice(0, limit);
-        logger.info(`RAG: Search returned ${topResults.length} matches. Top score: ${topResults[0]?.score.toFixed(4)}`);
-        return topResults;
-      }
-      /**
-       * Simple cosine similarity
-       */
-      cosineSimilarity(a, b) {
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-          dotProduct += a[i] * b[i];
-          normA += a[i] * a[i];
-          normB += b[i] * b[i];
-        }
-        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-      }
-      /**
-       * Basic content chunker
-       */
-      chunkContent(content, maxChunkSize = 1e3, overlap = 100) {
-        const chunks = [];
-        let start = 0;
-        while (start < content.length) {
-          let end = start + maxChunkSize;
-          if (end >= content.length) {
-            end = content.length;
-          } else {
-            const lastNewline = content.lastIndexOf("\n", end);
-            if (lastNewline > start + maxChunkSize / 2) {
-              end = lastNewline;
-            }
-          }
-          const chunk = content.substring(start, end).trim();
-          if (chunk.length > 50) {
-            chunks.push(chunk);
-          }
-          if (end === content.length) break;
-          start = end - overlap;
+    }
+  }
+  return {
+    configured: true,
+    path: rrceHome
+  };
+}
+function loadMCPConfig() {
+  const configPath = getMCPConfigPath();
+  if (!fs9.existsSync(configPath)) {
+    return { ...DEFAULT_MCP_CONFIG };
+  }
+  try {
+    const content = fs9.readFileSync(configPath, "utf-8");
+    return parseMCPConfig(content);
+  } catch {
+    return { ...DEFAULT_MCP_CONFIG };
+  }
+}
+function saveMCPConfig(config) {
+  const configPath = getMCPConfigPath();
+  const dir = path10.dirname(configPath);
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
+  }
+  const content = serializeMCPConfig(config);
+  fs9.writeFileSync(configPath, content);
+}
+function parseMCPConfig(content) {
+  try {
+    const parsed = YAML.parse(content);
+    const config = {
+      server: {
+        port: parsed?.server?.port ?? DEFAULT_MCP_CONFIG.server.port,
+        autoStart: parsed?.server?.autoStart ?? DEFAULT_MCP_CONFIG.server.autoStart
+      },
+      defaults: {
+        includeNew: parsed?.defaults?.includeNew ?? DEFAULT_MCP_CONFIG.defaults.includeNew,
+        permissions: {
+          knowledge: parsed?.defaults?.permissions?.knowledge ?? DEFAULT_PERMISSIONS.knowledge,
+          tasks: parsed?.defaults?.permissions?.tasks ?? DEFAULT_PERMISSIONS.tasks,
+          refs: parsed?.defaults?.permissions?.refs ?? DEFAULT_PERMISSIONS.refs
         }
-        return chunks;
-      }
+      },
+      projects: Array.isArray(parsed?.projects) ? parsed.projects.map((p) => ({
+        name: p.name || "",
+        path: p.path,
+        expose: p.expose ?? true,
+        permissions: {
+          knowledge: p.permissions?.knowledge ?? DEFAULT_PERMISSIONS.knowledge,
+          tasks: p.permissions?.tasks ?? DEFAULT_PERMISSIONS.tasks,
+          refs: p.permissions?.refs ?? DEFAULT_PERMISSIONS.refs
+        },
+        semanticSearch: p.semanticSearch
+      })) : []
     };
+    return config;
+  } catch (err) {
+    return { ...DEFAULT_MCP_CONFIG };
   }
-});
+}
+function serializeMCPConfig(config) {
+  const header = `# RRCE MCP Hub Configuration
+# Manages which projects are exposed via MCP
 
-// src/mcp/resources.ts
-import * as fs13 from "fs";
-import * as path14 from "path";
-function getExposedProjects() {
-  const config = loadMCPConfig();
-  const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
-  const allProjects = projectService.scan({ knownPaths });
-  const globalProjects = allProjects.filter((project) => isProjectExposed(config, project.name, project.dataPath));
-  const activeProject = detectActiveProject(globalProjects);
-  let linkedProjects = [];
-  if (activeProject) {
-    const localConfigPath = path14.join(activeProject.dataPath, "config.yaml");
-    let cfgContent = null;
-    if (fs13.existsSync(path14.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
-      cfgContent = fs13.readFileSync(path14.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
-    } else if (fs13.existsSync(path14.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
-      cfgContent = fs13.readFileSync(path14.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
+`;
+  return header + YAML.stringify(config, {
+    indent: 2,
+    lineWidth: 0
+    // No line wrapping
+  });
+}
+function setProjectConfig(config, name, expose, permissions, projectPath, semanticSearch) {
+  const existing = findProjectConfig(config, { name, path: projectPath });
+  if (existing) {
+    existing.expose = expose;
+    if (projectPath && !existing.path) {
+      existing.path = projectPath;
     }
-    if (cfgContent) {
-      if (cfgContent.includes("linked_projects:")) {
-        const lines = cfgContent.split("\n");
-        let inLinked = false;
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed.startsWith("linked_projects:")) {
-            inLinked = true;
-            continue;
-          }
-          if (inLinked) {
-            if (trimmed.startsWith("-") || trimmed.startsWith("linked_projects")) {
-            } else if (trimmed !== "" && !trimmed.startsWith("#")) {
-              inLinked = false;
-            }
-            if (inLinked && trimmed.startsWith("-")) {
-              const val = trimmed.replace(/^-\s*/, "").trim();
-              const [pName] = val.split(":");
-              if (!globalProjects.some((p) => p.name === pName) && !linkedProjects.some((p) => p.name === pName)) {
-                const found = allProjects.find((p) => p.name === pName);
-                if (found) {
-                  linkedProjects.push(found);
-                }
-              }
-            }
-          }
-        }
-      }
+    if (permissions) {
+      existing.permissions = { ...existing.permissions, ...permissions };
+    }
+    if (semanticSearch) {
+      existing.semanticSearch = semanticSearch;
     }
+  } else {
+    config.projects.push({
+      name,
+      path: projectPath,
+      expose,
+      permissions: permissions ? { ...DEFAULT_PERMISSIONS, ...permissions } : { ...DEFAULT_PERMISSIONS },
+      semanticSearch
+    });
   }
-  return [...globalProjects, ...linkedProjects];
-}
-function getRAGIndexPath(project) {
-  const scanRoot = project.path || project.dataPath;
-  return path14.join(project.knowledgePath || path14.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
+  return config;
 }
-function detectActiveProject(knownProjects) {
-  let scanList = knownProjects;
-  if (!scanList) {
-    const config = loadMCPConfig();
-    const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
-    const all = projectService.scan({ knownPaths });
-    scanList = all.filter((project) => isProjectExposed(config, project.name, project.dataPath));
-  }
-  return findClosestProject(scanList);
+function removeProjectConfig(config, name) {
+  config.projects = config.projects.filter((p) => p.name !== name);
+  return config;
 }
-function getProjectContext(projectName) {
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.dataPath));
-  if (!project) {
-    return null;
-  }
-  const permissions = getProjectPermissions(config, projectName, project.dataPath);
-  if (!permissions.knowledge) {
-    return null;
-  }
-  if (!project.knowledgePath) {
-    return null;
-  }
-  const contextPath = path14.join(project.knowledgePath, "project-context.md");
-  if (!fs13.existsSync(contextPath)) {
-    return null;
+function isProjectExposed(config, name, projectPath) {
+  const project = findProjectConfig(config, { name, path: projectPath });
+  if (project) {
+    return project.expose;
   }
-  return fs13.readFileSync(contextPath, "utf-8");
+  return config.defaults.includeNew;
 }
-function getProjectTasks(projectName) {
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.dataPath));
-  if (!project) {
-    return [];
-  }
-  const permissions = getProjectPermissions(config, projectName, project.dataPath);
-  if (!permissions.tasks) {
-    return [];
-  }
-  if (!project.tasksPath || !fs13.existsSync(project.tasksPath)) {
-    return [];
-  }
-  const tasks = [];
-  try {
-    const taskDirs = fs13.readdirSync(project.tasksPath, { withFileTypes: true });
-    for (const dir of taskDirs) {
-      if (!dir.isDirectory()) continue;
-      const metaPath = path14.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 {
-        }
-      }
-    }
-  } catch {
-  }
-  return tasks;
+function getProjectPermissions(config, name, projectPath) {
+  const project = findProjectConfig(config, { name, path: projectPath });
+  return project?.permissions ?? config.defaults.permissions;
 }
-async 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, project.dataPath);
-    if (!permissions.knowledge || !project.knowledgePath) continue;
-    const projConfig = config.projects.find(
-      (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
-    );
-    const useRAG = projConfig?.semanticSearch?.enabled;
-    if (useRAG) {
-      try {
-        const indexPath = path14.join(project.knowledgePath, "embeddings.json");
-        const rag = new RAGService(indexPath, projConfig?.semanticSearch?.model);
-        const ragResults = await rag.search(query, 5);
-        for (const r of ragResults) {
-          results.push({
-            project: project.name,
-            file: path14.relative(project.knowledgePath, r.filePath),
-            matches: [r.content],
-            // The chunk content is the match
-            score: r.score
-          });
-        }
-      } catch (e) {
-      }
-      continue;
+function cleanStaleProjects(config) {
+  const rrceHome = getEffectiveGlobalPath();
+  const globalWorkspacesDir = path10.join(rrceHome, "workspaces");
+  const validProjects = [];
+  const removed = [];
+  for (const project of config.projects) {
+    let exists = false;
+    if (project.path) {
+      exists = fs9.existsSync(project.path);
+    } else {
+      const globalPath = path10.join(globalWorkspacesDir, project.name);
+      exists = fs9.existsSync(globalPath);
     }
-    try {
-      const files = fs13.readdirSync(project.knowledgePath);
-      for (const file of files) {
-        if (!file.endsWith(".md")) continue;
-        const filePath = path14.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
-          });
-        }
-      }
-    } catch {
+    if (exists) {
+      validProjects.push(project);
+    } else {
+      removed.push(project.name);
     }
   }
-  return results;
-}
-async function indexKnowledge(projectName, force = false) {
-  const config = loadMCPConfig();
-  const projects = getExposedProjects();
-  const project = projects.find((p) => p.name === projectName || p.path && p.path === projectName);
-  if (!project) {
-    return { success: false, message: `Project '${projectName}' not found`, filesIndexed: 0, filesSkipped: 0 };
+  if (removed.length > 0) {
+    config.projects = validProjects;
   }
-  const projConfig = config.projects.find(
-    (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
-  ) || (project.source === "global" ? { semanticSearch: { enabled: true, model: "Xenova/all-MiniLM-L6-v2" } } : void 0);
-  const isEnabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled;
-  if (!isEnabled) {
-    return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0, filesSkipped: 0 };
+  return { config, removed };
+}
+var init_config = __esm({
+  "src/mcp/config.ts"() {
+    "use strict";
+    init_paths();
+    init_types();
+    init_config_utils();
   }
-  const scanRoot = project.sourcePath || project.path || project.dataPath;
-  if (!fs13.existsSync(scanRoot)) {
-    return { success: false, message: "Project root not found", filesIndexed: 0, filesSkipped: 0 };
+});
+
+// src/commands/wizard/setup-actions.ts
+import * as fs10 from "fs";
+import * as path11 from "path";
+import pc4 from "picocolors";
+import { note as note2 } from "@clack/prompts";
+function createDirectoryStructure(dataPaths) {
+  for (const dataPath of dataPaths) {
+    ensureDir(dataPath);
+    ensureDir(path11.join(dataPath, "knowledge"));
+    ensureDir(path11.join(dataPath, "refs"));
+    ensureDir(path11.join(dataPath, "tasks"));
+    ensureDir(path11.join(dataPath, "templates"));
   }
-  const INDEXABLE_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".py",
-    ".pyw",
-    ".go",
-    ".rs",
-    ".java",
-    ".kt",
-    ".kts",
-    ".c",
-    ".cpp",
-    ".h",
-    ".hpp",
-    ".cs",
-    ".rb",
-    ".php",
-    ".swift",
-    ".md",
-    ".mdx",
-    ".json",
-    ".yaml",
-    ".yml",
-    ".toml",
-    ".sh",
-    ".bash",
-    ".zsh",
-    ".sql",
-    ".html",
-    ".css",
-    ".scss",
-    ".sass",
-    ".less"
-  ];
-  const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor"];
-  try {
-    const indexPath = path14.join(project.knowledgePath || path14.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
-    const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
-    const rag = new RAGService(indexPath, model);
-    let indexed = 0;
-    let skipped = 0;
-    const scanDir = async (dir) => {
-      const entries = fs13.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path14.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (SKIP_DIRS.includes(entry.name) || entry.name.startsWith(".")) {
-            continue;
-          }
-          await scanDir(fullPath);
-        } else if (entry.isFile()) {
-          const ext = path14.extname(entry.name).toLowerCase();
-          if (!INDEXABLE_EXTENSIONS.includes(ext)) {
-            continue;
-          }
-          try {
-            const stat = fs13.statSync(fullPath);
-            const mtime = force ? void 0 : stat.mtimeMs;
-            const content = fs13.readFileSync(fullPath, "utf-8");
-            const wasIndexed = await rag.indexFile(fullPath, content, mtime);
-            if (wasIndexed) {
-              indexed++;
-            } else {
-              skipped++;
-            }
-          } catch (err) {
-          }
-        }
-      }
-    };
-    await scanDir(scanRoot);
-    rag.markFullIndex();
-    const stats = rag.getStats();
-    return {
-      success: true,
-      message: `Indexed ${indexed} files, skipped ${skipped} unchanged. Total: ${stats.totalChunks} chunks from ${stats.totalFiles} files.`,
-      filesIndexed: indexed,
-      filesSkipped: skipped
-    };
-  } catch (error) {
-    return { success: false, message: `Indexing failed: ${error}`, filesIndexed: 0, filesSkipped: 0 };
+}
+function installAgentPrompts(config, workspacePath, dataPaths) {
+  const agentCoreDir = getAgentCoreDir();
+  syncMetadataToAll(agentCoreDir, dataPaths);
+  copyDirToAllStoragePaths(path11.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path11.join(agentCoreDir, "prompts"), "prompts", dataPaths);
+  if (config.storageMode === "workspace") {
+    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");
+    }
   }
 }
-function getContextPreamble() {
-  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}
+function createWorkspaceConfig(config, workspacePath, workspaceName) {
+  let configPath;
+  if (config.storageMode === "global") {
+    const rrceHome = config.globalPath || getDefaultRRCEHome2();
+    configPath = path11.join(rrceHome, "workspaces", workspaceName, "config.yaml");
+  } else {
+    configPath = path11.join(workspacePath, ".rrce-workflow", "config.yaml");
+  }
+  ensureDir(path11.dirname(configPath));
+  let content = `# RRCE-Workflow Configuration
+version: 1
+
+storage:
+  mode: ${config.storageMode}`;
+  if (config.globalPath && config.globalPath !== getDefaultRRCEHome2()) {
+    content += `
+  globalPath: "${config.globalPath}"`;
+  }
+  content += `
+
+project:
+  name: "${workspaceName}"
+  sourcePath: "${workspacePath}"
+
+tools:
+  opencode: ${config.tools.includes("opencode")}
+  copilot: ${config.tools.includes("copilot")}
+  antigravity: ${config.tools.includes("antigravity")}
 `;
-  if (projects.length === 0) {
-    contextPreamble += `
-WARNING: No projects are currently exposed to the MCP server.
-The user needs to run 'npx rrce-workflow mcp configure' in their terminal to select projects to expose.
-Please advise the user to do this if they expect to see project context.
+  if (config.enableRAG) {
+    content += `
+semantic_search:
+  enabled: true
 `;
   }
-  if (activeProject) {
-    contextPreamble += `
-Current Active Workspace: ${activeProject.name} (${activeProject.path})
+  if (config.linkedProjects.length > 0) {
+    content += `
+linked_projects:
 `;
-    contextPreamble += `IMPORTANT: Treat '${activeProject.path}' as the {{WORKSPACE_ROOT}}. All relative path operations (file reads/writes) MUST be performed relative to this directory.
+    config.linkedProjects.forEach((name) => {
+      content += `  - ${name}
 `;
+    });
   }
-  contextPreamble += `
-Note: If the user's request refers to a project not listed here, ask them to expose it via 'rrce-workflow mcp configure'.
+  fs10.writeFileSync(configPath, content);
+}
+async function registerWithMCP(config, workspacePath, workspaceName) {
+  if (!config.exposeToMCP) return;
+  try {
+    const { loadMCPConfig: loadMCPConfig3, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const mcpConfig = loadMCPConfig3();
+    setProjectConfig2(
+      mcpConfig,
+      workspaceName,
+      true,
+      void 0,
+      workspacePath,
+      config.enableRAG ? { enabled: true } : void 0
+    );
+    saveMCPConfig2(mcpConfig);
+  } catch (e) {
+    note2(
+      `${pc4.yellow("\u26A0")} Could not register project with MCP
+Error: ${e instanceof Error ? e.message : String(e)}
 
----
-`;
-  return contextPreamble;
+You can configure MCP later: ${pc4.cyan("npx rrce-workflow mcp")}`,
+      "MCP Registration Warning"
+    );
+  }
 }
-var init_resources = __esm({
-  "src/mcp/resources.ts"() {
-    "use strict";
-    init_config();
-    init_detection();
-    init_detection_service();
-    init_rag();
+function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
+  const globalPath = path11.join(customGlobalPath || getDefaultRRCEHome2(), "workspaces", workspaceName);
+  const workspacePath = path11.join(workspaceRoot, ".rrce-workflow");
+  switch (mode) {
+    case "global":
+      return [globalPath];
+    case "workspace":
+      return [workspacePath];
+    default:
+      return [globalPath];
   }
-});
-
-// src/mcp/handlers/resources.ts
-import "@modelcontextprotocol/sdk/server/index.js";
-import {
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-function registerResourceHandlers(server) {
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    logger.debug("Listing resources");
-    const projects = getExposedProjects();
-    const resources = [];
-    resources.push({
-      uri: "rrce://projects",
-      name: "Project List",
-      description: "List of all RRCE projects exposed via MCP",
-      mimeType: "application/json"
-    });
-    for (const project of projects) {
-      const config = loadMCPConfig();
-      const permissions = getProjectPermissions(config, project.name, project.dataPath);
-      if (permissions.knowledge) {
-        resources.push({
-          uri: `rrce://projects/${project.name}/context`,
-          name: `${project.name} - Project Context`,
-          description: `Project context and architecture for ${project.name}`,
-          mimeType: "text/markdown"
-        });
-      }
-      if (permissions.tasks) {
-        resources.push({
-          uri: `rrce://projects/${project.name}/tasks`,
-          name: `${project.name} - Tasks`,
-          description: `Task list and status for ${project.name}`,
-          mimeType: "application/json"
-        });
-      }
-    }
-    return { resources };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const { uri } = request.params;
-    logger.info(`Reading resource: ${uri}`);
+}
+function installToSelectedIDEs(tools) {
+  const success = [];
+  const failed = [];
+  const toolToTarget = {
+    "opencode": "opencode",
+    "antigravity": "antigravity",
+    "copilot": "vscode-global"
+  };
+  for (const tool of tools) {
+    const target = toolToTarget[tool];
+    if (!target) continue;
     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 && projectMatch[1] && projectMatch[2]) {
-        const projectName = projectMatch[1];
-        const resourceType = projectMatch[2];
-        const content = resourceType === "context" ? getProjectContext(projectName) : JSON.stringify(getProjectTasks(projectName), null, 2);
-        if (content === null) throw new Error(`Resource not found: ${uri}`);
-        return {
-          contents: [{
-            uri,
-            mimeType: resourceType === "tasks" ? "application/json" : "text/markdown",
-            text: content
-          }]
-        };
+      const result = installToConfig(target);
+      const label = getTargetLabel(target);
+      if (result) {
+        success.push(label);
+      } else {
+        failed.push(label);
       }
-      throw new Error(`Unknown resource: ${uri}`);
     } catch (error) {
-      logger.error(`Failed to read resource: ${uri}`, error);
-      throw error;
+      const label = getTargetLabel(target);
+      console.error(`Failed to install to ${label}:`, error);
+      failed.push(label);
     }
-  });
+  }
+  return { success, failed };
 }
-var init_resources2 = __esm({
-  "src/mcp/handlers/resources.ts"() {
+var init_setup_actions = __esm({
+  "src/commands/wizard/setup-actions.ts"() {
     "use strict";
-    init_logger();
-    init_config();
-    init_resources();
+    init_paths();
+    init_prompts();
+    init_utils();
+    init_vscode();
+    init_install();
   }
 });
 
-// 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
-      })));
-    }
-    const filename = p.filePath.split("/").pop() || "";
-    const id = filename.replace(/\.md$/, "");
-    return {
-      id,
-      name: p.frontmatter.name,
-      description: p.frontmatter.description,
-      arguments: args,
-      content: p.content
-    };
-  });
-}
-function getPromptDef(name) {
-  const all = getAllPrompts();
-  const search = name.toLowerCase();
-  return all.find(
-    (p) => p.name === name || p.id === name || p.name.toLowerCase() === search || p.id.toLowerCase() === search
-  );
-}
-function renderPrompt(content, args) {
-  let rendered = content;
-  for (const [key, val] of Object.entries(args)) {
-    rendered = rendered.replace(new RegExp(`{{${key}}}`, "g"), val);
+// src/commands/wizard/gitignore.ts
+var gitignore_exports = {};
+__export(gitignore_exports, {
+  updateGitignore: () => updateGitignore
+});
+import * as fs11 from "fs";
+import * as path12 from "path";
+function updateGitignore(workspacePath, storageMode, tools) {
+  const gitignorePath = path12.join(workspacePath, ".gitignore");
+  const entries = [];
+  if (storageMode === "workspace") {
+    entries.push(".rrce-workflow/");
   }
-  return rendered;
+  if (tools.includes("copilot")) {
+    entries.push(".github/agents/");
+  }
+  if (tools.includes("antigravity")) {
+    entries.push(".agent/workflows/");
+  }
+  entries.push("*.code-workspace");
+  if (entries.length === 0) {
+    return false;
+  }
+  let existingContent = "";
+  if (fs11.existsSync(gitignorePath)) {
+    existingContent = fs11.readFileSync(gitignorePath, "utf-8");
+  }
+  const sectionMarker = "# RRCE-Workflow Generated";
+  if (existingContent.includes(sectionMarker)) {
+    return false;
+  }
+  const newSection = `
+${sectionMarker}
+# Uncomment the following lines if you want to ignore rrce-workflow generated files:
+${entries.map((e) => `# ${e}`).join("\n")}
+`;
+  const updatedContent = existingContent.trimEnd() + newSection;
+  fs11.writeFileSync(gitignorePath, updatedContent);
+  return true;
 }
-var init_prompts2 = __esm({
-  "src/mcp/prompts.ts"() {
+var init_gitignore = __esm({
+  "src/commands/wizard/gitignore.ts"() {
     "use strict";
-    init_prompts();
   }
 });
 
-// src/mcp/handlers/tools.ts
-import "@modelcontextprotocol/sdk/server/index.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-function registerToolHandlers(server) {
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const 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"]
+// src/mcp/logger.ts
+import * as fs12 from "fs";
+import * as path13 from "path";
+function getLogFilePath() {
+  const workspaceRoot = detectWorkspaceRoot();
+  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
+  return path13.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]`;
+            }
+          }
         }
-      },
-      {
-        name: "index_knowledge",
-        description: "Update the semantic search index for a specific project",
-        inputSchema: {
-          type: "object",
-          properties: {
-            project: { type: "string", description: "Name of the project to index" },
-            force: { type: "boolean", description: "Force re-indexing of all files" }
-          },
-          required: ["project"]
+        logMessage += "\n";
+        try {
+          const dir = path13.dirname(this.logPath);
+          if (!fs12.existsSync(dir)) {
+            fs12.mkdirSync(dir, { recursive: true });
+          }
+          fs12.appendFileSync(this.logPath, logMessage);
+        } catch (e) {
+          console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
+          console.error(logMessage);
         }
-      },
-      {
-        name: "list_projects",
-        description: "List all projects exposed via MCP. Use these names for project-specific tools.",
-        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"]
+      }
+      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/services/rag.ts
+import * as fs13 from "fs";
+import * as path14 from "path";
+var INDEX_VERSION, DEFAULT_MODEL, RAGService;
+var init_rag = __esm({
+  "src/mcp/services/rag.ts"() {
+    "use strict";
+    init_logger();
+    INDEX_VERSION = "1.0.0";
+    DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+    RAGService = class _RAGService {
+      // Static cache for the pipeline to prevent reloading model for every instance
+      static pipelineInstance = null;
+      static activeModelName = null;
+      static loadPromise = null;
+      modelName;
+      indexPath;
+      index = null;
+      constructor(indexPath, modelName = DEFAULT_MODEL) {
+        this.indexPath = indexPath;
+        this.modelName = modelName;
+      }
+      /**
+       * Lazy load the model (Singleton pattern)
+       */
+      async getPipeline() {
+        if (_RAGService.activeModelName === this.modelName && _RAGService.pipelineInstance) {
+          return _RAGService.pipelineInstance;
         }
-      },
-      {
-        name: "list_agents",
-        description: "List available agents (e.g. init, plan) and their arguments. Use this to discover which agent to call.",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "get_agent_prompt",
-        description: 'Get the system prompt for a specific agent. Accepts agent Name (e.g. "RRCE Init") or ID (e.g. "init").',
-        inputSchema: {
-          type: "object",
-          properties: {
-            agent: { type: "string", description: "Name of the agent (e.g. init, plan, execute)" },
-            args: { type: "object", description: "Arguments for the agent prompt", additionalProperties: true }
-          },
-          required: ["agent"]
+        if (_RAGService.activeModelName === this.modelName && _RAGService.loadPromise) {
+          return _RAGService.loadPromise;
         }
+        logger.info(`RAG: Initializing model ${this.modelName}...`);
+        _RAGService.activeModelName = this.modelName;
+        _RAGService.loadPromise = (async () => {
+          try {
+            const { pipeline } = await import("@xenova/transformers");
+            const pipe = await pipeline("feature-extraction", this.modelName);
+            _RAGService.pipelineInstance = pipe;
+            logger.info(`RAG: Model ${this.modelName} initialized successfully.`);
+            return pipe;
+          } catch (error) {
+            logger.error(`RAG: Failed to initialize model ${this.modelName}`, error);
+            _RAGService.pipelineInstance = null;
+            _RAGService.activeModelName = null;
+            _RAGService.loadPromise = null;
+            throw error;
+          }
+        })();
+        return _RAGService.loadPromise;
       }
-    ];
-    const projects = getExposedProjects();
-    if (projects.length === 0) {
-      tools.push({
-        name: "help_setup",
-        description: "Get help on how to configure projects for the RRCE MCP Server",
-        inputSchema: { type: "object", properties: {} }
-      });
-    }
-    return { tools };
-  });
-  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 = await searchKnowledge(args.query);
-          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+      /**
+       * Load index from disk
+       */
+      loadIndex() {
+        if (this.index) return;
+        if (fs13.existsSync(this.indexPath)) {
+          try {
+            const data = fs13.readFileSync(this.indexPath, "utf-8");
+            this.index = JSON.parse(data);
+            logger.info(`RAG: Loaded index from ${this.indexPath} with ${this.index?.chunks.length} chunks.`);
+          } catch (error) {
+            logger.error(`RAG: Failed to load index from ${this.indexPath}`, error);
+            this.index = {
+              version: INDEX_VERSION,
+              baseModel: this.modelName,
+              chunks: []
+            };
+          }
+        } else {
+          this.index = {
+            version: INDEX_VERSION,
+            baseModel: this.modelName,
+            chunks: []
+          };
+          logger.info(`RAG: Created new empty index at ${this.indexPath}`);
         }
-        case "index_knowledge": {
-          const params = args;
-          const result = await indexKnowledge(params.project, params.force);
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      /**
+       * Save index to disk
+       */
+      saveIndex() {
+        if (!this.index) return;
+        try {
+          const dir = path14.dirname(this.indexPath);
+          if (!fs13.existsSync(dir)) {
+            fs13.mkdirSync(dir, { recursive: true });
+          }
+          fs13.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+          logger.info(`RAG: Saved index to ${this.indexPath} with ${this.index.chunks.length} chunks.`);
+        } catch (error) {
+          logger.error(`RAG: Failed to save index to ${this.indexPath}`, error);
         }
-        case "list_projects": {
-          const projects = getExposedProjects();
-          const list = projects.map((p) => ({ name: p.name, source: p.source, path: p.path }));
-          return {
-            content: [{
-              type: "text",
-              text: JSON.stringify(list, null, 2) + "\n\nTip: Use these project names for tools like `get_project_context` or `index_knowledge`."
-            }]
-          };
+      }
+      /**
+       * Generate embedding for text
+       */
+      async generateEmbedding(text2) {
+        const pipe = await this.getPipeline();
+        try {
+          const output = await pipe(text2, { pooling: "mean", normalize: true });
+          return Array.from(output.data);
+        } catch (error) {
+          logger.error("RAG: Error generating embedding", error);
+          throw error;
+        }
+      }
+      /**
+       * Index a file (smart: skips if mtime unchanged)
+       * @param filePath Absolute path to the file
+       * @param content File content
+       * @param mtime Optional modification time (if not provided, always re-indexes)
+       * @returns true if file was indexed, false if skipped
+       */
+      async indexFile(filePath, content, mtime) {
+        this.loadIndex();
+        if (!this.index) throw new Error("Index not initialized");
+        if (!this.index.fileMetadata) {
+          this.index.fileMetadata = {};
         }
-        case "get_project_context": {
-          const context = getProjectContext(args.project);
-          if (!context) {
-            const projects = getExposedProjects().map((p) => p.name).join(", ");
-            const msg = `No project context found for "${args.project}".
-Available projects: ${projects}`;
-            logger.warn(msg);
-            return { content: [{ type: "text", text: msg }], isError: true };
+        if (mtime !== void 0 && this.index.fileMetadata[filePath]) {
+          const existingMeta = this.index.fileMetadata[filePath];
+          if (existingMeta.mtime === mtime) {
+            logger.debug(`RAG: Skipping unchanged file ${filePath}`);
+            return false;
           }
-          return { content: [{ type: "text", text: context }] };
         }
-        case "list_agents": {
-          const prompts = getAllPrompts();
-          return {
-            content: [{
-              type: "text",
-              text: JSON.stringify(prompts.map((p) => ({
-                name: p.name,
-                id: p.id,
-                description: p.description,
-                arguments: p.arguments
-              })), null, 2) + "\n\nTip: Retrieve the prompt for an agent using `get_agent_prompt` with its name or ID."
-            }]
-          };
+        logger.info(`RAG: Indexing file ${filePath}`);
+        this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
+        const chunks = this.chunkContent(content);
+        for (const chunkText of chunks) {
+          const embedding = await this.generateEmbedding(chunkText);
+          this.index.chunks.push({
+            id: `${filePath}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            filePath,
+            content: chunkText,
+            embedding,
+            mtime
+          });
         }
-        case "get_agent_prompt": {
-          const params = args;
-          const agentName = params.agent;
-          const promptDef = getPromptDef(agentName);
-          if (!promptDef) {
-            const available = getAllPrompts().map((p) => `${p.name} (id: ${p.id})`).join(", ");
-            throw new Error(`Agent not found: ${agentName}. Available agents: ${available}`);
-          }
-          const renderArgs = params.args || {};
-          const stringArgs = {};
-          for (const [key, val] of Object.entries(renderArgs)) {
-            stringArgs[key] = String(val);
-          }
-          const content = renderPrompt(promptDef.content, stringArgs);
-          const contextPreamble = getContextPreamble();
-          return { content: [{ type: "text", text: contextPreamble + content }] };
+        this.index.fileMetadata[filePath] = {
+          mtime: mtime ?? Date.now(),
+          chunkCount: chunks.length
+        };
+        this.saveIndex();
+        return true;
+      }
+      /**
+       * Remove a file from index
+       */
+      async removeFile(filePath) {
+        this.loadIndex();
+        if (!this.index) return;
+        const initialCount = this.index.chunks.length;
+        this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
+        if (this.index.fileMetadata) {
+          delete this.index.fileMetadata[filePath];
         }
-        case "help_setup": {
-          const msg = `
-RRCE MCP Server is running, but no projects are configured/exposed.
-
-To fix this:
-1. Open a terminal.
-2. Run: npx rrce-workflow mcp configure
-3. Select the projects you want to expose to the AI.
-4. Restart the MCP server (or it may pick up changes automatically).
-`;
-          return { content: [{ type: "text", text: msg }] };
+        if (this.index.chunks.length !== initialCount) {
+          logger.info(`RAG: Removed file ${filePath} from index (${initialCount - this.index.chunks.length} chunks removed)`);
+          this.saveIndex();
         }
-        default:
-          throw new Error(`Unknown tool: ${name}`);
       }
-    } catch (error) {
-      logger.error(`Tool execution failed: ${name}`, error);
-      throw error;
-    }
-  });
-}
-var init_tools = __esm({
-  "src/mcp/handlers/tools.ts"() {
-    "use strict";
-    init_logger();
-    init_resources();
-    init_prompts2();
-  }
-});
-
-// src/mcp/handlers/prompts.ts
-import "@modelcontextprotocol/sdk/server/index.js";
-import {
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import * as path15 from "path";
-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(", ")}`);
+      /**
+       * Get index statistics
+       */
+      getStats() {
+        this.loadIndex();
+        if (!this.index) return { totalChunks: 0, totalFiles: 0 };
+        const fileCount = this.index.fileMetadata ? Object.keys(this.index.fileMetadata).length : 0;
+        return {
+          totalChunks: this.index.chunks.length,
+          totalFiles: fileCount,
+          lastFullIndex: this.index.lastFullIndex
+        };
       }
-      const renderArgs = {};
-      for (const [key, val] of Object.entries(providedArgs)) {
-        renderArgs[key] = String(val);
+      /**
+       * Mark the last full index timestamp
+       */
+      markFullIndex() {
+        this.loadIndex();
+        if (!this.index) return;
+        this.index.lastFullIndex = Date.now();
+        this.saveIndex();
       }
-      const activeProject = detectActiveProject();
-      const DEFAULT_RRCE_HOME = getEffectiveGlobalPath();
-      let resolvedRrceData = ".rrce-workflow/";
-      let resolvedRrceHome = DEFAULT_RRCE_HOME;
-      let resolvedWorkspaceRoot = process.cwd();
-      let resolvedWorkspaceName = "current-project";
-      if (activeProject) {
-        resolvedRrceData = activeProject.dataPath + "/";
-        resolvedWorkspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
-        resolvedWorkspaceName = activeProject.name;
-        if (activeProject.source === "global") {
-          const workspacesDir = path15.dirname(activeProject.dataPath);
-          resolvedRrceHome = path15.dirname(workspacesDir);
+      /**
+       * Search the index
+       */
+      async search(query, limit = 5) {
+        this.loadIndex();
+        if (!this.index || this.index.chunks.length === 0) {
+          logger.warn("RAG: Search called on empty index");
+          return [];
+        }
+        logger.info(`RAG: Searching for "${query}" (limit: ${limit})`);
+        const queryEmbedding = await this.generateEmbedding(query);
+        const results = this.index.chunks.map((chunk) => {
+          const score = this.cosineSimilarity(queryEmbedding, chunk.embedding);
+          return { ...chunk, score };
+        });
+        results.sort((a, b) => b.score - a.score);
+        const topResults = results.slice(0, limit);
+        logger.info(`RAG: Search returned ${topResults.length} matches. Top score: ${topResults[0]?.score.toFixed(4)}`);
+        return topResults;
+      }
+      /**
+       * Simple cosine similarity
+       */
+      cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+          dotProduct += a[i] * b[i];
+          normA += a[i] * a[i];
+          normB += b[i] * b[i];
         }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
       }
-      if (!renderArgs["RRCE_DATA"]) renderArgs["RRCE_DATA"] = resolvedRrceData;
-      if (!renderArgs["RRCE_HOME"]) renderArgs["RRCE_HOME"] = resolvedRrceHome;
-      if (!renderArgs["WORKSPACE_ROOT"]) renderArgs["WORKSPACE_ROOT"] = resolvedWorkspaceRoot;
-      if (!renderArgs["WORKSPACE_NAME"]) renderArgs["WORKSPACE_NAME"] = resolvedWorkspaceName;
-      const content = renderPrompt(promptDef.content, renderArgs);
-      let contextPreamble = getContextPreamble();
-      contextPreamble += `
-### System Resolved Paths (OVERRIDE)
-The system has pre-resolved the configuration for this project. Use these values instead of manual resolution:
-- **RRCE_DATA**: \`${resolvedRrceData}\` (Stores knowledge, tasks, refs)
-- **WORKSPACE_ROOT**: \`${resolvedWorkspaceRoot}\` (Source code location)
-- **RRCE_HOME**: \`${resolvedRrceHome}\`
-- **Current Project**: ${resolvedWorkspaceName}
-`;
-      return {
-        messages: [
-          {
-            role: "user",
-            content: {
-              type: "text",
-              text: contextPreamble + content
-            }
-          }
-        ]
-      };
-    } catch (error) {
-      logger.error(`Failed to get prompt: ${name}`, error);
-      throw error;
-    }
-  });
-}
-var init_prompts3 = __esm({
-  "src/mcp/handlers/prompts.ts"() {
-    "use strict";
-    init_logger();
-    init_resources();
-    init_prompts2();
-    init_paths();
+      /**
+       * Basic content chunker
+       */
+      chunkContent(content, maxChunkSize = 1e3, overlap = 100) {
+        const chunks = [];
+        let start = 0;
+        while (start < content.length) {
+          let end = start + maxChunkSize;
+          if (end >= content.length) {
+            end = content.length;
+          } else {
+            const lastNewline = content.lastIndexOf("\n", end);
+            if (lastNewline > start + maxChunkSize / 2) {
+              end = lastNewline;
+            }
+          }
+          const chunk = content.substring(start, end).trim();
+          if (chunk.length > 50) {
+            chunks.push(chunk);
+          }
+          if (end === content.length) break;
+          start = end - overlap;
+        }
+        return chunks;
+      }
+    };
   }
 });
 
-// src/mcp/server.ts
-var server_exports = {};
-__export(server_exports, {
-  getMCPServerStatus: () => getMCPServerStatus,
-  startMCPServer: () => startMCPServer,
-  stopMCPServer: () => stopMCPServer
-});
-import { Server as Server4 } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-async function startMCPServer(options = {}) {
-  try {
-    logger.info("Starting MCP Server...");
-    process.on("uncaughtException", (error) => {
-      logger.error("Uncaught Exception", error);
-      console.error("Uncaught Exception:", error);
-    });
-    process.on("unhandledRejection", (reason) => {
-      logger.error("Unhandled Rejection", reason);
-      console.error("Unhandled Rejection:", reason);
-    });
-    const config = loadMCPConfig();
-    mcpServer = new Server4(
-      { 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);
-    if (!options.interactive) {
-      const transport = new StdioServerTransport();
-      await mcpServer.connect(transport);
-    } else {
-      logger.info("Running in interactive mode (Stdio transport detached)");
+// src/mcp/resources.ts
+import * as fs14 from "fs";
+import * as path15 from "path";
+function getExposedProjects() {
+  const config = loadMCPConfig();
+  const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
+  const allProjects = projectService.scan({ knownPaths });
+  const globalProjects = allProjects.filter((project) => isProjectExposed(config, project.name, project.dataPath));
+  const activeProject = detectActiveProject(globalProjects);
+  let linkedProjects = [];
+  if (activeProject) {
+    const localConfigPath = path15.join(activeProject.dataPath, "config.yaml");
+    let cfgContent = null;
+    if (fs14.existsSync(path15.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
+      cfgContent = fs14.readFileSync(path15.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
+    } else if (fs14.existsSync(path15.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
+      cfgContent = fs14.readFileSync(path15.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
     }
-    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 });
-    if (!options.interactive) {
-      console.error(`RRCE MCP Hub started (pid: ${process.pid})`);
-      console.error(`Exposed projects: ${exposed}`);
+    if (cfgContent) {
+      if (cfgContent.includes("linked_projects:")) {
+        const lines = cfgContent.split("\n");
+        let inLinked = false;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("linked_projects:")) {
+            inLinked = true;
+            continue;
+          }
+          if (inLinked) {
+            if (trimmed.startsWith("-") || trimmed.startsWith("linked_projects")) {
+            } else if (trimmed !== "" && !trimmed.startsWith("#")) {
+              inLinked = false;
+            }
+            if (inLinked && trimmed.startsWith("-")) {
+              const val = trimmed.replace(/^-\s*/, "").trim();
+              const [pName] = val.split(":");
+              if (!globalProjects.some((p) => p.name === pName) && !linkedProjects.some((p) => p.name === pName)) {
+                const found = allProjects.find((p) => p.name === pName);
+                if (found) {
+                  linkedProjects.push(found);
+                }
+              }
+            }
+          }
+        }
+      }
     }
-    return { port: config.server.port, pid: process.pid };
-  } catch (error) {
-    logger.error("Failed to start MCP server", 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");
+  return [...globalProjects, ...linkedProjects];
 }
-function getMCPServerStatus() {
-  return { ...serverState };
+function getRAGIndexPath(project) {
+  const scanRoot = project.path || project.dataPath;
+  return path15.join(project.knowledgePath || path15.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
 }
-var serverState, mcpServer;
-var init_server = __esm({
-  "src/mcp/server.ts"() {
-    "use strict";
-    init_logger();
-    init_config();
-    init_resources();
-    init_resources2();
-    init_tools();
-    init_prompts3();
-    serverState = { running: false };
-    mcpServer = null;
+function detectActiveProject(knownProjects) {
+  let scanList = knownProjects;
+  if (!scanList) {
+    const config = loadMCPConfig();
+    const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
+    const all = projectService.scan({ knownPaths });
+    scanList = all.filter((project) => isProjectExposed(config, project.name, project.dataPath));
   }
-});
-
-// src/mcp/install.ts
-import * as fs14 from "fs";
-import * as path16 from "path";
-import * as os from "os";
-function checkInstallStatus(workspacePath) {
-  return {
-    antigravity: checkAntigravityConfig(),
-    claude: checkClaudeConfig(),
-    vscodeGlobal: checkVSCodeGlobalConfig(),
-    vscodeWorkspace: workspacePath ? checkVSCodeWorkspaceConfig(workspacePath) : false,
-    opencode: checkOpenCodeConfig()
-  };
+  return findClosestProject(scanList);
 }
-function checkAntigravityConfig() {
-  if (!fs14.existsSync(ANTIGRAVITY_CONFIG)) return false;
-  try {
-    const content = JSON.parse(fs14.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
-    return !!content.mcpServers?.["rrce"];
-  } catch {
-    return false;
+function getProjectContext(projectName) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.dataPath));
+  if (!project) {
+    return null;
   }
-}
-function checkClaudeConfig() {
-  if (!fs14.existsSync(CLAUDE_CONFIG)) return false;
-  try {
-    const content = JSON.parse(fs14.readFileSync(CLAUDE_CONFIG, "utf-8"));
-    return !!content.mcpServers?.["rrce"];
-  } catch {
-    return false;
+  const permissions = getProjectPermissions(config, projectName, project.dataPath);
+  if (!permissions.knowledge) {
+    return null;
   }
-}
-function checkVSCodeGlobalConfig() {
-  if (!fs14.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
-  try {
-    const content = JSON.parse(fs14.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
-    return !!content["mcp.servers"]?.["rrce"];
-  } catch {
-    return false;
+  if (!project.knowledgePath) {
+    return null;
   }
-}
-function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path16.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs14.existsSync(configPath)) return false;
-  try {
-    const content = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
-    return !!content.servers?.["rrce"];
-  } catch {
-    return false;
+  const contextPath = path15.join(project.knowledgePath, "project-context.md");
+  if (!fs14.existsSync(contextPath)) {
+    return null;
   }
+  return fs14.readFileSync(contextPath, "utf-8");
 }
-function checkOpenCodeConfig() {
-  if (!fs14.existsSync(OPENCODE_CONFIG)) return false;
+function getProjectTasks(projectName) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.dataPath));
+  if (!project) {
+    return [];
+  }
+  const permissions = getProjectPermissions(config, projectName, project.dataPath);
+  if (!permissions.tasks) {
+    return [];
+  }
+  if (!project.tasksPath || !fs14.existsSync(project.tasksPath)) {
+    return [];
+  }
+  const tasks = [];
   try {
-    const content = JSON.parse(fs14.readFileSync(OPENCODE_CONFIG, "utf-8"));
-    return !!content.mcp?.["rrce"];
+    const taskDirs = fs14.readdirSync(project.tasksPath, { withFileTypes: true });
+    for (const dir of taskDirs) {
+      if (!dir.isDirectory()) continue;
+      const metaPath = path15.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 false;
-  }
-}
-function isInstalledAnywhere(workspacePath) {
-  const status = checkInstallStatus(workspacePath);
-  return status.antigravity || status.claude || status.vscodeGlobal || status.vscodeWorkspace || status.opencode;
-}
-function installToConfig(target, workspacePath) {
-  switch (target) {
-    case "antigravity":
-      return installToAntigravity();
-    case "claude":
-      return installToClaude();
-    case "vscode-global":
-      return installToVSCodeGlobal();
-    case "vscode-workspace":
-      return workspacePath ? installToVSCodeWorkspace(workspacePath) : false;
-    case "opencode":
-      return installToOpenCode();
-    default:
-      return false;
   }
+  return tasks;
 }
-function installToAntigravity() {
-  const dir = path16.dirname(ANTIGRAVITY_CONFIG);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
-  }
-  let config = { mcpServers: {} };
-  if (fs14.existsSync(ANTIGRAVITY_CONFIG)) {
-    try {
-      config = JSON.parse(fs14.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
-    } catch {
+async function searchKnowledge(query, projectFilter) {
+  const config = loadMCPConfig();
+  const projects = getExposedProjects();
+  const results = [];
+  const queryLower = query.toLowerCase();
+  for (const project of projects) {
+    if (projectFilter && project.name !== projectFilter) continue;
+    const permissions = getProjectPermissions(config, project.name, project.dataPath);
+    if (!permissions.knowledge || !project.knowledgePath) continue;
+    const projConfig = config.projects.find(
+      (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
+    );
+    const useRAG = projConfig?.semanticSearch?.enabled;
+    if (useRAG) {
+      try {
+        const indexPath = path15.join(project.knowledgePath, "embeddings.json");
+        const rag = new RAGService(indexPath, projConfig?.semanticSearch?.model);
+        const ragResults = await rag.search(query, 5);
+        for (const r of ragResults) {
+          results.push({
+            project: project.name,
+            file: path15.relative(project.knowledgePath, r.filePath),
+            matches: [r.content],
+            // The chunk content is the match
+            score: r.score
+          });
+        }
+      } catch (e) {
+      }
+      continue;
     }
-  }
-  if (!config.mcpServers) config.mcpServers = {};
-  config.mcpServers["rrce"] = {
-    command: "npx",
-    args: ["-y", "rrce-workflow", "mcp", "start"]
-  };
-  try {
-    fs14.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function installToClaude() {
-  const dir = path16.dirname(CLAUDE_CONFIG);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
-  }
-  let config = { mcpServers: {} };
-  if (fs14.existsSync(CLAUDE_CONFIG)) {
     try {
-      config = JSON.parse(fs14.readFileSync(CLAUDE_CONFIG, "utf-8"));
+      const files = fs14.readdirSync(project.knowledgePath);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const filePath = path15.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 {
     }
   }
-  if (!config.mcpServers) config.mcpServers = {};
-  config.mcpServers["rrce"] = {
-    command: "npx",
-    args: ["-y", "rrce-workflow", "mcp", "start"]
-  };
-  try {
-    fs14.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
-    return true;
-  } catch {
-    return false;
-  }
+  return results;
 }
-function installToVSCodeGlobal() {
-  const dir = path16.dirname(VSCODE_GLOBAL_CONFIG);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+async function indexKnowledge(projectName, force = false) {
+  const config = loadMCPConfig();
+  const projects = getExposedProjects();
+  const project = projects.find((p) => p.name === projectName || p.path && p.path === projectName);
+  if (!project) {
+    return { success: false, message: `Project '${projectName}' not found`, filesIndexed: 0, filesSkipped: 0 };
   }
-  let settings = {};
-  if (fs14.existsSync(VSCODE_GLOBAL_CONFIG)) {
-    try {
-      settings = JSON.parse(fs14.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
-    } catch {
-    }
+  const projConfig = config.projects.find(
+    (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
+  ) || (project.source === "global" ? { semanticSearch: { enabled: true, model: "Xenova/all-MiniLM-L6-v2" } } : void 0);
+  const isEnabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled;
+  if (!isEnabled) {
+    return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0, filesSkipped: 0 };
   }
-  if (!settings["mcp.servers"]) settings["mcp.servers"] = {};
-  settings["mcp.servers"]["rrce"] = {
-    command: "npx",
-    args: ["-y", "rrce-workflow", "mcp", "start"]
-  };
+  const scanRoot = project.sourcePath || project.path || project.dataPath;
+  if (!fs14.existsSync(scanRoot)) {
+    return { success: false, message: "Project root not found", filesIndexed: 0, filesSkipped: 0 };
+  }
+  const INDEXABLE_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".pyw",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".kts",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".cs",
+    ".rb",
+    ".php",
+    ".swift",
+    ".md",
+    ".mdx",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".sql",
+    ".html",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less"
+  ];
+  const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor"];
   try {
-    fs14.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
-    return true;
-  } catch {
-    return false;
+    const indexPath = path15.join(project.knowledgePath || path15.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
+    const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
+    const rag = new RAGService(indexPath, model);
+    let indexed = 0;
+    let skipped = 0;
+    const scanDir = async (dir) => {
+      const entries = fs14.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path15.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.includes(entry.name) || entry.name.startsWith(".")) {
+            continue;
+          }
+          await scanDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path15.extname(entry.name).toLowerCase();
+          if (!INDEXABLE_EXTENSIONS.includes(ext)) {
+            continue;
+          }
+          try {
+            const stat = fs14.statSync(fullPath);
+            const mtime = force ? void 0 : stat.mtimeMs;
+            const content = fs14.readFileSync(fullPath, "utf-8");
+            const wasIndexed = await rag.indexFile(fullPath, content, mtime);
+            if (wasIndexed) {
+              indexed++;
+            } else {
+              skipped++;
+            }
+          } catch (err) {
+          }
+        }
+      }
+    };
+    await scanDir(scanRoot);
+    rag.markFullIndex();
+    const stats = rag.getStats();
+    return {
+      success: true,
+      message: `Indexed ${indexed} files, skipped ${skipped} unchanged. Total: ${stats.totalChunks} chunks from ${stats.totalFiles} files.`,
+      filesIndexed: indexed,
+      filesSkipped: skipped
+    };
+  } catch (error) {
+    return { success: false, message: `Indexing failed: ${error}`, filesIndexed: 0, filesSkipped: 0 };
   }
 }
-function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path16.join(workspacePath, ".vscode");
-  const configPath = path16.join(vscodeDir, "mcp.json");
-  if (!fs14.existsSync(vscodeDir)) {
-    fs14.mkdirSync(vscodeDir, { recursive: true });
+function getContextPreamble() {
+  const projects = getExposedProjects();
+  const activeProject = detectActiveProject();
+  let contextPreamble = "";
+  if (activeProject) {
+    const rrceHome = process.env.RRCE_HOME || path15.join(__require("os").homedir(), ".rrce-workflow");
+    const workspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
+    const rrceData = activeProject.dataPath;
+    contextPreamble += `
+## System Resolved Paths
+Use these values directly in your operations. Do NOT manually resolve paths.
+
+| Variable | Value |
+|----------|-------|
+| \`WORKSPACE_ROOT\` | \`${workspaceRoot}\` |
+| \`WORKSPACE_NAME\` | \`${activeProject.name}\` |
+| \`RRCE_DATA\` | \`${rrceData}\` |
+| \`RRCE_HOME\` | \`${rrceHome}\` |
+
+`;
   }
-  let config = { servers: {} };
-  if (fs14.existsSync(configPath)) {
-    try {
-      config = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
-    } catch {
-    }
+  const projectList = projects.map((p) => {
+    const isActive = activeProject && p.dataPath === activeProject.dataPath;
+    return `- ${p.name} (${p.source}) ${isActive ? "**[ACTIVE]**" : ""}`;
+  }).join("\n");
+  contextPreamble += `
+## Available Projects
+${projectList}
+`;
+  if (projects.length === 0) {
+    contextPreamble += `
+WARNING: No projects are currently exposed to the MCP server.
+Run 'npx rrce-workflow mcp configure' to select projects to expose.
+`;
   }
-  if (!config.servers) config.servers = {};
-  config.servers["rrce"] = {
-    command: "npx",
-    args: ["-y", "rrce-workflow", "mcp", "start"]
-  };
-  try {
-    fs14.writeFileSync(configPath, JSON.stringify(config, null, 2));
-    return true;
-  } catch {
-    return false;
+  if (activeProject) {
+    contextPreamble += `
+Current Active Workspace: ${activeProject.name}
+All file operations should be relative to WORKSPACE_ROOT shown above.
+`;
   }
+  contextPreamble += `
+---
+`;
+  return contextPreamble;
 }
-function installToOpenCode() {
-  const dir = path16.dirname(OPENCODE_CONFIG);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+var init_resources = __esm({
+  "src/mcp/resources.ts"() {
+    "use strict";
+    init_config();
+    init_detection();
+    init_detection_service();
+    init_rag();
   }
-  let config = {
-    $schema: "https://opencode.ai/config.json"
-  };
-  if (fs14.existsSync(OPENCODE_CONFIG)) {
+});
+
+// src/mcp/handlers/resources.ts
+import "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function registerResourceHandlers(server) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    logger.debug("Listing resources");
+    const projects = getExposedProjects();
+    const resources = [];
+    resources.push({
+      uri: "rrce://projects",
+      name: "Project List",
+      description: "List of all RRCE projects exposed via MCP",
+      mimeType: "application/json"
+    });
+    for (const project of projects) {
+      const config = loadMCPConfig();
+      const permissions = getProjectPermissions(config, project.name, project.dataPath);
+      if (permissions.knowledge) {
+        resources.push({
+          uri: `rrce://projects/${project.name}/context`,
+          name: `${project.name} - Project Context`,
+          description: `Project context and architecture for ${project.name}`,
+          mimeType: "text/markdown"
+        });
+      }
+      if (permissions.tasks) {
+        resources.push({
+          uri: `rrce://projects/${project.name}/tasks`,
+          name: `${project.name} - Tasks`,
+          description: `Task list and status for ${project.name}`,
+          mimeType: "application/json"
+        });
+      }
+    }
+    return { resources };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    logger.info(`Reading resource: ${uri}`);
     try {
-      config = JSON.parse(fs14.readFileSync(OPENCODE_CONFIG, "utf-8"));
+      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 && projectMatch[1] && projectMatch[2]) {
+        const projectName = projectMatch[1];
+        const resourceType = projectMatch[2];
+        const content = resourceType === "context" ? getProjectContext(projectName) : JSON.stringify(getProjectTasks(projectName), null, 2);
+        if (content === null) throw new Error(`Resource not found: ${uri}`);
+        return {
+          contents: [{
+            uri,
+            mimeType: resourceType === "tasks" ? "application/json" : "text/markdown",
+            text: content
+          }]
+        };
+      }
+      throw new Error(`Unknown resource: ${uri}`);
     } catch (error) {
-      console.error("Warning: Could not parse existing OpenCode config, creating fresh config");
+      logger.error(`Failed to read resource: ${uri}`, error);
+      throw error;
     }
-  }
-  if (!config.mcp) config.mcp = {};
-  config.mcp["rrce"] = {
-    type: "local",
-    command: ["npx", "-y", "rrce-workflow", "mcp", "start"],
-    enabled: true
-  };
-  try {
-    fs14.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
-    return true;
-  } catch (error) {
-    console.error("Failed to write OpenCode config:", error instanceof Error ? error.message : String(error));
-    return false;
-  }
+  });
 }
-function uninstallFromOpenCode() {
-  if (!fs14.existsSync(OPENCODE_CONFIG)) {
-    console.error("OpenCode config not found");
-    return false;
+var init_resources2 = __esm({
+  "src/mcp/handlers/resources.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    init_resources();
   }
-  try {
-    const config = JSON.parse(fs14.readFileSync(OPENCODE_CONFIG, "utf-8"));
-    if (!config.mcp?.["rrce"]) {
-      console.warn("RRCE not found in OpenCode config");
-      return false;
+});
+
+// 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
+      })));
     }
-    delete config.mcp["rrce"];
-    fs14.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
-    return true;
-  } catch (error) {
-    console.error("Failed to uninstall from OpenCode:", error instanceof Error ? error.message : String(error));
-    return false;
+    if (p.frontmatter["optional-args"]) {
+      args.push(...p.frontmatter["optional-args"].map((a) => ({
+        name: a.name,
+        description: a.prompt || a.name,
+        required: false
+      })));
+    }
+    const filename = p.filePath.split("/").pop() || "";
+    const id = filename.replace(/\.md$/, "");
+    return {
+      id,
+      name: p.frontmatter.name,
+      description: p.frontmatter.description,
+      arguments: args,
+      content: p.content
+    };
+  });
+}
+function getPromptDef(name) {
+  const all = getAllPrompts();
+  const search = name.toLowerCase();
+  return all.find(
+    (p) => p.name === name || p.id === name || p.name.toLowerCase() === search || p.id.toLowerCase() === search
+  );
+}
+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;
 }
-function uninstallFromAntigravity() {
-  if (!fs14.existsSync(ANTIGRAVITY_CONFIG)) {
-    console.error("Antigravity config not found");
-    return false;
+var init_prompts2 = __esm({
+  "src/mcp/prompts.ts"() {
+    "use strict";
+    init_prompts();
   }
-  try {
-    const config = JSON.parse(fs14.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
-    if (!config.mcpServers?.["rrce"]) {
-      console.warn("RRCE not found in Antigravity config");
-      return false;
+});
+
+// src/mcp/handlers/tools.ts
+import "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function registerToolHandlers(server) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const 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" },
+            project: { type: "string", description: "Optional: limit search to specific project name" }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "index_knowledge",
+        description: "Update the semantic search index for a specific project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project to index" },
+            force: { type: "boolean", description: "Force re-indexing of all files" }
+          },
+          required: ["project"]
+        }
+      },
+      {
+        name: "list_projects",
+        description: "List all projects exposed via MCP. Use these names for project-specific tools.",
+        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"]
+        }
+      },
+      {
+        name: "list_agents",
+        description: "List available agents (e.g. init, plan) and their arguments. Use this to discover which agent to call.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_agent_prompt",
+        description: 'Get the system prompt for a specific agent. Accepts agent Name (e.g. "RRCE Init") or ID (e.g. "init").',
+        inputSchema: {
+          type: "object",
+          properties: {
+            agent: { type: "string", description: "Name of the agent (e.g. init, plan, execute)" },
+            args: { type: "object", description: "Arguments for the agent prompt", additionalProperties: true }
+          },
+          required: ["agent"]
+        }
+      }
+    ];
+    const projects = getExposedProjects();
+    if (projects.length === 0) {
+      tools.push({
+        name: "help_setup",
+        description: "Get help on how to configure projects for the RRCE MCP Server",
+        inputSchema: { type: "object", properties: {} }
+      });
+    }
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info(`Calling tool: ${name}`, args);
+    try {
+      switch (name) {
+        case "search_knowledge": {
+          const params = args;
+          const results = await searchKnowledge(params.query, params.project);
+          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        case "index_knowledge": {
+          const params = args;
+          const result = await indexKnowledge(params.project, params.force);
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        case "list_projects": {
+          const projects = getExposedProjects();
+          const list = projects.map((p) => ({ name: p.name, source: p.source, path: p.path }));
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(list, null, 2) + "\n\nTip: Use these project names for tools like `get_project_context` or `index_knowledge`."
+            }]
+          };
+        }
+        case "get_project_context": {
+          const context = getProjectContext(args.project);
+          if (!context) {
+            const projects = getExposedProjects().map((p) => p.name).join(", ");
+            const msg = `No project context found for "${args.project}".
+Available projects: ${projects}`;
+            logger.warn(msg);
+            return { content: [{ type: "text", text: msg }], isError: true };
+          }
+          return { content: [{ type: "text", text: context }] };
+        }
+        case "list_agents": {
+          const prompts = getAllPrompts();
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(prompts.map((p) => ({
+                name: p.name,
+                id: p.id,
+                description: p.description,
+                arguments: p.arguments
+              })), null, 2) + "\n\nTip: Retrieve the prompt for an agent using `get_agent_prompt` with its name or ID."
+            }]
+          };
+        }
+        case "get_agent_prompt": {
+          const params = args;
+          const agentName = params.agent;
+          const promptDef = getPromptDef(agentName);
+          if (!promptDef) {
+            const available = getAllPrompts().map((p) => `${p.name} (id: ${p.id})`).join(", ");
+            throw new Error(`Agent not found: ${agentName}. Available agents: ${available}`);
+          }
+          const renderArgs = params.args || {};
+          const stringArgs = {};
+          for (const [key, val] of Object.entries(renderArgs)) {
+            stringArgs[key] = String(val);
+          }
+          const content = renderPrompt(promptDef.content, stringArgs);
+          const contextPreamble = getContextPreamble();
+          return { content: [{ type: "text", text: contextPreamble + content }] };
+        }
+        case "help_setup": {
+          const msg = `
+RRCE MCP Server is running, but no projects are configured/exposed.
+
+To fix this:
+1. Open a terminal.
+2. Run: npx rrce-workflow mcp configure
+3. Select the projects you want to expose to the AI.
+4. Restart the MCP server (or it may pick up changes automatically).
+`;
+          return { content: [{ type: "text", text: msg }] };
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      logger.error(`Tool execution failed: ${name}`, error);
+      throw error;
     }
-    delete config.mcpServers["rrce"];
-    fs14.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2) + "\n");
-    return true;
-  } catch (error) {
-    console.error("Failed to uninstall from Antigravity:", error instanceof Error ? error.message : String(error));
-    return false;
-  }
+  });
 }
-function uninstallFromClaude() {
-  if (!fs14.existsSync(CLAUDE_CONFIG)) {
-    console.error("Claude Desktop config not found");
-    return false;
+var init_tools = __esm({
+  "src/mcp/handlers/tools.ts"() {
+    "use strict";
+    init_logger();
+    init_resources();
+    init_prompts2();
   }
-  try {
-    const config = JSON.parse(fs14.readFileSync(CLAUDE_CONFIG, "utf-8"));
-    if (!config.mcpServers?.["rrce"]) {
-      console.warn("RRCE not found in Claude Desktop config");
-      return false;
+});
+
+// src/mcp/handlers/prompts.ts
+import "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as path16 from "path";
+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}`);
     }
-    delete config.mcpServers["rrce"];
-    fs14.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2) + "\n");
-    return true;
-  } catch (error) {
-    console.error("Failed to uninstall from Claude Desktop:", error instanceof Error ? error.message : String(error));
-    return false;
-  }
-}
-function uninstallFromVSCodeGlobal() {
-  if (!fs14.existsSync(VSCODE_GLOBAL_CONFIG)) {
-    console.error("VSCode global config not found");
-    return false;
-  }
-  try {
-    const settings = JSON.parse(fs14.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
-    if (!settings["mcp.servers"]?.["rrce"]) {
-      console.warn("RRCE not found in VSCode global settings");
-      return false;
+    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 activeProject = detectActiveProject();
+      const DEFAULT_RRCE_HOME = getEffectiveGlobalPath();
+      let resolvedRrceData = ".rrce-workflow/";
+      let resolvedRrceHome = DEFAULT_RRCE_HOME;
+      let resolvedWorkspaceRoot = process.cwd();
+      let resolvedWorkspaceName = "current-project";
+      if (activeProject) {
+        resolvedRrceData = activeProject.dataPath + "/";
+        resolvedWorkspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
+        resolvedWorkspaceName = activeProject.name;
+        if (activeProject.source === "global") {
+          const workspacesDir = path16.dirname(activeProject.dataPath);
+          resolvedRrceHome = path16.dirname(workspacesDir);
+        }
+      }
+      if (!renderArgs["RRCE_DATA"]) renderArgs["RRCE_DATA"] = resolvedRrceData;
+      if (!renderArgs["RRCE_HOME"]) renderArgs["RRCE_HOME"] = resolvedRrceHome;
+      if (!renderArgs["WORKSPACE_ROOT"]) renderArgs["WORKSPACE_ROOT"] = resolvedWorkspaceRoot;
+      if (!renderArgs["WORKSPACE_NAME"]) renderArgs["WORKSPACE_NAME"] = resolvedWorkspaceName;
+      const content = renderPrompt(promptDef.content, renderArgs);
+      let contextPreamble = getContextPreamble();
+      contextPreamble += `
+### System Resolved Paths (OVERRIDE)
+The system has pre-resolved the configuration for this project. Use these values instead of manual resolution:
+- **RRCE_DATA**: \`${resolvedRrceData}\` (Stores knowledge, tasks, refs)
+- **WORKSPACE_ROOT**: \`${resolvedWorkspaceRoot}\` (Source code location)
+- **RRCE_HOME**: \`${resolvedRrceHome}\`
+- **Current Project**: ${resolvedWorkspaceName}
+`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: contextPreamble + content
+            }
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error(`Failed to get prompt: ${name}`, error);
+      throw error;
     }
-    delete settings["mcp.servers"]["rrce"];
-    fs14.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2) + "\n");
-    return true;
-  } catch (error) {
-    console.error("Failed to uninstall from VSCode (Global):", error instanceof Error ? error.message : String(error));
-    return false;
-  }
+  });
 }
-function uninstallFromVSCodeWorkspace(workspacePath) {
-  const configPath = path16.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs14.existsSync(configPath)) {
-    console.error("VSCode workspace config not found");
-    return false;
+var init_prompts3 = __esm({
+  "src/mcp/handlers/prompts.ts"() {
+    "use strict";
+    init_logger();
+    init_resources();
+    init_prompts2();
+    init_paths();
   }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  getMCPServerStatus: () => getMCPServerStatus,
+  startMCPServer: () => startMCPServer,
+  stopMCPServer: () => stopMCPServer
+});
+import { Server as Server4 } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startMCPServer(options = {}) {
   try {
-    const config = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
-    if (!config.servers?.["rrce"]) {
-      console.warn("RRCE not found in VSCode workspace config");
-      return false;
+    logger.info("Starting MCP Server...");
+    process.on("uncaughtException", (error) => {
+      logger.error("Uncaught Exception", error);
+      console.error("Uncaught Exception:", error);
+    });
+    process.on("unhandledRejection", (reason) => {
+      logger.error("Unhandled Rejection", reason);
+      console.error("Unhandled Rejection:", reason);
+    });
+    const config = loadMCPConfig();
+    mcpServer = new Server4(
+      { 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);
+    if (!options.interactive) {
+      const transport = new StdioServerTransport();
+      await mcpServer.connect(transport);
+    } else {
+      logger.info("Running in interactive mode (Stdio transport detached)");
     }
-    delete config.servers["rrce"];
-    fs14.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-    return true;
+    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 });
+    if (!options.interactive) {
+      console.error(`RRCE MCP Hub started (pid: ${process.pid})`);
+      console.error(`Exposed projects: ${exposed}`);
+    }
+    return { port: config.server.port, pid: process.pid };
   } catch (error) {
-    console.error("Failed to uninstall from VSCode (Workspace):", error instanceof Error ? error.message : String(error));
-    return false;
+    logger.error("Failed to start MCP server", error);
+    throw error;
   }
 }
-function uninstallFromConfig(target, workspacePath) {
-  switch (target) {
-    case "antigravity":
-      return uninstallFromAntigravity();
-    case "claude":
-      return uninstallFromClaude();
-    case "vscode-global":
-      return uninstallFromVSCodeGlobal();
-    case "vscode-workspace":
-      return workspacePath ? uninstallFromVSCodeWorkspace(workspacePath) : false;
-    case "opencode":
-      return uninstallFromOpenCode();
-    default:
-      return false;
+function stopMCPServer() {
+  if (mcpServer) {
+    logger.info("Stopping MCP Server...");
+    mcpServer.close();
+    mcpServer = null;
   }
+  serverState = { running: false };
+  logger.info("RRCE MCP Hub stopped");
 }
-function getTargetLabel(target) {
-  switch (target) {
-    case "antigravity":
-      return "Antigravity IDE";
-    case "claude":
-      return "Claude Desktop";
-    case "vscode-global":
-      return "VSCode (Global)";
-    case "vscode-workspace":
-      return "VSCode (Workspace)";
-    case "opencode":
-      return "OpenCode";
-    default:
-      return target;
-  }
+function getMCPServerStatus() {
+  return { ...serverState };
 }
-var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG, OPENCODE_CONFIG;
-var init_install = __esm({
-  "src/mcp/install.ts"() {
+var serverState, mcpServer;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path16.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path16.join(os.homedir(), ".config/claude/claude_desktop_config.json");
-    VSCODE_GLOBAL_CONFIG = path16.join(os.homedir(), ".config/Code/User/settings.json");
-    OPENCODE_CONFIG = path16.join(os.homedir(), ".config/opencode/opencode.json");
+    init_logger();
+    init_config();
+    init_resources();
+    init_resources2();
+    init_tools();
+    init_prompts3();
+    serverState = { running: false };
+    mcpServer = null;
   }
 });
 
@@ -4131,13 +4209,18 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
       process.exit(0);
     }
   }
+  const toolsPreview = [];
+  if (isOpenCodeInstalled()) toolsPreview.push("OpenCode");
+  if (isVSCodeInstalled()) toolsPreview.push("GitHub Copilot");
+  if (isAntigravityInstalled()) toolsPreview.push("Antigravity");
+  const toolsText = toolsPreview.length > 0 ? toolsPreview.join(", ") : "None detected";
   note9(
     `${pc11.bold("Express Setup will configure:")}
 \u2022 Storage: ${storageMode === "global" ? "Global" : "Workspace"}
 \u2022 MCP Server: Enabled
 \u2022 Semantic Search (RAG): Enabled
 \u2022 Git ignore entries: Added (as comments)
-\u2022 AI Tools: All available`,
+\u2022 AI Tools: ${toolsText}`,
     "Configuration Preview"
   );
   const confirmed = await confirm6({
@@ -4148,10 +4231,14 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
     cancel3("Setup cancelled.");
     process.exit(0);
   }
+  const defaultTools = [];
+  if (isOpenCodeInstalled()) defaultTools.push("opencode");
+  if (isVSCodeInstalled()) defaultTools.push("copilot");
+  if (isAntigravityInstalled()) defaultTools.push("antigravity");
   const config = {
     storageMode,
     globalPath: customGlobalPath,
-    tools: ["copilot", "antigravity"],
+    tools: defaultTools,
     linkedProjects: [],
     addToGitignore: false,
     exposeToMCP: true,
@@ -4239,6 +4326,7 @@ async function executeSetup(config, workspacePath, workspaceName, allProjects, s
       generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
     }
     await registerWithMCP(config, workspacePath, workspaceName);
+    const ideResults = installToSelectedIDEs(config.tools);
     s.stop("Configuration generated");
     const dataSummary = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
     const summary = [
@@ -4246,8 +4334,14 @@ async function executeSetup(config, workspacePath, workspaceName, allProjects, s
       config.tools.length > 0 ? `${pc11.green("\u2713")} Tools: ${config.tools.join(", ")}` : null,
       config.exposeToMCP ? `${pc11.green("\u2713")} MCP server configured` : null,
       config.enableRAG ? `${pc11.green("\u2713")} Semantic Search enabled` : null,
-      config.linkedProjects.length > 0 ? `${pc11.green("\u2713")} Linked ${config.linkedProjects.length} project(s)` : null
+      config.linkedProjects.length > 0 ? `${pc11.green("\u2713")} Linked ${config.linkedProjects.length} project(s)` : null,
+      ideResults.success.length > 0 ? `${pc11.green("\u2713")} RRCE installed to: ${ideResults.success.join(", ")}` : null,
+      ideResults.failed.length > 0 ? `${pc11.yellow("\u26A0")} Failed to install to: ${ideResults.failed.join(", ")}` : null
     ].filter(Boolean);
+    if (ideResults.success.length > 0) {
+      summary.push("");
+      summary.push(pc11.dim("\u{1F4A1} You may need to restart your IDE or refresh MCP config for changes to take effect."));
+    }
     note9(summary.join("\n"), "Setup Complete");
   } catch (error) {
     s.stop("Error occurred");
@@ -4288,6 +4382,7 @@ var init_setup_flow = __esm({
     "use strict";
     init_detection();
     init_tui_utils();
+    init_install();
     init_setup_prompts();
     init_setup_actions();
     init_gitignore();