rrce-workflow 0.2.21 → 0.2.23

package/dist/index.js

@@ -1,24 +1,16 @@
-// src/commands/wizard/index.ts
-import { intro, select as select2, spinner as spinner5, note as note5, outro as outro5, isCancel as isCancel5 } from "@clack/prompts";
-import pc6 from "picocolors";
-import * as fs11 from "fs";
-
-// src/lib/git.ts
-import { execSync } from "child_process";
-function getGitUser() {
-  try {
-    const result = execSync("git config user.name", { encoding: "utf-8" });
-    return result.trim() || null;
-  } catch {
-    return null;
-  }
-}
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/lib/paths.ts
 import * as fs from "fs";
 import * as path from "path";
-var RRCE_HOME = process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
-var RRCE_WORKSPACE = process.env.RRCE_WORKSPACE;
 function detectWorkspaceRoot() {
   if (RRCE_WORKSPACE) {
     return RRCE_WORKSPACE;
@@ -132,8 +124,224 @@ function getEffectiveRRCEHome(workspaceRoot) {
   }
   return getDefaultRRCEHome();
 }
+var RRCE_HOME, RRCE_WORKSPACE;
+var init_paths = __esm({
+  "src/lib/paths.ts"() {
+    "use strict";
+    RRCE_HOME = process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
+    RRCE_WORKSPACE = process.env.RRCE_WORKSPACE;
+  }
+});
+
+// src/lib/autocomplete-prompt.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as readline from "readline";
+import pc from "picocolors";
+function directoryPrompt(opts) {
+  return new Promise((resolve) => {
+    process.stdout.write(`${pc.cyan("\u25C6")}  ${opts.message}
+`);
+    process.stdout.write(`${pc.cyan("\u2502")}  `);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      completer: completeDirectory,
+      terminal: true
+    });
+    if (opts.defaultValue) {
+      rl.write(opts.defaultValue);
+    }
+    rl.on("line", (input) => {
+      const value = input.trim();
+      const expandedPath = value.startsWith("~") ? value.replace(/^~/, process.env.HOME || "") : value;
+      if (opts.validate) {
+        const error = opts.validate(expandedPath);
+        if (error) {
+          process.stdout.write(`${pc.yellow("\u2502")}  ${pc.yellow(error)}
+`);
+          process.stdout.write(`${pc.cyan("\u2502")}  `);
+          rl.write(value);
+          return;
+        }
+      }
+      rl.close();
+      process.stdout.write(`${pc.green("\u2713")}  ${pc.dim(expandedPath)}
+`);
+      resolve(expandedPath);
+    });
+    rl.on("close", () => {
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve(/* @__PURE__ */ Symbol("cancel"));
+    });
+  });
+}
+function completeDirectory(line) {
+  const expanded = line.startsWith("~") ? line.replace(/^~/, process.env.HOME || "") : line;
+  try {
+    let dirToScan;
+    let prefix;
+    let basePath;
+    if (expanded === "" || expanded === "/") {
+      dirToScan = expanded || "/";
+      prefix = "";
+      basePath = expanded;
+    } else if (expanded.endsWith("/")) {
+      dirToScan = expanded;
+      prefix = "";
+      basePath = expanded;
+    } else {
+      dirToScan = path6.dirname(expanded);
+      prefix = path6.basename(expanded).toLowerCase();
+      basePath = dirToScan === "/" ? "/" : dirToScan + "/";
+    }
+    if (!fs6.existsSync(dirToScan)) {
+      return [[], line];
+    }
+    const entries = fs6.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
+      if (!entry.isDirectory()) return false;
+      if (entry.name.startsWith(".") && !prefix.startsWith(".")) return false;
+      return prefix === "" || entry.name.toLowerCase().startsWith(prefix);
+    }).map((entry) => {
+      const fullPath = path6.join(dirToScan, entry.name);
+      const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
+      return displayPath + "/";
+    }).sort();
+    if (entries.length === 1) {
+      return [entries, line];
+    }
+    if (entries.length > 1) {
+      const commonPrefix = getCommonPrefix(entries);
+      if (commonPrefix.length > line.length) {
+        return [[commonPrefix], line];
+      }
+    }
+    return [entries, line];
+  } catch {
+    return [[], line];
+  }
+}
+function getCommonPrefix(strings) {
+  if (strings.length === 0) return "";
+  if (strings.length === 1) return strings[0] || "";
+  let prefix = strings[0] || "";
+  for (let i = 1; i < strings.length; i++) {
+    const str = strings[i] || "";
+    while (prefix.length > 0 && !str.startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+    }
+  }
+  return prefix;
+}
+function isCancelled(value) {
+  return typeof value === "symbol";
+}
+var init_autocomplete_prompt = __esm({
+  "src/lib/autocomplete-prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/tui-utils.ts
+var tui_utils_exports = {};
+__export(tui_utils_exports, {
+  resolveGlobalPath: () => resolveGlobalPath
+});
+import { select, note, isCancel } from "@clack/prompts";
+import pc2 from "picocolors";
+import * as path7 from "path";
+async function resolveGlobalPath() {
+  const defaultPath = getDefaultRRCEHome();
+  const isDefaultWritable = checkWriteAccess(defaultPath);
+  const options = [
+    {
+      value: "default",
+      label: `Default (${defaultPath})`,
+      hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
+    },
+    {
+      value: "custom",
+      label: "Custom path",
+      hint: "Specify your own directory"
+    }
+  ];
+  const choice = await select({
+    message: "Global storage location:",
+    options,
+    initialValue: isDefaultWritable ? "default" : "custom"
+  });
+  if (isCancel(choice)) {
+    return void 0;
+  }
+  if (choice === "default") {
+    if (!isDefaultWritable) {
+      note(
+        `${pc2.yellow("\u26A0")} Cannot write to default path:
+  ${pc2.dim(defaultPath)}
+
+This can happen when running via npx/bunx in restricted environments.
+Please choose a custom path instead.`,
+        "Write Access Issue"
+      );
+      return resolveGlobalPath();
+    }
+    return defaultPath;
+  }
+  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const customPath = await directoryPrompt({
+    message: "Enter custom global path (Tab to autocomplete):",
+    defaultValue: suggestedPath,
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Path cannot be empty";
+      }
+      if (!checkWriteAccess(value)) {
+        return `Cannot write to ${value}. Please choose a writable path.`;
+      }
+      return void 0;
+    }
+  });
+  if (isCancelled(customPath)) {
+    return void 0;
+  }
+  let expandedPath = customPath;
+  if (!expandedPath.endsWith(".rrce-workflow")) {
+    expandedPath = path7.join(expandedPath, ".rrce-workflow");
+  }
+  return expandedPath;
+}
+var init_tui_utils = __esm({
+  "src/lib/tui-utils.ts"() {
+    "use strict";
+    init_paths();
+    init_autocomplete_prompt();
+  }
+});
+
+// src/commands/wizard/index.ts
+import { intro, select as select3, spinner as spinner5, note as note6, outro as outro5, isCancel as isCancel6 } from "@clack/prompts";
+import pc7 from "picocolors";
+import * as fs11 from "fs";
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+function getGitUser() {
+  try {
+    const result = execSync("git config user.name", { encoding: "utf-8" });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/wizard/index.ts
+init_paths();
 
 // src/lib/detection.ts
+init_paths();
 import * as fs2 from "fs";
 import * as path2 from "path";
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -279,10 +487,11 @@ function parseWorkspaceConfig(configPath) {
 }
 
 // src/commands/wizard/setup-flow.ts
-import { group, select, multiselect, confirm, spinner, note, outro, cancel, isCancel } from "@clack/prompts";
-import pc2 from "picocolors";
+init_paths();
+import { group, select as select2, multiselect, confirm, spinner, note as note2, outro, cancel } from "@clack/prompts";
+import pc3 from "picocolors";
 import * as fs7 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 
 // src/lib/prompts.ts
 import * as fs3 from "fs";
@@ -355,6 +564,7 @@ function getAgentCorePromptsDir() {
 }
 
 // src/commands/wizard/utils.ts
+init_paths();
 import * as fs4 from "fs";
 import * as path4 from "path";
 function copyPromptsToDir(prompts, targetDir, extension) {
@@ -381,6 +591,7 @@ function copyDirRecursive(src, dest) {
 }
 
 // src/commands/wizard/vscode.ts
+init_paths();
 import * as fs5 from "fs";
 import * as path5 from "path";
 function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
@@ -458,124 +669,18 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
     workspace.settings["files.readonlyInclude"] = {
       ...cleanedReadonly,
       ...readonlyPatterns
-    };
-  }
-  fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
-}
-
-// src/lib/autocomplete-prompt.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
-import * as readline from "readline";
-import pc from "picocolors";
-function directoryPrompt(opts) {
-  return new Promise((resolve) => {
-    process.stdout.write(`${pc.cyan("\u25C6")}  ${opts.message}
-`);
-    process.stdout.write(`${pc.cyan("\u2502")}  `);
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      completer: completeDirectory,
-      terminal: true
-    });
-    if (opts.defaultValue) {
-      rl.write(opts.defaultValue);
-    }
-    rl.on("line", (input) => {
-      const value = input.trim();
-      const expandedPath = value.startsWith("~") ? value.replace(/^~/, process.env.HOME || "") : value;
-      if (opts.validate) {
-        const error = opts.validate(expandedPath);
-        if (error) {
-          process.stdout.write(`${pc.yellow("\u2502")}  ${pc.yellow(error)}
-`);
-          process.stdout.write(`${pc.cyan("\u2502")}  `);
-          rl.write(value);
-          return;
-        }
-      }
-      rl.close();
-      process.stdout.write(`${pc.green("\u2713")}  ${pc.dim(expandedPath)}
-`);
-      resolve(expandedPath);
-    });
-    rl.on("close", () => {
-    });
-    rl.on("SIGINT", () => {
-      rl.close();
-      process.stdout.write("\n");
-      resolve(/* @__PURE__ */ Symbol("cancel"));
-    });
-  });
-}
-function completeDirectory(line) {
-  const expanded = line.startsWith("~") ? line.replace(/^~/, process.env.HOME || "") : line;
-  try {
-    let dirToScan;
-    let prefix;
-    let basePath;
-    if (expanded === "" || expanded === "/") {
-      dirToScan = expanded || "/";
-      prefix = "";
-      basePath = expanded;
-    } else if (expanded.endsWith("/")) {
-      dirToScan = expanded;
-      prefix = "";
-      basePath = expanded;
-    } else {
-      dirToScan = path6.dirname(expanded);
-      prefix = path6.basename(expanded).toLowerCase();
-      basePath = dirToScan === "/" ? "/" : dirToScan + "/";
-    }
-    if (!fs6.existsSync(dirToScan)) {
-      return [[], line];
-    }
-    const entries = fs6.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
-      if (!entry.isDirectory()) return false;
-      if (entry.name.startsWith(".") && !prefix.startsWith(".")) return false;
-      return prefix === "" || entry.name.toLowerCase().startsWith(prefix);
-    }).map((entry) => {
-      const fullPath = path6.join(dirToScan, entry.name);
-      const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
-      return displayPath + "/";
-    }).sort();
-    if (entries.length === 1) {
-      return [entries, line];
-    }
-    if (entries.length > 1) {
-      const commonPrefix = getCommonPrefix(entries);
-      if (commonPrefix.length > line.length) {
-        return [[commonPrefix], line];
-      }
-    }
-    return [entries, line];
-  } catch {
-    return [[], line];
-  }
-}
-function getCommonPrefix(strings) {
-  if (strings.length === 0) return "";
-  if (strings.length === 1) return strings[0] || "";
-  let prefix = strings[0] || "";
-  for (let i = 1; i < strings.length; i++) {
-    const str = strings[i] || "";
-    while (prefix.length > 0 && !str.startsWith(prefix)) {
-      prefix = prefix.slice(0, -1);
-    }
+    };
   }
-  return prefix;
-}
-function isCancelled(value) {
-  return typeof value === "symbol";
+  fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
 
 // src/commands/wizard/setup-flow.ts
+init_tui_utils();
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const s = spinner();
   const config = await group(
     {
-      storageMode: () => select({
+      storageMode: () => select2({
         message: "Where should workflow data be stored?",
         options: [
           { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Cross-project access, clean workspace" },
@@ -600,8 +705,8 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
           options: existingProjects.map((project) => ({
             value: `${project.name}:${project.source}`,
             // Unique key
-            label: `${project.name} ${pc2.dim(`(${project.source})`)}`,
-            hint: pc2.dim(
+            label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
+            hint: pc3.dim(
               project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
             )
           })),
@@ -609,7 +714,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
         });
       },
       addToGitignore: () => confirm({
-        message: "Add generated folders to .gitignore?",
+        message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
         initialValue: true
       }),
       confirm: () => confirm({
@@ -656,7 +761,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       `Storage: ${config.storageMode}`
     ];
     if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc2.cyan(customGlobalPath)}`);
+      summary.push(`Global path: ${pc3.cyan(customGlobalPath)}`);
     }
     if (dataPaths.length > 0) {
       summary.push(`Data paths:`);
@@ -669,13 +774,13 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     const linkedProjects = config.linkedProjects;
     if (linkedProjects.length > 0) {
       summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
-      summary.push(`Workspace file: ${pc2.cyan(`${workspaceName}.code-workspace`)}`);
+      summary.push(`Workspace file: ${pc3.cyan(`${workspaceName}.code-workspace`)}`);
     }
-    note(summary.join("\n"), "Setup Summary");
+    note2(summary.join("\n"), "Setup Summary");
     if (linkedProjects.length > 0) {
-      outro(pc2.green(`\u2713 Setup complete! Open ${pc2.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+      outro(pc3.green(`\u2713 Setup complete! Open ${pc3.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
     } else {
-      outro(pc2.green(`\u2713 Setup complete! Your agents are ready to use.`));
+      outro(pc3.green(`\u2713 Setup complete! Your agents are ready to use.`));
     }
   } catch (error) {
     s.stop("Error occurred");
@@ -683,77 +788,18 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     process.exit(1);
   }
 }
-async function resolveGlobalPath() {
-  const defaultPath = getDefaultRRCEHome();
-  const isDefaultWritable = checkWriteAccess(defaultPath);
-  const options = [];
-  options.push({
-    value: "default",
-    label: `Default (${defaultPath})`,
-    hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
-  });
-  options.push({
-    value: "custom",
-    label: "Custom path",
-    hint: "Specify your own directory"
-  });
-  const choice = await select({
-    message: "Global storage location:",
-    options,
-    initialValue: isDefaultWritable ? "default" : "custom"
-  });
-  if (isCancel(choice)) {
-    return void 0;
-  }
-  if (choice === "default") {
-    if (!isDefaultWritable) {
-      note(
-        `${pc2.yellow("\u26A0")} Cannot write to default path:
-  ${pc2.dim(defaultPath)}
-
-This can happen when running via npx/bunx in restricted environments.
-Please choose a custom path instead.`,
-        "Write Access Issue"
-      );
-      return resolveGlobalPath();
-    }
-    return defaultPath;
-  }
-  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
-  const customPath = await directoryPrompt({
-    message: "Enter custom global path (Tab to autocomplete):",
-    defaultValue: suggestedPath,
-    validate: (value) => {
-      if (!value.trim()) {
-        return "Path cannot be empty";
-      }
-      if (!checkWriteAccess(value)) {
-        return `Cannot write to ${value}. Please choose a writable path.`;
-      }
-      return void 0;
-    }
-  });
-  if (isCancelled(customPath)) {
-    return void 0;
-  }
-  let expandedPath = customPath;
-  if (!expandedPath.endsWith(".rrce-workflow")) {
-    expandedPath = path7.join(expandedPath, ".rrce-workflow");
-  }
-  return expandedPath;
-}
 async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path7.join(dataPath, "knowledge"));
-    ensureDir(path7.join(dataPath, "refs"));
-    ensureDir(path7.join(dataPath, "tasks"));
-    ensureDir(path7.join(dataPath, "templates"));
+    ensureDir(path8.join(dataPath, "knowledge"));
+    ensureDir(path8.join(dataPath, "refs"));
+    ensureDir(path8.join(dataPath, "tasks"));
+    ensureDir(path8.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path7.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (config.tools.includes("copilot")) {
     const copilotPath = getAgentPromptPath(workspacePath, "copilot");
@@ -765,8 +811,8 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
     ensureDir(antigravityPath);
     copyPromptsToDir(prompts, antigravityPath, ".md");
   }
-  const workspaceConfigPath = path7.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path7.dirname(workspaceConfigPath));
+  const workspaceConfigPath = path8.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path8.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -806,8 +852,8 @@ linked_projects:
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path7.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path7.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path8.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -818,7 +864,7 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
   }
 }
 function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path7.join(workspacePath, ".gitignore");
+  const gitignorePath = path8.join(workspacePath, ".gitignore");
   const entries = [];
   if (storageMode === "workspace") {
     entries.push(".rrce-workflow/");
@@ -841,7 +887,11 @@ function updateGitignore(workspacePath, storageMode, tools) {
     const newEntries = [];
     for (const entry of entries) {
       const entryWithoutSlash = entry.replace(/\/$/, "");
-      if (!lines.some((line) => line === entry || line === entryWithoutSlash)) {
+      const commentedEntry = `# ${entry}`;
+      const commentedEntryNoSlash = `# ${entryWithoutSlash}`;
+      if (!lines.some(
+        (line) => line === entry || line === entryWithoutSlash || line === commentedEntry || line === commentedEntryNoSlash
+      )) {
         newEntries.push(entry);
       }
     }
@@ -853,9 +903,9 @@ function updateGitignore(workspacePath, storageMode, tools) {
       newContent += "\n";
     }
     if (newContent === "" || !content.includes("# rrce-workflow")) {
-      newContent += "\n# rrce-workflow generated folders\n";
+      newContent += "\n# rrce-workflow generated folders (uncomment to ignore)\n";
     }
-    newContent += newEntries.join("\n") + "\n";
+    newContent += newEntries.map((e) => `# ${e}`).join("\n") + "\n";
     fs7.writeFileSync(gitignorePath, newContent);
     return true;
   } catch {
@@ -864,8 +914,9 @@ function updateGitignore(workspacePath, storageMode, tools) {
 }
 
 // src/commands/wizard/link-flow.ts
-import { multiselect as multiselect2, spinner as spinner2, note as note2, outro as outro2, cancel as cancel2, isCancel as isCancel2 } from "@clack/prompts";
-import pc3 from "picocolors";
+init_paths();
+import { multiselect as multiselect2, spinner as spinner2, note as note3, outro as outro2, cancel as cancel2, isCancel as isCancel3 } from "@clack/prompts";
+import pc4 from "picocolors";
 import * as fs8 from "fs";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
@@ -873,7 +924,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     workspacePath
   });
   if (projects.length === 0) {
-    outro2(pc3.yellow("No other projects found. Try setting up another project first."));
+    outro2(pc4.yellow("No other projects found. Try setting up another project first."));
     return;
   }
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
@@ -882,14 +933,14 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     options: projects.map((project) => ({
       value: `${project.name}:${project.source}`,
       // Unique key
-      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
-      hint: pc3.dim(
+      label: `${project.name} ${pc4.dim(`(${project.source})`)}`,
+      hint: pc4.dim(
         project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
       )
     })),
     required: true
   });
-  if (isCancel2(linkedProjects)) {
+  if (isCancel3(linkedProjects)) {
     cancel2("Cancelled.");
     process.exit(0);
   }
@@ -937,43 +988,44 @@ linked_projects:
   const workspaceFile = `${workspaceName}.code-workspace`;
   const summary = [
     `Linked projects:`,
-    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc3.dim(`(${p.source})`)}`),
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc4.dim(`(${p.source})`)}`),
     ``,
-    `Workspace file: ${pc3.cyan(workspaceFile)}`
+    `Workspace file: ${pc4.cyan(workspaceFile)}`
   ];
-  note2(summary.join("\n"), "Link Summary");
-  outro2(pc3.green(`\u2713 Projects linked! Open ${pc3.bold(workspaceFile)} in VSCode to access linked data.`));
+  note3(summary.join("\n"), "Link Summary");
+  outro2(pc4.green(`\u2713 Projects linked! Open ${pc4.bold(workspaceFile)} in VSCode to access linked data.`));
 }
 
 // src/commands/wizard/sync-flow.ts
-import { confirm as confirm2, spinner as spinner3, note as note3, outro as outro3, cancel as cancel3, isCancel as isCancel3 } from "@clack/prompts";
-import pc4 from "picocolors";
+init_paths();
+import { confirm as confirm2, spinner as spinner3, note as note4, outro as outro3, cancel as cancel3, isCancel as isCancel4 } from "@clack/prompts";
+import pc5 from "picocolors";
 import * as fs9 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs9.existsSync(path8.join(localPath, dir))
+    (dir) => fs9.existsSync(path9.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
-    outro3(pc4.yellow("No data found in workspace storage to sync."));
+    outro3(pc5.yellow("No data found in workspace storage to sync."));
     return;
   }
-  note3(
+  note4(
     `The following will be copied to global storage:
 ${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 
-Destination: ${pc4.cyan(globalPath)}`,
+Destination: ${pc5.cyan(globalPath)}`,
     "Sync Preview"
   );
   const shouldSync = await confirm2({
     message: "Proceed with sync to global storage?",
     initialValue: true
   });
-  if (isCancel3(shouldSync) || !shouldSync) {
+  if (isCancel4(shouldSync) || !shouldSync) {
     outro3("Sync cancelled.");
     return;
   }
@@ -982,8 +1034,8 @@ Destination: ${pc4.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path8.join(localPath, dir);
-      const destDir = path8.join(globalPath, dir);
+      const srcDir = path9.join(localPath, dir);
+      const destDir = path9.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -992,12 +1044,12 @@ Destination: ${pc4.cyan(globalPath)}`,
       `Synced directories:`,
       ...existingDirs.map((d) => `  \u2713 ${d}/`),
       ``,
-      `Global path: ${pc4.cyan(globalPath)}`,
+      `Global path: ${pc5.cyan(globalPath)}`,
       ``,
       `Other projects can now link this knowledge!`
     ];
-    note3(summary.join("\n"), "Sync Summary");
-    outro3(pc4.green("\u2713 Workspace knowledge synced to global storage!"));
+    note4(summary.join("\n"), "Sync Summary");
+    outro3(pc5.green("\u2713 Workspace knowledge synced to global storage!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel3(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
@@ -1006,10 +1058,11 @@ Destination: ${pc4.cyan(globalPath)}`,
 }
 
 // src/commands/wizard/update-flow.ts
-import { confirm as confirm3, spinner as spinner4, note as note4, outro as outro4, cancel as cancel4, isCancel as isCancel4 } from "@clack/prompts";
-import pc5 from "picocolors";
+init_paths();
+import { confirm as confirm3, spinner as spinner4, note as note5, outro as outro4, cancel as cancel4, isCancel as isCancel5 } from "@clack/prompts";
+import pc6 from "picocolors";
 import * as fs10 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner4();
   s.start("Checking for updates");
@@ -1020,7 +1073,7 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const customGlobalPath = getEffectiveRRCEHome(workspacePath);
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     s.stop("Updates found");
-    note4(
+    note5(
       `The following will be updated from the package:
   \u2022 prompts/ (${prompts.length} agent prompts)
   \u2022 templates/ (output templates)
@@ -1033,13 +1086,13 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       message: "Proceed with update?",
       initialValue: true
     });
-    if (isCancel4(shouldUpdate) || !shouldUpdate) {
+    if (isCancel5(shouldUpdate) || !shouldUpdate) {
       outro4("Update cancelled.");
       return;
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path9.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path10.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
     const configContent = fs10.readFileSync(configFilePath, "utf-8");
@@ -1061,8 +1114,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       ``,
       `Your configuration and knowledge files were preserved.`
     ];
-    note4(summary.join("\n"), "Update Summary");
-    outro4(pc5.green("\u2713 Successfully updated from package!"));
+    note5(summary.join("\n"), "Update Summary");
+    outro4(pc6.green("\u2713 Successfully updated from package!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
@@ -1070,8 +1123,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path9.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path10.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -1084,7 +1137,7 @@ function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot,
 
 // src/commands/wizard/index.ts
 async function runWizard() {
-  intro(pc6.cyan(pc6.inverse(" RRCE-Workflow Setup ")));
+  intro(pc7.cyan(pc7.inverse(" RRCE-Workflow Setup ")));
   const s = spinner5();
   s.start("Detecting environment");
   const workspacePath = detectWorkspaceRoot();
@@ -1092,9 +1145,9 @@ async function runWizard() {
   const gitUser = getGitUser();
   await new Promise((r) => setTimeout(r, 800));
   s.stop("Environment detected");
-  note5(
-    `Git User:  ${pc6.bold(gitUser || "(not found)")}
-Workspace: ${pc6.bold(workspaceName)}`,
+  note6(
+    `Git User:  ${pc7.bold(gitUser || "(not found)")}
+Workspace: ${pc7.bold(workspaceName)}`,
     "Context"
   );
   const detectedProjects = scanForProjects({
@@ -1132,11 +1185,11 @@ Workspace: ${pc6.bold(workspaceName)}`,
     }
     menuOptions.push({ value: "update", label: "Update from package", hint: "Get latest prompts & templates" });
     menuOptions.push({ value: "exit", label: "Exit" });
-    const action = await select2({
+    const action = await select3({
       message: "This workspace is already configured. What would you like to do?",
       options: menuOptions
     });
-    if (isCancel5(action) || action === "exit") {
+    if (isCancel6(action) || action === "exit") {
       outro5("Exited.");
       process.exit(0);
     }
@@ -1157,18 +1210,18 @@ Workspace: ${pc6.bold(workspaceName)}`,
 }
 
 // src/commands/selector.ts
-import { intro as intro2, select as select3, note as note6, cancel as cancel6, isCancel as isCancel6, outro as outro6 } from "@clack/prompts";
-import pc7 from "picocolors";
-import * as path10 from "path";
+import { intro as intro2, select as select4, note as note7, cancel as cancel6, isCancel as isCancel7, outro as outro6 } from "@clack/prompts";
+import pc8 from "picocolors";
+import * as path11 from "path";
 async function runSelector() {
-  const workspaceName = path10.basename(process.cwd());
-  intro2(pc7.cyan(pc7.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const workspaceName = path11.basename(process.cwd());
+  intro2(pc8.cyan(pc8.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {
     cancel6("No agents found. Run `rrce-workflow` to set up.");
     process.exit(0);
   }
-  const selection = await select3({
+  const selection = await select4({
     message: "Select an agent:",
     options: prompts.map((p) => ({
       value: p,
@@ -1176,23 +1229,814 @@ async function runSelector() {
       hint: p.frontmatter.description
     }))
   });
-  if (isCancel6(selection)) {
+  if (isCancel7(selection)) {
     cancel6("Selection cancelled.");
     process.exit(0);
   }
   const prompt = selection;
-  note6(
+  note7(
     `Use this agent in your IDE by invoking:
-${pc7.bold(pc7.cyan(`@${prompt.frontmatter.name}`))}`,
+${pc8.bold(pc8.cyan(`@${prompt.frontmatter.name}`))}`,
     "Agent Selected"
   );
   outro6("Done");
 }
 
+// src/mcp/index.ts
+import { intro as intro3, outro as outro7, select as select5, multiselect as multiselect3, confirm as confirm4, spinner as spinner6, note as note8, cancel as cancel7, isCancel as isCancel8 } from "@clack/prompts";
+import pc9 from "picocolors";
+
+// src/mcp/config.ts
+init_paths();
+import * as fs12 from "fs";
+import * as path12 from "path";
+
+// src/mcp/types.ts
+var DEFAULT_MCP_CONFIG = {
+  server: {
+    port: 3e3,
+    autoStart: false
+  },
+  projects: [],
+  defaults: {
+    includeNew: true,
+    permissions: {
+      knowledge: true,
+      tasks: true,
+      refs: true
+    }
+  }
+};
+var DEFAULT_PERMISSIONS = {
+  knowledge: true,
+  tasks: true,
+  refs: true
+};
+
+// src/mcp/config.ts
+function getMCPConfigPath() {
+  const workspaceRoot = detectWorkspaceRoot();
+  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
+  return path12.join(rrceHome, "mcp.yaml");
+}
+function ensureMCPGlobalPath() {
+  const workspaceRoot = detectWorkspaceRoot();
+  const rrceHome = getEffectiveRRCEHome(workspaceRoot);
+  if (rrceHome.startsWith(".") || rrceHome.includes(".rrce-workflow/")) {
+    const configPath = path12.join(workspaceRoot, ".rrce-workflow", "config.yaml");
+    if (fs12.existsSync(configPath)) {
+      const content = fs12.readFileSync(configPath, "utf-8");
+      const modeMatch = content.match(/mode:\s*(global|workspace)/);
+      if (modeMatch?.[1] === "workspace") {
+        return {
+          configured: false,
+          path: rrceHome,
+          reason: "Workspace mode configured. MCP requires a global storage path."
+        };
+      }
+    }
+  }
+  return {
+    configured: true,
+    path: rrceHome
+  };
+}
+function loadMCPConfig() {
+  const configPath = getMCPConfigPath();
+  if (!fs12.existsSync(configPath)) {
+    return { ...DEFAULT_MCP_CONFIG };
+  }
+  try {
+    const content = fs12.readFileSync(configPath, "utf-8");
+    return parseMCPConfig(content);
+  } catch {
+    return { ...DEFAULT_MCP_CONFIG };
+  }
+}
+function saveMCPConfig(config) {
+  const configPath = getMCPConfigPath();
+  const dir = path12.dirname(configPath);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
+  }
+  const content = serializeMCPConfig(config);
+  fs12.writeFileSync(configPath, content);
+}
+function parseMCPConfig(content) {
+  const config = { ...DEFAULT_MCP_CONFIG, projects: [] };
+  const portMatch = content.match(/port:\s*(\d+)/);
+  if (portMatch?.[1]) config.server.port = parseInt(portMatch[1], 10);
+  const autoStartMatch = content.match(/autoStart:\s*(true|false)/);
+  if (autoStartMatch) config.server.autoStart = autoStartMatch[1] === "true";
+  const includeNewMatch = content.match(/includeNew:\s*(true|false)/);
+  if (includeNewMatch) config.defaults.includeNew = includeNewMatch[1] === "true";
+  const projectsMatch = content.match(/projects:\s*\n((?:\s+-[\s\S]*?(?=\n\w|\n*$))+)/);
+  if (projectsMatch?.[1]) {
+    const projectsContent = projectsMatch[1];
+    const projectBlocks = projectsContent.split(/\n\s+-\s+name:/).filter(Boolean);
+    for (const block of projectBlocks) {
+      const nameMatch = block.match(/(?:^|\n\s*)name:\s*[\"']?([^\"'\n]+)[\"']?/) || block.match(/^[\"']?([^\"'\n:]+)[\"']?/);
+      const exposeMatch = block.match(/expose:\s*(true|false)/);
+      if (nameMatch?.[1]) {
+        const permissions = parsePermissions(block);
+        config.projects.push({
+          name: nameMatch[1].trim(),
+          expose: exposeMatch ? exposeMatch[1] === "true" : true,
+          permissions
+        });
+      }
+    }
+  }
+  return config;
+}
+function parsePermissions(block) {
+  const permissions = { ...DEFAULT_PERMISSIONS };
+  const knowledgeMatch = block.match(/knowledge:\s*(true|false)/);
+  if (knowledgeMatch) permissions.knowledge = knowledgeMatch[1] === "true";
+  const tasksMatch = block.match(/tasks:\s*(true|false)/);
+  if (tasksMatch) permissions.tasks = tasksMatch[1] === "true";
+  const refsMatch = block.match(/refs:\s*(true|false)/);
+  if (refsMatch) permissions.refs = refsMatch[1] === "true";
+  return permissions;
+}
+function serializeMCPConfig(config) {
+  let content = `# RRCE MCP Hub Configuration
+# Manages which projects are exposed via MCP
+
+server:
+  port: ${config.server.port}
+  autoStart: ${config.server.autoStart}
+
+defaults:
+  includeNew: ${config.defaults.includeNew}
+  permissions:
+    knowledge: ${config.defaults.permissions.knowledge}
+    tasks: ${config.defaults.permissions.tasks}
+    refs: ${config.defaults.permissions.refs}
+
+projects:
+`;
+  if (config.projects.length === 0) {
+    content += '  # No projects configured yet. Run "rrce-workflow mcp" to add projects.\n';
+  } else {
+    for (const project of config.projects) {
+      content += `  - name: "${project.name}"
+    expose: ${project.expose}
+    permissions:
+      knowledge: ${project.permissions.knowledge}
+      tasks: ${project.permissions.tasks}
+      refs: ${project.permissions.refs}
+`;
+    }
+  }
+  return content;
+}
+function setProjectConfig(config, name, expose, permissions) {
+  const existing = config.projects.find((p) => p.name === name);
+  if (existing) {
+    existing.expose = expose;
+    if (permissions) {
+      existing.permissions = { ...existing.permissions, ...permissions };
+    }
+  } else {
+    config.projects.push({
+      name,
+      expose,
+      permissions: permissions ? { ...DEFAULT_PERMISSIONS, ...permissions } : { ...DEFAULT_PERMISSIONS }
+    });
+  }
+  return config;
+}
+function isProjectExposed(config, name) {
+  const project = config.projects.find((p) => p.name === name);
+  if (project) {
+    return project.expose;
+  }
+  return config.defaults.includeNew;
+}
+function getProjectPermissions(config, name) {
+  const project = config.projects.find((p) => p.name === name);
+  return project?.permissions ?? config.defaults.permissions;
+}
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs14 from "fs";
+import * as path14 from "path";
+
+// src/mcp/resources.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+function getExposedProjects() {
+  const config = loadMCPConfig();
+  const allProjects = scanForProjects();
+  return allProjects.filter((project) => isProjectExposed(config, project.name));
+}
+function getProjectContext(projectName) {
+  const config = loadMCPConfig();
+  if (!isProjectExposed(config, projectName)) {
+    return null;
+  }
+  const permissions = getProjectPermissions(config, projectName);
+  if (!permissions.knowledge) {
+    return null;
+  }
+  const projects = scanForProjects();
+  const project = projects.find((p) => p.name === projectName);
+  if (!project?.knowledgePath) {
+    return null;
+  }
+  const contextPath = path13.join(project.knowledgePath, "project-context.md");
+  if (!fs13.existsSync(contextPath)) {
+    return null;
+  }
+  return fs13.readFileSync(contextPath, "utf-8");
+}
+function getProjectTasks(projectName) {
+  const config = loadMCPConfig();
+  if (!isProjectExposed(config, projectName)) {
+    return [];
+  }
+  const permissions = getProjectPermissions(config, projectName);
+  if (!permissions.tasks) {
+    return [];
+  }
+  const projects = scanForProjects();
+  const project = projects.find((p) => p.name === projectName);
+  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 = path13.join(project.tasksPath, dir.name, "meta.json");
+      if (fs13.existsSync(metaPath)) {
+        try {
+          const meta = JSON.parse(fs13.readFileSync(metaPath, "utf-8"));
+          tasks.push(meta);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return tasks;
+}
+function searchKnowledge(query) {
+  const config = loadMCPConfig();
+  const projects = getExposedProjects();
+  const results = [];
+  const queryLower = query.toLowerCase();
+  for (const project of projects) {
+    const permissions = getProjectPermissions(config, project.name);
+    if (!permissions.knowledge || !project.knowledgePath) continue;
+    try {
+      const files = fs13.readdirSync(project.knowledgePath);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const filePath = path13.join(project.knowledgePath, file);
+        const content = fs13.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        const matches = [];
+        for (const line of lines) {
+          if (line.toLowerCase().includes(queryLower)) {
+            matches.push(line.trim());
+          }
+        }
+        if (matches.length > 0) {
+          results.push({
+            project: project.name,
+            file,
+            matches: matches.slice(0, 5)
+            // Limit to 5 matches per file
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+
+// src/mcp/prompts.ts
+var AGENT_PROMPTS = [
+  {
+    name: "init",
+    description: "Initialize project context by analyzing codebase structure, tech stack, and conventions",
+    file: "init.md",
+    arguments: [
+      { name: "PROJECT_NAME", description: "Project name (optional, auto-detected if omitted)", required: false }
+    ]
+  },
+  {
+    name: "research",
+    description: "Research and clarify requirements for a new task",
+    file: "research_discussion.md",
+    arguments: [
+      { name: "REQUEST", description: "Description of the task or feature to research", required: true },
+      { name: "TASK_SLUG", description: "Kebab-case identifier for the task", required: true },
+      { name: "TITLE", description: "Human-readable title for the task", required: false }
+    ]
+  },
+  {
+    name: "plan",
+    description: "Create an actionable execution plan from research findings",
+    file: "planning_orchestrator.md",
+    arguments: [
+      { name: "TASK_SLUG", description: "Task slug to create plan for", required: true }
+    ]
+  },
+  {
+    name: "execute",
+    description: "Implement the planned work with code and tests",
+    file: "executor.md",
+    arguments: [
+      { name: "TASK_SLUG", description: "Task slug to execute", required: true },
+      { name: "BRANCH", description: "Git branch reference (optional)", required: false }
+    ]
+  },
+  {
+    name: "docs",
+    description: "Generate documentation for completed work",
+    file: "documentation.md",
+    arguments: [
+      { name: "DOC_TYPE", description: "Type of documentation (api, architecture, runbook, changelog)", required: true },
+      { name: "TASK_SLUG", description: "Task slug if documenting specific task", required: false }
+    ]
+  },
+  {
+    name: "sync",
+    description: "Reconcile knowledge base with actual codebase state",
+    file: "sync.md",
+    arguments: [
+      { name: "SCOPE", description: "Specific path or module to sync (optional)", required: false }
+    ]
+  }
+];
+
+// src/mcp/server.ts
+var serverState = { running: false };
+var mcpServer = null;
+async function startMCPServer() {
+  const config = loadMCPConfig();
+  mcpServer = new Server(
+    { name: "rrce-mcp-hub", version: "1.0.0" },
+    { capabilities: { resources: {}, tools: {}, prompts: {} } }
+  );
+  registerResourceHandlers(mcpServer);
+  registerToolHandlers(mcpServer);
+  registerPromptHandlers(mcpServer);
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+  serverState = { running: true, port: config.server.port, pid: process.pid };
+  console.error(`RRCE MCP Hub started (pid: ${process.pid})`);
+  console.error(`Exposed projects: ${getExposedProjects().map((p) => p.name).join(", ")}`);
+  return { port: config.server.port, pid: process.pid };
+}
+function registerResourceHandlers(server) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const projects = getExposedProjects();
+    const resources = [];
+    resources.push({
+      uri: "rrce://projects",
+      name: "Project List",
+      description: "List of all RRCE projects exposed via MCP",
+      mimeType: "application/json"
+    });
+    for (const project of projects) {
+      const config = loadMCPConfig();
+      const permissions = getProjectPermissions(config, project.name);
+      if (permissions.knowledge) {
+        resources.push({
+          uri: `rrce://projects/${project.name}/context`,
+          name: `${project.name} - Project Context`,
+          description: `Project context and architecture for ${project.name}`,
+          mimeType: "text/markdown"
+        });
+      }
+      if (permissions.tasks) {
+        resources.push({
+          uri: `rrce://projects/${project.name}/tasks`,
+          name: `${project.name} - Tasks`,
+          description: `Task list and status for ${project.name}`,
+          mimeType: "application/json"
+        });
+      }
+    }
+    return { resources };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === "rrce://projects") {
+      const projects = getExposedProjects();
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(projects.map((p) => ({ name: p.name, source: p.source, path: p.path })), null, 2)
+        }]
+      };
+    }
+    const projectMatch = uri.match(/^rrce:\/\/projects\/([^/]+)\/(.+)$/);
+    if (projectMatch) {
+      const [, projectName, resourceType] = projectMatch;
+      const content = resourceType === "context" ? getProjectContext(projectName) : JSON.stringify(getProjectTasks(projectName), null, 2);
+      if (content === null) throw new Error(`Resource not found: ${uri}`);
+      return {
+        contents: [{
+          uri,
+          mimeType: resourceType === "tasks" ? "application/json" : "text/markdown",
+          text: content
+        }]
+      };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  });
+}
+function registerToolHandlers(server) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "search_knowledge",
+        description: "Search across all exposed project knowledge bases",
+        inputSchema: {
+          type: "object",
+          properties: { query: { type: "string", description: "Search query to find in knowledge files" } },
+          required: ["query"]
+        }
+      },
+      {
+        name: "list_projects",
+        description: "List all projects exposed via MCP",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_project_context",
+        description: "Get the project context/architecture for a specific project",
+        inputSchema: {
+          type: "object",
+          properties: { project: { type: "string", description: "Name of the project to get context for" } },
+          required: ["project"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+      case "search_knowledge": {
+        const results = searchKnowledge(args.query);
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+      }
+      case "list_projects": {
+        const projects = getExposedProjects();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(projects.map((p) => ({ name: p.name, source: p.source, path: p.path })), null, 2)
+          }]
+        };
+      }
+      case "get_project_context": {
+        const context = getProjectContext(args.project);
+        if (!context) {
+          return { content: [{ type: "text", text: `No project context found for "${args.project}"` }], isError: true };
+        }
+        return { content: [{ type: "text", text: context }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  });
+}
+function registerPromptHandlers(server) {
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: AGENT_PROMPTS.map((p) => ({
+      name: p.name,
+      description: p.description,
+      arguments: p.arguments.map((a) => ({ name: a.name, description: a.description, required: a.required }))
+    }))
+  }));
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const promptDef = AGENT_PROMPTS.find((p) => p.name === name);
+    if (!promptDef) throw new Error(`Unknown prompt: ${name}`);
+    const promptsDir = getAgentCorePromptsDir();
+    const promptPath = path14.join(promptsDir, promptDef.file);
+    if (!fs14.existsSync(promptPath)) throw new Error(`Prompt file not found: ${promptDef.file}`);
+    let promptContent = fs14.readFileSync(promptPath, "utf-8");
+    if (args) {
+      for (const [key, value] of Object.entries(args)) {
+        promptContent = promptContent.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), String(value));
+      }
+    }
+    return {
+      description: promptDef.description,
+      messages: [{ role: "user", content: { type: "text", text: promptContent } }]
+    };
+  });
+}
+function stopMCPServer() {
+  if (mcpServer) {
+    mcpServer.close();
+    mcpServer = null;
+  }
+  serverState = { running: false };
+  console.error("RRCE MCP Hub stopped");
+}
+function getMCPServerStatus() {
+  return { ...serverState };
+}
+
+// src/mcp/index.ts
+async function runMCP(subcommand2) {
+  if (subcommand2) {
+    switch (subcommand2) {
+      case "start":
+        await startMCPServer();
+        await new Promise(() => {
+        });
+        return;
+      case "stop":
+        await handleStopServer();
+        return;
+      case "status":
+        await handleShowStatus();
+        return;
+      case "help":
+        showHelp();
+        return;
+    }
+  }
+  intro3(pc9.bgCyan(pc9.black(" RRCE MCP Hub ")));
+  const globalPathCheck = await ensureMCPGlobalPath();
+  if (!globalPathCheck.configured) {
+    const configured = await handleConfigureGlobalPath();
+    if (!configured) {
+      outro7(pc9.yellow("MCP requires a global storage path. Setup cancelled."));
+      return;
+    }
+  }
+  let running = true;
+  while (running) {
+    const action = await select5({
+      message: "What would you like to do?",
+      options: [
+        { value: "status", label: "\u{1F4CB} View project status", hint: "See which projects are exposed" },
+        { value: "configure", label: "\u2699\uFE0F  Configure projects", hint: "Choose which projects to expose" },
+        { value: "start", label: "\u25B6\uFE0F  Start MCP server", hint: "Start the MCP server" },
+        { value: "stop", label: "\u23F9\uFE0F  Stop MCP server", hint: "Stop the running server" },
+        { value: "help", label: "\u2753 Help", hint: "Learn about MCP Hub" },
+        { value: "exit", label: "\u21A9  Exit", hint: "Return to shell" }
+      ]
+    });
+    if (isCancel8(action)) {
+      cancel7("MCP Hub closed.");
+      return;
+    }
+    switch (action) {
+      case "status":
+        await handleShowStatus();
+        break;
+      case "configure":
+        await handleConfigure();
+        break;
+      case "start":
+        await handleStartServer();
+        running = false;
+        break;
+      case "stop":
+        await handleStopServer();
+        break;
+      case "help":
+        showHelp();
+        break;
+      case "exit":
+        running = false;
+        break;
+    }
+  }
+  outro7(pc9.green("MCP Hub closed."));
+}
+async function handleConfigureGlobalPath() {
+  const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
+  const fs15 = await import("fs");
+  const path15 = await import("path");
+  note8(
+    `MCP Hub requires a ${pc9.bold("global storage path")} to store its configuration
+and coordinate across projects.
+
+Your current setup uses ${pc9.cyan("workspace")} mode, which stores data
+locally in each project. MCP needs a central location.`,
+    "Global Path Required"
+  );
+  const resolvedPath = await resolveGlobalPath2();
+  if (!resolvedPath) {
+    return false;
+  }
+  try {
+    if (!fs15.existsSync(resolvedPath)) {
+      fs15.mkdirSync(resolvedPath, { recursive: true });
+    }
+    const config = loadMCPConfig();
+    saveMCPConfig(config);
+    note8(
+      `${pc9.green("\u2713")} Global path configured: ${pc9.cyan(resolvedPath)}
+
+MCP config will be stored at:
+${path15.join(resolvedPath, "mcp.yaml")}`,
+      "Configuration Saved"
+    );
+    return true;
+  } catch (error) {
+    note8(
+      `${pc9.red("\u2717")} Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
+      "Error"
+    );
+    return false;
+  }
+}
+async function handleShowStatus() {
+  const s = spinner6();
+  s.start("Loading projects...");
+  const config = loadMCPConfig();
+  const projects = scanForProjects();
+  s.stop("Projects loaded");
+  if (projects.length === 0) {
+    note8('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
+    return;
+  }
+  const lines = [
+    `${pc9.bold("Project Status")}`,
+    ""
+  ];
+  for (const project of projects) {
+    const projectConfig = config.projects.find((p) => p.name === project.name);
+    const isExposed = projectConfig?.expose ?? config.defaults.includeNew;
+    const status = isExposed ? pc9.green("\u2713 exposed") : pc9.dim("\u25CB hidden");
+    const source = pc9.dim(`(${project.source})`);
+    lines.push(`  ${status}  ${project.name} ${source}`);
+  }
+  lines.push("");
+  lines.push(pc9.dim(`Config: ${getMCPConfigPath()}`));
+  const serverStatus = getMCPServerStatus();
+  if (serverStatus.running) {
+    lines.push(pc9.green(`Server: running on port ${serverStatus.port}`));
+  } else {
+    lines.push(pc9.dim("Server: not running"));
+  }
+  note8(lines.join("\n"), "MCP Hub Status");
+}
+async function handleConfigure() {
+  const s = spinner6();
+  s.start("Scanning for projects...");
+  const config = loadMCPConfig();
+  const projects = scanForProjects();
+  s.stop("Projects found");
+  if (projects.length === 0) {
+    note8('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
+    return;
+  }
+  const options = projects.map((project) => {
+    const projectConfig = config.projects.find((p) => p.name === project.name);
+    const isExposed = projectConfig?.expose ?? config.defaults.includeNew;
+    return {
+      value: project.name,
+      label: `${project.name} ${pc9.dim(`(${project.source})`)}`,
+      hint: project.dataPath
+    };
+  });
+  const currentlyExposed = projects.filter((p) => {
+    const cfg = config.projects.find((c) => c.name === p.name);
+    return cfg?.expose ?? config.defaults.includeNew;
+  }).map((p) => p.name);
+  const selected = await multiselect3({
+    message: "Select projects to expose via MCP:",
+    options,
+    initialValues: currentlyExposed,
+    required: false
+  });
+  if (isCancel8(selected)) {
+    return;
+  }
+  const selectedNames = selected;
+  for (const project of projects) {
+    const shouldExpose = selectedNames.includes(project.name);
+    setProjectConfig(config, project.name, shouldExpose);
+  }
+  saveMCPConfig(config);
+  const exposedCount = selectedNames.length;
+  note8(
+    `${pc9.green("\u2713")} Configuration saved!
+
+Exposed projects: ${exposedCount}
+Hidden projects: ${projects.length - exposedCount}`,
+    "Configuration Updated"
+  );
+}
+async function handleStartServer() {
+  const s = spinner6();
+  s.start("Starting MCP server...");
+  try {
+    const result = await startMCPServer();
+    s.stop(pc9.green(`MCP server started on port ${result.port}`));
+    note8(
+      `The MCP server is now running.
+
+To connect from Claude Desktop, add to your config:
+` + pc9.cyan(`~/.config/claude/claude_desktop_config.json`),
+      "Server Started"
+    );
+  } catch (error) {
+    s.stop(pc9.red("Failed to start server"));
+    note8(
+      `Error: ${error instanceof Error ? error.message : String(error)}`,
+      "Server Error"
+    );
+  }
+}
+async function handleStopServer() {
+  const status = getMCPServerStatus();
+  if (!status.running) {
+    note8("MCP server is not running.", "Status");
+    return;
+  }
+  const confirmed = await confirm4({
+    message: "Stop the MCP server?",
+    initialValue: true
+  });
+  if (isCancel8(confirmed) || !confirmed) {
+    return;
+  }
+  stopMCPServer();
+  note8(pc9.green("MCP server stopped."), "Server Stopped");
+}
+function showHelp() {
+  const help = `
+${pc9.bold("RRCE MCP Hub")} - Cross-project AI assistant server
+
+${pc9.bold("ABOUT")}
+MCP (Model Context Protocol) allows AI assistants like Claude to 
+access your project knowledge in real-time. The RRCE MCP Hub 
+provides a central server that exposes selected projects.
+
+${pc9.bold("MENU OPTIONS")}
+  ${pc9.cyan("View project status")}   See which projects are exposed
+  ${pc9.cyan("Configure projects")}    Choose which projects to expose
+  ${pc9.cyan("Start MCP server")}      Start the server for AI access
+  ${pc9.cyan("Stop MCP server")}       Stop the running server
+
+${pc9.bold("DIRECT COMMANDS")}
+  ${pc9.dim("rrce-workflow mcp start")}    Start server directly
+  ${pc9.dim("rrce-workflow mcp stop")}     Stop server directly
+  ${pc9.dim("rrce-workflow mcp status")}   Show status directly
+  ${pc9.dim("rrce-workflow mcp help")}     Show this help
+
+${pc9.bold("CLAUDE DESKTOP SETUP")}
+Add to ${pc9.cyan("~/.config/claude/claude_desktop_config.json")}:
+${pc9.dim(`{
+  "mcpServers": {
+    "rrce": {
+      "command": "npx",
+      "args": ["rrce-workflow", "mcp", "start"]
+    }
+  }
+}`)}
+
+${pc9.bold("RESOURCES EXPOSED")}
+  ${pc9.cyan("rrce://projects")}              List all exposed projects
+  ${pc9.cyan("rrce://projects/{name}/context")}  Get project context
+  ${pc9.cyan("rrce://projects/{name}/tasks")}    Get project tasks
+
+${pc9.bold("PROMPTS (Agent Commands)")}
+  ${pc9.cyan("init")}      Initialize project context
+  ${pc9.cyan("research")}  Research requirements for a task
+  ${pc9.cyan("plan")}      Create execution plan
+  ${pc9.cyan("execute")}   Implement planned work
+  ${pc9.cyan("docs")}      Generate documentation
+  ${pc9.cyan("sync")}      Sync knowledge with codebase
+`;
+  note8(help.trim(), "Help");
+}
+
 // src/index.ts
 var command = process.argv[2];
+var subcommand = process.argv[3];
 if (!command || command === "wizard") {
   runWizard();
+} else if (command === "mcp") {
+  runMCP(subcommand);
 } else {
   runSelector();
 }