rrce-workflow 0.2.49 → 0.2.51

package/dist/index.js

@@ -25,29 +25,6 @@ var init_git = __esm({
 });
 
 // src/lib/paths.ts
-var paths_exports = {};
-__export(paths_exports, {
-  checkWriteAccess: () => checkWriteAccess,
-  copyDirToAllStoragePaths: () => copyDirToAllStoragePaths,
-  copyToAllStoragePaths: () => copyToAllStoragePaths,
-  detectWorkspaceRoot: () => detectWorkspaceRoot,
-  ensureDir: () => ensureDir,
-  getAgentPromptPath: () => getAgentPromptPath,
-  getConfigPath: () => getConfigPath,
-  getDefaultRRCEHome: () => getDefaultRRCEHome,
-  getEffectiveRRCEHome: () => getEffectiveRRCEHome,
-  getGlobalProjectKnowledgePath: () => getGlobalProjectKnowledgePath,
-  getGlobalWorkspacePath: () => getGlobalWorkspacePath,
-  getLocalWorkspacePath: () => getLocalWorkspacePath,
-  getRRCEHome: () => getRRCEHome,
-  getSuggestedGlobalPaths: () => getSuggestedGlobalPaths,
-  getWorkspaceName: () => getWorkspaceName,
-  listGlobalProjects: () => listGlobalProjects,
-  resolveAllDataPaths: () => resolveAllDataPaths,
-  resolveDataPath: () => resolveDataPath,
-  syncMetadataToAll: () => syncMetadataToAll,
-  writeToAllStoragePaths: () => writeToAllStoragePaths
-});
 import * as fs from "fs";
 import * as path from "path";
 function detectWorkspaceRoot() {
@@ -77,49 +54,9 @@ function getConfigPath(workspaceRoot) {
 function getWorkspaceName(workspaceRoot) {
   return path.basename(workspaceRoot);
 }
-function resolveDataPath(mode, workspaceName, workspaceRoot) {
-  switch (mode) {
-    case "global":
-      return path.join(RRCE_HOME, "workspaces", workspaceName);
-    case "workspace":
-      return path.join(workspaceRoot, ".rrce-workflow");
-    default:
-      return path.join(RRCE_HOME, "workspaces", workspaceName);
-  }
-}
-function resolveAllDataPaths(mode, workspaceName, workspaceRoot) {
-  const globalPath = path.join(RRCE_HOME, "workspaces", workspaceName);
-  const workspacePath = path.join(workspaceRoot, ".rrce-workflow");
-  switch (mode) {
-    case "global":
-      return [globalPath];
-    case "workspace":
-      return [workspacePath];
-    default:
-      return [globalPath];
-  }
-}
 function getRRCEHome() {
   return RRCE_HOME;
 }
-function listGlobalProjects(excludeWorkspace) {
-  const workspacesDir = path.join(RRCE_HOME, "workspaces");
-  if (!fs.existsSync(workspacesDir)) {
-    return [];
-  }
-  try {
-    const entries = fs.readdirSync(workspacesDir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory() && entry.name !== excludeWorkspace).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
-function getGlobalProjectKnowledgePath(projectName) {
-  return path.join(RRCE_HOME, "workspaces", projectName, "knowledge");
-}
-function getGlobalWorkspacePath(workspaceName) {
-  return path.join(RRCE_HOME, "workspaces", workspaceName);
-}
 function getLocalWorkspacePath(workspaceRoot) {
   return path.join(workspaceRoot, ".rrce-workflow");
 }
@@ -143,13 +80,6 @@ function copyToAllStoragePaths(sourceFile, relativePath, dataPaths) {
     fs.writeFileSync(targetPath, content);
   }
 }
-function writeToAllStoragePaths(content, relativePath, dataPaths) {
-  for (const dataPath of dataPaths) {
-    const targetPath = path.join(dataPath, relativePath);
-    ensureDir(path.dirname(targetPath));
-    fs.writeFileSync(targetPath, content);
-  }
-}
 function copyDirToAllStoragePaths(sourceDir, relativeDir, dataPaths) {
   if (!fs.existsSync(sourceDir)) {
     return;
@@ -194,25 +124,6 @@ function checkWriteAccess(dirPath) {
 function getDefaultRRCEHome() {
   return process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
 }
-function getSuggestedGlobalPaths() {
-  const suggestions = [];
-  if (process.env.RRCE_HOME) {
-    suggestions.push({
-      path: process.env.RRCE_HOME,
-      label: "RRCE_HOME (environment)",
-      isWritable: checkWriteAccess(process.env.RRCE_HOME)
-    });
-  }
-  const homeDefault = path.join(process.env.HOME || "~", ".rrce-workflow");
-  if (!process.env.RRCE_HOME || process.env.RRCE_HOME !== homeDefault) {
-    suggestions.push({
-      path: homeDefault,
-      label: "~/.rrce-workflow (default)",
-      isWritable: checkWriteAccess(homeDefault)
-    });
-  }
-  return suggestions;
-}
 function getEffectiveRRCEHome(workspaceRoot) {
   if (workspaceRoot) {
     const configPath = getConfigPath(workspaceRoot);
@@ -390,212 +301,9 @@ var init_detection = __esm({
   }
 });
 
-// src/types/prompt.ts
-import { z } from "zod";
-var PromptArgSchema, AutoIdentitySchema, PromptFrontmatterSchema;
-var init_prompt = __esm({
-  "src/types/prompt.ts"() {
-    "use strict";
-    PromptArgSchema = z.object({
-      name: z.string(),
-      default: z.string().optional(),
-      prompt: z.string().optional()
-    });
-    AutoIdentitySchema = z.object({
-      user: z.string(),
-      model: z.string()
-    });
-    PromptFrontmatterSchema = z.object({
-      name: z.string(),
-      description: z.string(),
-      "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
-      tools: z.array(z.string()).optional(),
-      "required-args": z.array(PromptArgSchema).optional(),
-      "optional-args": z.array(PromptArgSchema).optional(),
-      "auto-identity": AutoIdentitySchema.optional()
-    });
-  }
-});
-
-// src/lib/prompts.ts
+// src/lib/autocomplete-prompt.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-function parsePromptFile(filePath) {
-  try {
-    const fileContent = fs3.readFileSync(filePath, "utf-8");
-    const { data, content } = matter(fileContent);
-    const parsed = PromptFrontmatterSchema.safeParse(data);
-    if (!parsed.success) {
-      console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
-      return null;
-    }
-    return {
-      frontmatter: parsed.data,
-      content: content.trim(),
-      filePath
-    };
-  } catch (error) {
-    console.error(`Error reading prompt file ${filePath}:`, error);
-    return null;
-  }
-}
-function loadPromptsFromDir(dirPath) {
-  if (!fs3.existsSync(dirPath)) {
-    return [];
-  }
-  const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
-  const prompts = [];
-  for (const file of files) {
-    const prompt = parsePromptFile(path3.join(dirPath, file));
-    if (prompt) {
-      prompts.push(prompt);
-    }
-  }
-  return prompts;
-}
-function getAgentCoreDir() {
-  return path3.join(__dirname, "..", "agent-core");
-}
-function getAgentCorePromptsDir() {
-  return path3.join(getAgentCoreDir(), "prompts");
-}
-var __filename, __dirname;
-var init_prompts = __esm({
-  "src/lib/prompts.ts"() {
-    "use strict";
-    init_prompt();
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path3.dirname(__filename);
-  }
-});
-
-// src/commands/wizard/utils.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-function copyPromptsToDir(prompts, targetDir, extension) {
-  for (const prompt of prompts) {
-    const baseName = path4.basename(prompt.filePath, ".md");
-    const targetName = baseName + extension;
-    const targetPath = path4.join(targetDir, targetName);
-    const content = fs4.readFileSync(prompt.filePath, "utf-8");
-    fs4.writeFileSync(targetPath, content);
-  }
-}
-function copyDirRecursive(src, dest) {
-  const entries = fs4.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path4.join(src, entry.name);
-    const destPath = path4.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs4.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-var init_utils = __esm({
-  "src/commands/wizard/utils.ts"() {
-    "use strict";
-    init_paths();
-  }
-});
-
-// src/commands/wizard/vscode.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
-  const workspaceFilePath = path5.join(workspacePath, `${workspaceName}.code-workspace`);
-  let workspace;
-  if (fs5.existsSync(workspaceFilePath)) {
-    try {
-      const content = fs5.readFileSync(workspaceFilePath, "utf-8");
-      workspace = JSON.parse(content);
-    } catch {
-      workspace = { folders: [], settings: {} };
-    }
-  } else {
-    workspace = { folders: [], settings: {} };
-  }
-  if (!workspace.settings) {
-    workspace.settings = {};
-  }
-  workspace.folders = workspace.folders.filter(
-    (f) => f.path === "." || !f.name?.startsWith("\u{1F4C1}") && !f.name?.startsWith("\u{1F4DA}") && !f.name?.startsWith("\u{1F4CE}") && !f.name?.startsWith("\u{1F4CB}")
-  );
-  const mainFolderIndex = workspace.folders.findIndex((f) => f.path === ".");
-  if (mainFolderIndex === -1) {
-    workspace.folders.unshift({
-      path: ".",
-      name: `\u{1F3E0} ${workspaceName} (workspace)`
-    });
-  } else {
-    workspace.folders[mainFolderIndex] = {
-      path: ".",
-      name: `\u{1F3E0} ${workspaceName} (workspace)`
-    };
-  }
-  const referenceFolderPaths = [];
-  const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === "object";
-  if (isDetectedProjects) {
-    const projects = linkedProjects;
-    for (const project of projects) {
-      const sourceLabel = project.source === "global" ? "global" : "local";
-      const folderPath = project.dataPath;
-      if (fs5.existsSync(folderPath)) {
-        referenceFolderPaths.push(folderPath);
-        workspace.folders.push({
-          path: folderPath,
-          name: `\u{1F4C1} ${project.name} [${sourceLabel}]`
-        });
-      }
-    }
-  } else {
-    const projectNames = linkedProjects;
-    const rrceHome = customGlobalPath || getRRCEHome();
-    for (const projectName of projectNames) {
-      const folderPath = path5.join(rrceHome, "workspaces", projectName);
-      if (fs5.existsSync(folderPath)) {
-        referenceFolderPaths.push(folderPath);
-        workspace.folders.push({
-          path: folderPath,
-          name: `\u{1F4C1} ${projectName} [global]`
-        });
-      }
-    }
-  }
-  if (referenceFolderPaths.length > 0) {
-    const readonlyPatterns = {};
-    for (const folderPath of referenceFolderPaths) {
-      readonlyPatterns[`${folderPath}/**`] = true;
-    }
-    const existingReadonly = workspace.settings["files.readonlyInclude"] || {};
-    const cleanedReadonly = {};
-    for (const [pattern, value] of Object.entries(existingReadonly)) {
-      if (!pattern.includes(".rrce-workflow") && !pattern.includes("rrce-workflow/workspaces")) {
-        cleanedReadonly[pattern] = value;
-      }
-    }
-    workspace.settings["files.readonlyInclude"] = {
-      ...cleanedReadonly,
-      ...readonlyPatterns
-    };
-  }
-  fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
-}
-var init_vscode = __esm({
-  "src/commands/wizard/vscode.ts"() {
-    "use strict";
-    init_paths();
-    init_detection();
-  }
-});
-
-// src/lib/autocomplete-prompt.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
 import * as readline from "readline";
 import pc from "picocolors";
 function directoryPrompt(opts) {
@@ -654,19 +362,19 @@ function completeDirectory(line) {
       prefix = "";
       basePath = expanded;
     } else {
-      dirToScan = path6.dirname(expanded);
-      prefix = path6.basename(expanded).toLowerCase();
+      dirToScan = path3.dirname(expanded);
+      prefix = path3.basename(expanded).toLowerCase();
       basePath = dirToScan === "/" ? "/" : dirToScan + "/";
     }
-    if (!fs6.existsSync(dirToScan)) {
+    if (!fs3.existsSync(dirToScan)) {
       return [[], line];
     }
-    const entries = fs6.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
+    const entries = fs3.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 fullPath = path3.join(dirToScan, entry.name);
       const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
       return displayPath + "/";
     }).sort();
@@ -706,29 +414,29 @@ var init_autocomplete_prompt = __esm({
 });
 
 // src/lib/preferences.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 function getPreferencesPath() {
   const home = process.env.HOME || "~";
-  return path7.join(home, ".rrce-workflow", "preferences.json");
+  return path4.join(home, ".rrce-workflow", "preferences.json");
 }
 function loadUserPreferences() {
   const prefPath = getPreferencesPath();
-  if (!fs7.existsSync(prefPath)) {
+  if (!fs4.existsSync(prefPath)) {
     return {};
   }
   try {
-    return JSON.parse(fs7.readFileSync(prefPath, "utf-8"));
+    return JSON.parse(fs4.readFileSync(prefPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveUserPreferences(prefs) {
   const prefPath = getPreferencesPath();
-  ensureDir(path7.dirname(prefPath));
+  ensureDir(path4.dirname(prefPath));
   const current = loadUserPreferences();
   const refined = { ...current, ...prefs };
-  fs7.writeFileSync(prefPath, JSON.stringify(refined, null, 2));
+  fs4.writeFileSync(prefPath, JSON.stringify(refined, null, 2));
 }
 var init_preferences = __esm({
   "src/lib/preferences.ts"() {
@@ -744,7 +452,7 @@ __export(tui_utils_exports, {
 });
 import { select, note, isCancel } from "@clack/prompts";
 import pc2 from "picocolors";
-import * as path8 from "path";
+import * as path5 from "path";
 async function resolveGlobalPath() {
   const prefs = loadUserPreferences();
   const defaultPath = prefs.defaultGlobalPath || getDefaultRRCEHome();
@@ -783,7 +491,7 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path8.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const suggestedPath = path5.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
   const customPath = await directoryPrompt({
     message: "Enter custom global path (Tab to autocomplete):",
     defaultValue: suggestedPath,
@@ -802,7 +510,7 @@ Please choose a custom path instead.`,
   }
   let expandedPath = customPath;
   if (!expandedPath.endsWith(".rrce-workflow")) {
-    expandedPath = path8.join(expandedPath, ".rrce-workflow");
+    expandedPath = path5.join(expandedPath, ".rrce-workflow");
   }
   saveUserPreferences({ defaultGlobalPath: expandedPath });
   return expandedPath;
@@ -816,33 +524,362 @@ var init_tui_utils = __esm({
   }
 });
 
-// src/mcp/types.ts
-var DEFAULT_MCP_CONFIG, DEFAULT_PERMISSIONS;
-var init_types = __esm({
-  "src/mcp/types.ts"() {
-    "use strict";
-    DEFAULT_MCP_CONFIG = {
-      server: {
-        port: 3e3,
-        autoStart: false
-      },
-      projects: [],
-      defaults: {
-        includeNew: true,
-        permissions: {
-          knowledge: true,
-          tasks: true,
-          refs: true
-        }
-      }
-    };
-    DEFAULT_PERMISSIONS = {
-      knowledge: true,
-      tasks: true,
-      refs: true
-    };
+// src/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;
+}
+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);
+  }
+  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);
+  }
+  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);
+  }
+  return result;
+}
+async function promptGitignore() {
+  const result = await confirm({
+    message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
+    initialValue: true
+  });
+  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";
+  }
+});
+
+// src/types/prompt.ts
+import { z } from "zod";
+var PromptArgSchema, AutoIdentitySchema, PromptFrontmatterSchema;
+var init_prompt = __esm({
+  "src/types/prompt.ts"() {
+    "use strict";
+    PromptArgSchema = z.object({
+      name: z.string(),
+      default: z.string().optional(),
+      prompt: z.string().optional()
+    });
+    AutoIdentitySchema = z.object({
+      user: z.string(),
+      model: z.string()
+    });
+    PromptFrontmatterSchema = z.object({
+      name: z.string(),
+      description: z.string(),
+      "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
+      tools: z.array(z.string()).optional(),
+      "required-args": z.array(PromptArgSchema).optional(),
+      "optional-args": z.array(PromptArgSchema).optional(),
+      "auto-identity": AutoIdentitySchema.optional()
+    });
+  }
+});
+
+// src/lib/prompts.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+function parsePromptFile(filePath) {
+  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;
+  }
+}
+function loadPromptsFromDir(dirPath) {
+  if (!fs5.existsSync(dirPath)) {
+    return [];
+  }
+  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);
+    }
+  }
+  return prompts;
+}
+function getAgentCoreDir() {
+  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 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);
+    }
+  }
+}
+var init_utils = __esm({
+  "src/commands/wizard/utils.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// 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)) {
+    try {
+      const content = fs7.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 (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]`
+        });
+      }
+    }
+  }
+  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
+    };
+  }
+  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
+    };
+  }
+});
+
+// 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 = {};
@@ -859,6 +896,7 @@ __export(config_exports, {
 });
 import * as fs8 from "fs";
 import * as path9 from "path";
+import YAML from "yaml";
 function getMCPConfigPath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
@@ -908,175 +946,51 @@ function saveMCPConfig(config) {
   fs8.writeFileSync(configPath, content);
 }
 function parseMCPConfig(content) {
-  const config = { ...DEFAULT_MCP_CONFIG, projects: [] };
-  const lines = content.split("\n");
-  let currentSection = null;
-  let currentProject = null;
-  let inPermissions = false;
-  let inSemanticSearch = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("#") || trimmed === "") continue;
-    if (line.match(/^server:/)) {
-      currentSection = "server";
-      currentProject = null;
-      inPermissions = false;
-      inSemanticSearch = false;
-      continue;
-    }
-    if (line.match(/^defaults:/)) {
-      currentSection = "defaults";
-      currentProject = null;
-      inPermissions = false;
-      inSemanticSearch = false;
-      continue;
-    }
-    if (line.match(/^projects:/)) {
-      currentSection = "projects";
-      currentProject = null;
-      inPermissions = false;
-      inSemanticSearch = false;
-      continue;
-    }
-    if (currentSection === "server") {
-      const portMatch = trimmed.match(/^port:\s*(\d+)/);
-      if (portMatch?.[1]) config.server.port = parseInt(portMatch[1], 10);
-      const autoStartMatch = trimmed.match(/^autoStart:\s*(true|false)/);
-      if (autoStartMatch) config.server.autoStart = autoStartMatch[1] === "true";
-    }
-    if (currentSection === "defaults") {
-      const includeNewMatch = trimmed.match(/^includeNew:\s*(true|false)/);
-      if (includeNewMatch) config.defaults.includeNew = includeNewMatch[1] === "true";
-      if (trimmed === "permissions:") {
-        inPermissions = true;
-        continue;
-      }
-      if (inPermissions) {
-        const knowledgeMatch = trimmed.match(/^knowledge:\s*(true|false)/);
-        if (knowledgeMatch) config.defaults.permissions.knowledge = knowledgeMatch[1] === "true";
-        const tasksMatch = trimmed.match(/^tasks:\s*(true|false)/);
-        if (tasksMatch) config.defaults.permissions.tasks = tasksMatch[1] === "true";
-        const refsMatch = trimmed.match(/^refs:\s*(true|false)/);
-        if (refsMatch) config.defaults.permissions.refs = refsMatch[1] === "true";
-      }
-    }
-    if (currentSection === "projects") {
-      const projectNameMatch = line.match(/^\s+-\s+name:\s*["']?([^"'\n]+)["']?/);
-      if (projectNameMatch) {
-        if (currentProject && currentProject.name) {
-          config.projects.push(currentProject);
-        }
-        currentProject = {
-          name: projectNameMatch[1].trim(),
-          expose: true,
-          permissions: { ...DEFAULT_PERMISSIONS }
-        };
-        inPermissions = false;
-        continue;
-      }
-      if (currentProject) {
-        const pathMatch = trimmed.match(/^path:\s*["']?([^"'\n]+)["']?/);
-        if (pathMatch) {
-          currentProject.path = pathMatch[1].trim();
-        }
-        const exposeMatch = trimmed.match(/^expose:\s*(true|false)/);
-        if (exposeMatch) {
-          currentProject.expose = exposeMatch[1] === "true";
-        }
-        if (trimmed === "permissions:") {
-          inPermissions = true;
-          continue;
-        }
-        if (inPermissions) {
-          const knowledgeMatch = trimmed.match(/^knowledge:\s*(true|false)/);
-          if (knowledgeMatch) currentProject.permissions.knowledge = knowledgeMatch[1] === "true";
-          const tasksMatch = trimmed.match(/^tasks:\s*(true|false)/);
-          if (tasksMatch) currentProject.permissions.tasks = tasksMatch[1] === "true";
-          const refsMatch = trimmed.match(/^refs:\s*(true|false)/);
-          if (refsMatch) currentProject.permissions.refs = refsMatch[1] === "true";
-        }
-        if (trimmed === "semanticSearch:") {
-          inSemanticSearch = true;
-          inPermissions = false;
-          if (!currentProject.semanticSearch) {
-            currentProject.semanticSearch = { enabled: false };
-          }
-          continue;
-        }
-        if (inSemanticSearch && currentProject.semanticSearch) {
-          const enabledMatch = trimmed.match(/^enabled:\s*(true|false)/);
-          if (enabledMatch) currentProject.semanticSearch.enabled = enabledMatch[1] === "true";
-          const modelMatch = trimmed.match(/^model:\s*["']?([^"'\n]+)["']?/);
-          if (modelMatch) currentProject.semanticSearch.model = modelMatch[1].trim();
+  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
         }
-      }
-    }
-  }
-  if (currentProject && currentProject.name) {
-    config.projects.push(currentProject);
+      },
+      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 };
   }
-  return config;
 }
 function serializeMCPConfig(config) {
-  let content = `# RRCE MCP Hub Configuration
+  const header = `# 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}"
-`;
-      if (project.path) {
-        content += `    path: "${project.path}"
 `;
-      }
-      content += `    expose: ${project.expose}
-`;
-      if (project.semanticSearch) {
-        content += `    semanticSearch:
-      enabled: ${project.semanticSearch.enabled}
-`;
-        if (project.semanticSearch.model) {
-          content += `      model: "${project.semanticSearch.model}"
-`;
-        }
-      }
-      content += `    permissions:
-      knowledge: ${project.permissions.knowledge}
-      tasks: ${project.permissions.tasks}
-      refs: ${project.permissions.refs}
-`;
-    }
-  }
-  return content;
+  return header + YAML.stringify(config, {
+    indent: 2,
+    lineWidth: 0
+    // No line wrapping
+  });
 }
 function setProjectConfig(config, name, expose, permissions, projectPath, semanticSearch) {
-  let existing = config.projects.find((p) => {
-    if (projectPath && p.path) {
-      return p.path === projectPath;
-    }
-    if (!projectPath && !p.path) {
-      return p.name === name;
-    }
-    if (projectPath && !p.path && p.name === name) {
-      return true;
-    }
-    return false;
-  });
+  const existing = findProjectConfig(config, { name, path: projectPath });
   if (existing) {
     existing.expose = expose;
     if (projectPath && !existing.path) {
@@ -1104,24 +1018,14 @@ function removeProjectConfig(config, name) {
   return config;
 }
 function isProjectExposed(config, name, projectPath) {
-  const project = config.projects.find((p) => {
-    if (projectPath && p.path) return p.path === projectPath;
-    if (!projectPath && !p.path) return p.name === name;
-    if (projectPath && !p.path) return p.name === name;
-    return false;
-  });
+  const project = findProjectConfig(config, { name, path: projectPath });
   if (project) {
     return project.expose;
   }
   return config.defaults.includeNew;
 }
 function getProjectPermissions(config, name, projectPath) {
-  const project = config.projects.find((p) => {
-    if (projectPath && p.path) return p.path === projectPath;
-    if (!projectPath && !p.path) return p.name === name;
-    if (projectPath && !p.path) return p.name === name;
-    return false;
-  });
+  const project = findProjectConfig(config, { name, path: projectPath });
   return project?.permissions ?? config.defaults.permissions;
 }
 function cleanStaleProjects(config) {
@@ -1146,23 +1050,192 @@ function cleanStaleProjects(config) {
   if (removed.length > 0) {
     config.projects = validProjects;
   }
-  return { config, removed };
+  return { config, removed };
+}
+var init_config = __esm({
+  "src/mcp/config.ts"() {
+    "use strict";
+    init_paths();
+    init_types();
+    init_config_utils();
+  }
+});
+
+// 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);
+  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 createWorkspaceConfig(config, workspacePath, workspaceName) {
+  if (config.storageMode !== "workspace") return;
+  const configPath = path10.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path10.dirname(configPath));
+  let content = `# RRCE-Workflow Configuration
+version: 1
+
+storage:
+  mode: ${config.storageMode}`;
+  if (config.globalPath && config.globalPath !== getDefaultRRCEHome()) {
+    content += `
+  globalPath: "${config.globalPath}"`;
+  }
+  content += `
+
+project:
+  name: "${workspaceName}"
+
+tools:
+  copilot: ${config.tools.includes("copilot")}
+  antigravity: ${config.tools.includes("antigravity")}
+`;
+  if (config.linkedProjects.length > 0) {
+    content += `
+linked_projects:
+`;
+    config.linkedProjects.forEach((name) => {
+      content += `  - ${name}
+`;
+    });
+  }
+  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();
+    if (config.storageMode === "workspace") {
+      setProjectConfig2(
+        mcpConfig,
+        workspaceName,
+        true,
+        void 0,
+        void 0,
+        config.enableRAG ? { enabled: true } : void 0
+      );
+    } else {
+      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"
+    );
+  }
+}
+function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
+  const globalPath = path10.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
+  switch (mode) {
+    case "global":
+      return [globalPath];
+    case "workspace":
+      return [workspacePath];
+    default:
+      return [globalPath];
+  }
+}
+var init_setup_actions = __esm({
+  "src/commands/wizard/setup-actions.ts"() {
+    "use strict";
+    init_paths();
+    init_prompts();
+    init_utils();
+    init_vscode();
+  }
+});
+
+// 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/");
+  }
+  if (tools.includes("antigravity")) {
+    entries.push(".agent/workflows/");
+  }
+  entries.push("*.code-workspace");
+  if (entries.length === 0) {
+    return false;
+  }
+  let existingContent = "";
+  if (fs10.existsSync(gitignorePath)) {
+    existingContent = fs10.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;
+  fs10.writeFileSync(gitignorePath, updatedContent);
+  return true;
 }
-var init_config = __esm({
-  "src/mcp/config.ts"() {
+var init_gitignore = __esm({
+  "src/commands/wizard/gitignore.ts"() {
     "use strict";
-    init_paths();
-    init_types();
   }
 });
 
 // src/mcp/logger.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 function getLogFilePath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path10.join(rrceHome, "mcp-server.log");
+  return path12.join(rrceHome, "mcp-server.log");
 }
 var Logger, logger;
 var init_logger = __esm({
@@ -1193,11 +1266,11 @@ ${JSON.stringify(data, null, 2)}`;
         }
         logMessage += "\n";
         try {
-          const dir = path10.dirname(this.logPath);
-          if (!fs9.existsSync(dir)) {
-            fs9.mkdirSync(dir, { recursive: true });
+          const dir = path12.dirname(this.logPath);
+          if (!fs11.existsSync(dir)) {
+            fs11.mkdirSync(dir, { recursive: true });
           }
-          fs9.appendFileSync(this.logPath, logMessage);
+          fs11.appendFileSync(this.logPath, logMessage);
         } catch (e) {
           console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
           console.error(logMessage);
@@ -1221,8 +1294,8 @@ ${JSON.stringify(data, null, 2)}`;
 });
 
 // src/mcp/services/rag.ts
-import * as fs10 from "fs";
-import * as path11 from "path";
+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"() {
@@ -1263,9 +1336,9 @@ var init_rag = __esm({
        */
       loadIndex() {
         if (this.index) return;
-        if (fs10.existsSync(this.indexPath)) {
+        if (fs12.existsSync(this.indexPath)) {
           try {
-            const data = fs10.readFileSync(this.indexPath, "utf-8");
+            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) {
@@ -1291,11 +1364,11 @@ var init_rag = __esm({
       saveIndex() {
         if (!this.index) return;
         try {
-          const dir = path11.dirname(this.indexPath);
-          if (!fs10.existsSync(dir)) {
-            fs10.mkdirSync(dir, { recursive: true });
+          const dir = path13.dirname(this.indexPath);
+          if (!fs12.existsSync(dir)) {
+            fs12.mkdirSync(dir, { recursive: true });
           }
-          fs10.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+          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);
@@ -1304,10 +1377,10 @@ var init_rag = __esm({
       /**
        * Generate embedding for text
        */
-      async generateEmbedding(text3) {
+      async generateEmbedding(text2) {
         const pipe = await this.getPipeline();
         try {
-          const output = await pipe(text3, { pooling: "mean", normalize: true });
+          const output = await pipe(text2, { pooling: "mean", normalize: true });
           return Array.from(output.data);
         } catch (error) {
           logger.error("RAG: Error generating embedding", error);
@@ -1411,8 +1484,8 @@ var init_rag = __esm({
 });
 
 // src/mcp/resources.ts
-import * as fs11 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 function getExposedProjects() {
   const config = loadMCPConfig();
   const allProjects = scanForProjects();
@@ -1420,12 +1493,12 @@ function getExposedProjects() {
   const activeProject = detectActiveProject(globalProjects);
   let linkedProjects = [];
   if (activeProject) {
-    const localConfigPath = path12.join(activeProject.dataPath, "config.yaml");
+    const localConfigPath = path14.join(activeProject.dataPath, "config.yaml");
     let cfgContent = null;
-    if (fs11.existsSync(path12.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
-      cfgContent = fs11.readFileSync(path12.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
-    } else if (fs11.existsSync(path12.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
-      cfgContent = fs11.readFileSync(path12.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
+    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");
     }
     if (cfgContent) {
       if (cfgContent.includes("linked_projects:")) {
@@ -1485,11 +1558,11 @@ function getProjectContext(projectName) {
   if (!project.knowledgePath) {
     return null;
   }
-  const contextPath = path12.join(project.knowledgePath, "project-context.md");
-  if (!fs11.existsSync(contextPath)) {
+  const contextPath = path14.join(project.knowledgePath, "project-context.md");
+  if (!fs13.existsSync(contextPath)) {
     return null;
   }
-  return fs11.readFileSync(contextPath, "utf-8");
+  return fs13.readFileSync(contextPath, "utf-8");
 }
 function getProjectTasks(projectName) {
   const config = loadMCPConfig();
@@ -1502,18 +1575,18 @@ function getProjectTasks(projectName) {
   if (!permissions.tasks) {
     return [];
   }
-  if (!project.tasksPath || !fs11.existsSync(project.tasksPath)) {
+  if (!project.tasksPath || !fs13.existsSync(project.tasksPath)) {
     return [];
   }
   const tasks = [];
   try {
-    const taskDirs = fs11.readdirSync(project.tasksPath, { withFileTypes: true });
+    const taskDirs = fs13.readdirSync(project.tasksPath, { withFileTypes: true });
     for (const dir of taskDirs) {
       if (!dir.isDirectory()) continue;
-      const metaPath = path12.join(project.tasksPath, dir.name, "meta.json");
-      if (fs11.existsSync(metaPath)) {
+      const metaPath = path14.join(project.tasksPath, dir.name, "meta.json");
+      if (fs13.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs11.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs13.readFileSync(metaPath, "utf-8"));
           tasks.push(meta);
         } catch {
         }
@@ -1537,13 +1610,13 @@ async function searchKnowledge(query) {
     const useRAG = projConfig?.semanticSearch?.enabled;
     if (useRAG) {
       try {
-        const indexPath = path12.join(project.knowledgePath, "embeddings.json");
+        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: path12.relative(project.knowledgePath, r.filePath),
+            file: path14.relative(project.knowledgePath, r.filePath),
             matches: [r.content],
             // The chunk content is the match
             score: r.score
@@ -1554,11 +1627,11 @@ async function searchKnowledge(query) {
       continue;
     }
     try {
-      const files = fs11.readdirSync(project.knowledgePath);
+      const files = fs13.readdirSync(project.knowledgePath);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path12.join(project.knowledgePath, file);
-        const content = fs11.readFileSync(filePath, "utf-8");
+        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) {
@@ -1593,18 +1666,18 @@ async function indexKnowledge(projectName, force = false) {
   if (!projConfig?.semanticSearch?.enabled) {
     return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0 };
   }
-  if (!project.knowledgePath || !fs11.existsSync(project.knowledgePath)) {
+  if (!project.knowledgePath || !fs13.existsSync(project.knowledgePath)) {
     return { success: false, message: "No knowledge directory found", filesIndexed: 0 };
   }
   try {
-    const indexPath = path12.join(project.knowledgePath, "embeddings.json");
+    const indexPath = path14.join(project.knowledgePath, "embeddings.json");
     const rag = new RAGService(indexPath, projConfig.semanticSearch.model);
-    const files = fs11.readdirSync(project.knowledgePath).filter((f) => f.endsWith(".md"));
+    const files = fs13.readdirSync(project.knowledgePath).filter((f) => f.endsWith(".md"));
     let count = 0;
     for (const file of files) {
-      const filePath = path12.join(project.knowledgePath, file);
-      const content = fs11.readFileSync(filePath, "utf-8");
-      await rag.indexFile(path12.join(project.knowledgePath, file), content);
+      const filePath = path14.join(project.knowledgePath, file);
+      const content = fs13.readFileSync(filePath, "utf-8");
+      await rag.indexFile(path14.join(project.knowledgePath, file), content);
       count++;
     }
     return { success: true, message: `Successfully indexed ${count} files`, filesIndexed: count };
@@ -2106,8 +2179,8 @@ var init_server = __esm({
 });
 
 // src/mcp/install.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 import * as os from "os";
 function checkInstallStatus(workspacePath) {
   return {
@@ -2118,37 +2191,37 @@ function checkInstallStatus(workspacePath) {
   };
 }
 function checkAntigravityConfig() {
-  if (!fs12.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  if (!fs14.existsSync(ANTIGRAVITY_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs12.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    const content = JSON.parse(fs14.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkClaudeConfig() {
-  if (!fs12.existsSync(CLAUDE_CONFIG)) return false;
+  if (!fs14.existsSync(CLAUDE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs12.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs14.readFileSync(CLAUDE_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeGlobalConfig() {
-  if (!fs12.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  if (!fs14.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs12.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    const content = JSON.parse(fs14.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     return !!content["mcp.servers"]?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path13.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs12.existsSync(configPath)) return false;
+  const configPath = path15.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs14.existsSync(configPath)) return false;
   try {
-    const content = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
     return !!content.servers?.["rrce"];
   } catch {
     return false;
@@ -2173,14 +2246,14 @@ function installToConfig(target, workspacePath) {
   }
 }
 function installToAntigravity() {
-  const dir = path13.dirname(ANTIGRAVITY_CONFIG);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  const dir = path15.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs12.existsSync(ANTIGRAVITY_CONFIG)) {
+  if (fs14.existsSync(ANTIGRAVITY_CONFIG)) {
     try {
-      config = JSON.parse(fs12.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+      config = JSON.parse(fs14.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -2190,21 +2263,21 @@ function installToAntigravity() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs12.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    fs14.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToClaude() {
-  const dir = path13.dirname(CLAUDE_CONFIG);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  const dir = path15.dirname(CLAUDE_CONFIG);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs12.existsSync(CLAUDE_CONFIG)) {
+  if (fs14.existsSync(CLAUDE_CONFIG)) {
     try {
-      config = JSON.parse(fs12.readFileSync(CLAUDE_CONFIG, "utf-8"));
+      config = JSON.parse(fs14.readFileSync(CLAUDE_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -2214,21 +2287,21 @@ function installToClaude() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs12.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    fs14.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeGlobal() {
-  const dir = path13.dirname(VSCODE_GLOBAL_CONFIG);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  const dir = path15.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
   let settings = {};
-  if (fs12.existsSync(VSCODE_GLOBAL_CONFIG)) {
+  if (fs14.existsSync(VSCODE_GLOBAL_CONFIG)) {
     try {
-      settings = JSON.parse(fs12.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+      settings = JSON.parse(fs14.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -2238,22 +2311,22 @@ function installToVSCodeGlobal() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs12.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    fs14.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path13.join(workspacePath, ".vscode");
-  const configPath = path13.join(vscodeDir, "mcp.json");
-  if (!fs12.existsSync(vscodeDir)) {
-    fs12.mkdirSync(vscodeDir, { recursive: true });
+  const vscodeDir = path15.join(workspacePath, ".vscode");
+  const configPath = path15.join(vscodeDir, "mcp.json");
+  if (!fs14.existsSync(vscodeDir)) {
+    fs14.mkdirSync(vscodeDir, { recursive: true });
   }
   let config = { servers: {} };
-  if (fs12.existsSync(configPath)) {
+  if (fs14.existsSync(configPath)) {
     try {
-      config = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
+      config = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
     } catch {
     }
   }
@@ -2263,7 +2336,7 @@ function installToVSCodeWorkspace(workspacePath) {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs12.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs14.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
@@ -2287,15 +2360,15 @@ var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path13.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path13.join(os.homedir(), ".config/claude/claude_desktop_config.json");
-    VSCODE_GLOBAL_CONFIG = path13.join(os.homedir(), ".config/Code/User/settings.json");
+    ANTIGRAVITY_CONFIG = path15.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path15.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path15.join(os.homedir(), ".config/Code/User/settings.json");
   }
 });
 
 // src/mcp/commands/configure.ts
-import { spinner, note as note2, multiselect, isCancel as isCancel2, confirm } from "@clack/prompts";
-import pc3 from "picocolors";
+import { spinner, note as note3, multiselect as multiselect2, isCancel as isCancel3, confirm as confirm2 } from "@clack/prompts";
+import pc5 from "picocolors";
 async function handleConfigure() {
   const s = spinner();
   s.start("Scanning for projects...");
@@ -2304,7 +2377,7 @@ async function handleConfigure() {
   logger.info("Configure: Loaded config", { projects: config.projects, defaultMode: config.defaults.includeNew });
   s.stop("Projects found");
   if (projects.length === 0) {
-    note2('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
+    note3('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
     return;
   }
   const options = projects.map((project) => {
@@ -2315,7 +2388,7 @@ async function handleConfigure() {
     return {
       value: project.dataPath,
       // Use precise data path as unique identifier
-      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
+      label: `${project.name} ${pc5.dim(`(${project.source})`)}`,
       hint: project.dataPath
     };
   });
@@ -2325,27 +2398,27 @@ async function handleConfigure() {
     );
     return cfg?.expose ?? config.defaults.includeNew;
   }).map((p) => p.dataPath);
-  const selected = await multiselect({
+  const selected = await multiselect2({
     message: "Select projects to expose via MCP:",
     options,
     initialValues: currentlyExposed,
     required: false
   });
-  if (isCancel2(selected)) {
+  if (isCancel3(selected)) {
     return;
   }
   const selectedPaths = selected;
   logger.info("Configure: User selected projects by path", selectedPaths);
   let enableSemanticSearch = false;
   if (selectedPaths.length > 0) {
-    const shouldEnable = await confirm({
+    const shouldEnable = await confirm2({
       message: "Enable Semantic Search (Local Mini RAG)?",
       initialValue: false
     });
-    if (isCancel2(shouldEnable)) return;
+    if (isCancel3(shouldEnable)) return;
     enableSemanticSearch = shouldEnable;
     if (enableSemanticSearch) {
-      note2(
+      note3(
         `This enables "search_knowledge" tool for agents.
 First use will download a ~100MB embedding model (all-MiniLM-L6-v2)
 to your local device (one-time).`,
@@ -2364,8 +2437,8 @@ to your local device (one-time).`,
   saveMCPConfig(config);
   logger.info("Configure: Config saved", config);
   const exposedCount = selectedPaths.length;
-  note2(
-    `${pc3.green("\u2713")} Configuration saved!
+  note3(
+    `${pc5.green("\u2713")} Configuration saved!
 
 Exposed projects: ${exposedCount}
 Hidden projects: ${projects.length - exposedCount}`,
@@ -2374,13 +2447,13 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs20 = await import("fs");
-  const path18 = await import("path");
-  note2(
-    `MCP Hub requires a ${pc3.bold("global storage path")} to store its configuration
+  const fs21 = await import("fs");
+  const path19 = await import("path");
+  note3(
+    `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
 
-Your current setup uses ${pc3.cyan("workspace")} mode, which stores data
+Your current setup uses ${pc5.cyan("workspace")} mode, which stores data
 locally in each project. MCP needs a central location.`,
     "Global Path Required"
   );
@@ -2389,22 +2462,22 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs20.existsSync(resolvedPath)) {
-      fs20.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs21.existsSync(resolvedPath)) {
+      fs21.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
-    note2(
-      `${pc3.green("\u2713")} Global path configured: ${pc3.cyan(resolvedPath)}
+    note3(
+      `${pc5.green("\u2713")} Global path configured: ${pc5.cyan(resolvedPath)}
 
 MCP config will be stored at:
-${path18.join(resolvedPath, "mcp.yaml")}`,
+${path19.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
   } catch (error) {
-    note2(
-      `${pc3.red("\u2717")} Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
+    note3(
+      `${pc5.red("\u2717")} Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
       "Error"
     );
     return false;
@@ -2420,33 +2493,33 @@ var init_configure = __esm({
 });
 
 // src/mcp/commands/install-wizard.ts
-import { multiselect as multiselect2, note as note3, isCancel as isCancel3 } from "@clack/prompts";
-import pc4 from "picocolors";
+import { multiselect as multiselect3, note as note4, isCancel as isCancel4 } from "@clack/prompts";
+import pc6 from "picocolors";
 async function runInstallWizard(workspacePath) {
   const status = checkInstallStatus(workspacePath);
   const options = [
     {
       value: "antigravity",
       label: "Antigravity IDE",
-      hint: status.antigravity ? pc4.green("\u2713 Installed") : pc4.dim("Not installed")
+      hint: status.antigravity ? pc6.green("\u2713 Installed") : pc6.dim("Not installed")
     },
     {
       value: "vscode-global",
       label: "VSCode (Global Settings)",
-      hint: status.vscodeGlobal ? pc4.green("\u2713 Installed") : pc4.dim("Not installed")
+      hint: status.vscodeGlobal ? pc6.green("\u2713 Installed") : pc6.dim("Not installed")
     },
     {
       value: "vscode-workspace",
       label: "VSCode (Workspace Config)",
-      hint: status.vscodeWorkspace ? pc4.green("\u2713 Installed") : pc4.dim("Not installed")
+      hint: status.vscodeWorkspace ? pc6.green("\u2713 Installed") : pc6.dim("Not installed")
     },
     {
       value: "claude",
       label: "Claude Desktop",
-      hint: status.claude ? pc4.green("\u2713 Installed") : pc4.dim("Not installed")
+      hint: status.claude ? pc6.green("\u2713 Installed") : pc6.dim("Not installed")
     }
   ];
-  const selected = await multiselect2({
+  const selected = await multiselect3({
     message: "Select where to install RRCE MCP Server:",
     options,
     initialValues: [
@@ -2457,16 +2530,16 @@ async function runInstallWizard(workspacePath) {
     ],
     required: false
   });
-  if (isCancel3(selected)) return;
+  if (isCancel4(selected)) return;
   const targets = selected;
   const results = [];
   for (const target of targets) {
     const success = installToConfig(target, workspacePath);
     const label = getTargetLabel(target);
-    results.push(`${label}: ${success ? pc4.green("\u2713 Success") : pc4.red("\u2717 Failed")}`);
+    results.push(`${label}: ${success ? pc6.green("\u2713 Success") : pc6.red("\u2717 Failed")}`);
   }
   if (results.length > 0) {
-    note3(results.join("\n"), "Installation Results");
+    note4(results.join("\n"), "Installation Results");
   }
 }
 var init_install_wizard = __esm({
@@ -2593,10 +2666,8 @@ var init_ProjectsView = __esm({
     "use strict";
     init_SimpleSelect();
     init_config();
-    init_detection();
-    ProjectsView = ({ onConfigChange }) => {
-      const [config, setConfig] = useState2(loadMCPConfig());
-      const allProjects = scanForProjects();
+    ProjectsView = ({ config: initialConfig, projects: allProjects, onConfigChange }) => {
+      const [config, setConfig] = useState2(initialConfig);
       const projectItems = allProjects.map((p) => {
         const projectConfig = config.projects.find(
           (c) => c.path && c.path === p.path || !c.path && c.name === p.name
@@ -2873,9 +2944,9 @@ var App_exports = {};
 __export(App_exports, {
   App: () => App
 });
-import { useState as useState4, useEffect as useEffect4 } from "react";
+import { useState as useState4, useEffect as useEffect3, useMemo, useCallback } from "react";
 import { Box as Box10, useInput as useInput3, useApp } from "ink";
-import fs13 from "fs";
+import fs15 from "fs";
 import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 var TABS, App;
 var init_App = __esm({
@@ -2888,6 +2959,7 @@ var init_App = __esm({
     init_StatusBoard();
     init_TabBar();
     init_config();
+    init_config_utils();
     init_detection();
     init_logger();
     init_server();
@@ -2908,15 +2980,21 @@ var init_App = __esm({
         pid: process.pid,
         running: false
       });
-      const [configVersion, setConfigVersion] = useState4(0);
-      const config = loadMCPConfig();
-      const projects = scanForProjects();
-      const exposedProjects = projects.filter((p) => {
-        const cfg = config.projects.find(
-          (c) => c.path && c.path === p.path || !c.path && c.name === p.name
-        );
-        return cfg?.expose ?? config.defaults.includeNew;
-      });
+      const [config, setConfig] = useState4(() => loadMCPConfig());
+      const [projects, setProjects] = useState4(() => scanForProjects());
+      const refreshData = useCallback(() => {
+        setConfig(loadMCPConfig());
+        setProjects(scanForProjects());
+      }, []);
+      const exposedProjects = useMemo(
+        () => projects.filter((p) => {
+          const cfg = config.projects.find(
+            (c) => c.path && c.path === p.path || !c.path && c.name === p.name
+          );
+          return cfg?.expose ?? config.defaults.includeNew;
+        }),
+        [projects, config]
+      );
       const workspacePath = detectWorkspaceRoot();
       const installStatus = checkInstallStatus(workspacePath);
       const installedCount = [
@@ -2925,7 +3003,7 @@ var init_App = __esm({
         installStatus.vscodeGlobal,
         installStatus.vscodeWorkspace
       ].filter(Boolean).length;
-      useEffect4(() => {
+      useEffect3(() => {
         const start = async () => {
           const status = getMCPServerStatus();
           if (!status.running) {
@@ -2941,21 +3019,21 @@ var init_App = __esm({
         };
         start();
       }, []);
-      useEffect4(() => {
+      useEffect3(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs13.existsSync(logPath)) {
-          const stats = fs13.statSync(logPath);
+        if (fs15.existsSync(logPath)) {
+          const stats = fs15.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs13.existsSync(logPath)) {
-            const stats = fs13.statSync(logPath);
+          if (fs15.existsSync(logPath)) {
+            const stats = fs15.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs13.openSync(logPath, "r");
-              fs13.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs13.closeSync(fd);
+              const fd = fs15.openSync(logPath, "r");
+              fs15.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs15.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -2977,9 +3055,9 @@ var init_App = __esm({
       });
       const termHeight = process.stdout.rows || 24;
       const contentHeight = termHeight - 8;
-      const handleConfigChange = () => {
-        setConfigVersion((prev) => prev + 1);
-      };
+      const handleConfigChange = useCallback(() => {
+        refreshData();
+      }, [refreshData]);
       return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", padding: 0, height: termHeight, children: [
         /* @__PURE__ */ jsx10(TabBar, { tabs: TABS, activeTab, onChange: setActiveTab }),
         /* @__PURE__ */ jsxs9(Box10, { marginTop: 1, flexGrow: 1, children: [
@@ -2994,7 +3072,7 @@ var init_App = __esm({
               }
             }
           ),
-          activeTab === "projects" && /* @__PURE__ */ jsx10(ProjectsView, { onConfigChange: handleConfigChange }),
+          activeTab === "projects" && /* @__PURE__ */ jsx10(ProjectsView, { config, projects, onConfigChange: handleConfigChange }),
           activeTab === "install" && /* @__PURE__ */ jsx10(InstallView, {}),
           activeTab === "logs" && /* @__PURE__ */ jsx10(LogViewer, { logs, height: contentHeight })
         ] }),
@@ -3013,7 +3091,7 @@ var init_App = __esm({
 });
 
 // src/mcp/commands/start.ts
-import { confirm as confirm2, isCancel as isCancel4, text } from "@clack/prompts";
+import { confirm as confirm3, isCancel as isCancel5, text } from "@clack/prompts";
 async function handleStartServer() {
   const React11 = await import("react");
   const { render } = await import("ink");
@@ -3027,11 +3105,11 @@ async function handleStartServer() {
     return cfg?.expose ?? config.defaults.includeNew;
   });
   if (exposedProjects.length === 0) {
-    const shouldConfig = await confirm2({
+    const shouldConfig = await confirm3({
       message: "No projects are currently exposed. Configure now?",
       initialValue: true
     });
-    if (shouldConfig && !isCancel4(shouldConfig)) {
+    if (shouldConfig && !isCancel5(shouldConfig)) {
       await handleConfigure();
       return handleStartServer();
     }
@@ -3047,7 +3125,7 @@ async function handleStartServer() {
         if (isNaN(Number(value))) return "Port must be a number";
       }
     });
-    if (isCancel4(portInput)) return;
+    if (isCancel5(portInput)) return;
     const newPort = parseInt(portInput, 10);
     if (newPort !== config.server.port) {
       config.server.port = newPort;
@@ -3079,8 +3157,8 @@ var init_start = __esm({
 });
 
 // src/mcp/commands/status.ts
-import { spinner as spinner2, note as note4 } from "@clack/prompts";
-import pc5 from "picocolors";
+import { spinner as spinner2, note as note5 } from "@clack/prompts";
+import pc7 from "picocolors";
 async function handleShowStatus() {
   const s = spinner2();
   s.start("Loading projects...");
@@ -3090,36 +3168,36 @@ async function handleShowStatus() {
   const installStatus = checkInstallStatus(workspacePath);
   s.stop("Projects loaded");
   if (projects.length === 0) {
-    note4('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
+    note5('No RRCE projects detected. Run "rrce-workflow" in a project to set it up.', "No Projects");
     return;
   }
   const lines = [
-    `${pc5.bold("Installation Status")}`,
+    `${pc7.bold("Installation Status")}`,
     "",
-    `  Antigravity:      ${installStatus.antigravity ? pc5.green("\u2713 Installed") : pc5.dim("Not installed")}`,
-    `  VSCode (Global):  ${installStatus.vscodeGlobal ? pc5.green("\u2713 Installed") : pc5.dim("Not installed")}`,
-    `  VSCode (Workspace): ${installStatus.vscodeWorkspace ? pc5.green("\u2713 Installed") : pc5.dim("Not installed")}`,
-    `  Claude Desktop:   ${installStatus.claude ? pc5.green("\u2713 Installed") : pc5.dim("Not installed")}`,
+    `  Antigravity:      ${installStatus.antigravity ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
+    `  VSCode (Global):  ${installStatus.vscodeGlobal ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
+    `  VSCode (Workspace): ${installStatus.vscodeWorkspace ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
+    `  Claude Desktop:   ${installStatus.claude ? pc7.green("\u2713 Installed") : pc7.dim("Not installed")}`,
     "",
-    `${pc5.bold("Project Status")}`,
+    `${pc7.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 ? pc5.green("\u2713 exposed") : pc5.dim("\u25CB hidden");
-    const source = pc5.dim(`(${project.source})`);
+    const status = isExposed ? pc7.green("\u2713 exposed") : pc7.dim("\u25CB hidden");
+    const source = pc7.dim(`(${project.source})`);
     lines.push(`  ${status}  ${project.name} ${source}`);
   }
   lines.push("");
-  lines.push(pc5.dim(`Config: ${getMCPConfigPath()}`));
+  lines.push(pc7.dim(`Config: ${getMCPConfigPath()}`));
   const serverStatus = getMCPServerStatus();
   if (serverStatus.running) {
-    lines.push(pc5.green(`Server: running on port ${serverStatus.port}`));
+    lines.push(pc7.green(`Server: running on port ${serverStatus.port}`));
   } else {
-    lines.push(pc5.dim("Server: not running"));
+    lines.push(pc7.dim("Server: not running"));
   }
-  note4(lines.join("\n"), "MCP Hub Status");
+  note5(lines.join("\n"), "MCP Hub Status");
 }
 var init_status = __esm({
   "src/mcp/commands/status.ts"() {
@@ -3133,46 +3211,46 @@ var init_status = __esm({
 });
 
 // src/mcp/commands/help.ts
-import { note as note5 } from "@clack/prompts";
-import pc6 from "picocolors";
+import { note as note6 } from "@clack/prompts";
+import pc8 from "picocolors";
 function showHelp() {
   const help = `
-${pc6.bold("RRCE MCP Hub")} - Cross-project AI assistant server
+${pc8.bold("RRCE MCP Hub")} - Cross-project AI assistant server
 
-${pc6.bold("ABOUT")}
+${pc8.bold("ABOUT")}
 MCP (Model Context Protocol) allows AI assistants like Claude to 
 access your project knowledge in real-time. The RRCE MCP Hub 
 provides a central server that exposes selected projects.
 
-${pc6.bold("MENU OPTIONS")}
-  ${pc6.cyan("Start MCP server")}      Start the server for AI access
-  ${pc6.cyan("Configure projects")}    Choose which projects to expose
-  ${pc6.cyan("Install to IDE")}        Add to Antigravity, VSCode, or Claude
-  ${pc6.cyan("View status")}           See which projects are exposed
-
-${pc6.bold("DIRECT COMMANDS")}
-  ${pc6.dim("rrce-workflow mcp start")}    Start server directly
-  ${pc6.dim("rrce-workflow mcp stop")}     Stop server directly
-  ${pc6.dim("rrce-workflow mcp status")}   Show status directly
-  ${pc6.dim("rrce-workflow mcp help")}     Show this help
-
-${pc6.bold("IDE INSTALLATION")}
-  ${pc6.cyan("Antigravity")}    ~/.gemini/antigravity/mcp_config.json
-  ${pc6.cyan("VSCode Global")} ~/.config/Code/User/settings.json
-  ${pc6.cyan("VSCode Workspace")} .vscode/mcp.json
-  ${pc6.cyan("Claude Desktop")} ~/.config/claude/claude_desktop_config.json
-
-${pc6.bold("SERVER COMMANDS")} (while running)
-  ${pc6.cyan("q")} Stop and quit       ${pc6.cyan("p")} Reconfigure projects
-  ${pc6.cyan("i")} Install to IDE      ${pc6.cyan("r")} Reload config
-  ${pc6.cyan("c")} Clear logs          ${pc6.cyan("?")} Show help
-
-${pc6.bold("RESOURCES EXPOSED")}
-  ${pc6.cyan("rrce://projects")}              List all exposed projects
-  ${pc6.cyan("rrce://projects/{name}/context")}  Get project context
-  ${pc6.cyan("rrce://projects/{name}/tasks")}    Get project tasks
+${pc8.bold("MENU OPTIONS")}
+  ${pc8.cyan("Start MCP server")}      Start the server for AI access
+  ${pc8.cyan("Configure projects")}    Choose which projects to expose
+  ${pc8.cyan("Install to IDE")}        Add to Antigravity, VSCode, or Claude
+  ${pc8.cyan("View status")}           See which projects are exposed
+
+${pc8.bold("DIRECT COMMANDS")}
+  ${pc8.dim("rrce-workflow mcp start")}    Start server directly
+  ${pc8.dim("rrce-workflow mcp stop")}     Stop server directly
+  ${pc8.dim("rrce-workflow mcp status")}   Show status directly
+  ${pc8.dim("rrce-workflow mcp help")}     Show this help
+
+${pc8.bold("IDE INSTALLATION")}
+  ${pc8.cyan("Antigravity")}    ~/.gemini/antigravity/mcp_config.json
+  ${pc8.cyan("VSCode Global")} ~/.config/Code/User/settings.json
+  ${pc8.cyan("VSCode Workspace")} .vscode/mcp.json
+  ${pc8.cyan("Claude Desktop")} ~/.config/claude/claude_desktop_config.json
+
+${pc8.bold("SERVER COMMANDS")} (while running)
+  ${pc8.cyan("q")} Stop and quit       ${pc8.cyan("p")} Reconfigure projects
+  ${pc8.cyan("i")} Install to IDE      ${pc8.cyan("r")} Reload config
+  ${pc8.cyan("c")} Clear logs          ${pc8.cyan("?")} Show help
+
+${pc8.bold("RESOURCES EXPOSED")}
+  ${pc8.cyan("rrce://projects")}              List all exposed projects
+  ${pc8.cyan("rrce://projects/{name}/context")}  Get project context
+  ${pc8.cyan("rrce://projects/{name}/tasks")}    Get project tasks
 `;
-  note5(help.trim(), "Help");
+  note6(help.trim(), "Help");
 }
 var init_help = __esm({
   "src/mcp/commands/help.ts"() {
@@ -3188,8 +3266,8 @@ __export(mcp_exports, {
   handleStartServer: () => handleStartServer,
   runMCP: () => runMCP
 });
-import { intro, outro, confirm as confirm3, note as note6, isCancel as isCancel5 } from "@clack/prompts";
-import pc7 from "picocolors";
+import { intro, outro, confirm as confirm4, note as note7, isCancel as isCancel6 } from "@clack/prompts";
+import pc9 from "picocolors";
 async function runMCP(subcommand2) {
   if (subcommand2) {
     switch (subcommand2) {
@@ -3221,36 +3299,36 @@ async function runMCP(subcommand2) {
   const workspacePath = detectWorkspaceRoot();
   const globalPathCheck = await ensureMCPGlobalPath();
   if (!globalPathCheck.configured) {
-    intro(pc7.bgCyan(pc7.black(" MCP Setup ")));
+    intro(pc9.bgCyan(pc9.black(" MCP Setup ")));
     const configured = await handleConfigureGlobalPath();
     if (!configured) {
-      outro(pc7.yellow("MCP requires a global storage path. Setup cancelled."));
+      outro(pc9.yellow("MCP requires a global storage path. Setup cancelled."));
       return;
     }
   }
   const installed = isInstalledAnywhere(workspacePath);
   if (!installed) {
-    intro(pc7.bgCyan(pc7.black(" Welcome to MCP Hub ")));
-    note6(
-      `${pc7.bold("Set up Model Context Protocol")}
+    intro(pc9.bgCyan(pc9.black(" Welcome to MCP Hub ")));
+    note7(
+      `${pc9.bold("Set up Model Context Protocol")}
 Allow AI assistants to access your project context.`,
       "Getting Started"
     );
-    const shouldInstall = await confirm3({
+    const shouldInstall = await confirm4({
       message: "Install MCP server integrations now?",
       initialValue: true
     });
-    if (shouldInstall && !isCancel5(shouldInstall)) {
+    if (shouldInstall && !isCancel6(shouldInstall)) {
       await runInstallWizard(workspacePath);
-      const shouldStart = await confirm3({
+      const shouldStart = await confirm4({
         message: "Start the MCP Dashboard?",
         initialValue: true
       });
-      if (shouldStart && !isCancel5(shouldStart)) {
+      if (shouldStart && !isCancel6(shouldStart)) {
         await handleStartServer();
       }
     } else {
-      outro(pc7.dim('Setup skipped. Run "npx rrce-workflow mcp" later to restart.'));
+      outro(pc9.dim('Setup skipped. Run "npx rrce-workflow mcp" later to restart.'));
     }
     return;
   }
@@ -3258,18 +3336,18 @@ Allow AI assistants to access your project context.`,
     await handleStartServer();
   } catch (err) {
     console.error(err);
-    outro(pc7.red("Failed to launch MCP Dashboard"));
+    outro(pc9.red("Failed to launch MCP Dashboard"));
   }
 }
 async function handleStopServer() {
   const { stopMCPServer: stopMCPServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const status = getMCPServerStatus();
   if (!status.running) {
-    console.log(pc7.dim("MCP server is already stopped."));
+    console.log(pc9.dim("MCP server is already stopped."));
     return;
   }
   stopMCPServer2();
-  console.log(pc7.green("MCP server stopped."));
+  console.log(pc9.green("MCP server stopped."));
 }
 var init_mcp = __esm({
   "src/mcp/index.ts"() {
@@ -3287,364 +3365,201 @@ var init_mcp = __esm({
 });
 
 // src/commands/wizard/setup-flow.ts
-import { group, select as select2, multiselect as multiselect3, confirm as confirm4, spinner as spinner3, note as note7, outro as outro2, cancel as cancel2, isCancel as isCancel6 } from "@clack/prompts";
-import pc8 from "picocolors";
-import * as fs14 from "fs";
-import * as path14 from "path";
-async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
-  const s = spinner3();
-  const config = await group(
-    {
-      storageMode: () => select2({
-        message: "Where should workflow data be stored?",
-        options: [
-          { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Cross-project access, clean workspace" },
-          { value: "workspace", label: "Workspace (.rrce-workflow/)", hint: "Self-contained, version with repo" }
-        ],
-        initialValue: "global"
-      }),
-      tools: () => multiselect3({
-        message: "Which AI tools do you use?",
-        options: [
-          { value: "copilot", label: "GitHub Copilot", hint: "VSCode" },
-          { value: "antigravity", label: "Antigravity IDE" }
-        ],
-        required: false
-      }),
-      exposeToMCP: () => confirm4({
-        message: "Expose this project to MCP (AI Agent) server?",
-        initialValue: true
-      }),
-      linkedProjects: () => {
-        if (existingProjects.length === 0) {
-          return Promise.resolve([]);
-        }
-        return multiselect3({
-          message: "Link knowledge from other projects?",
-          options: existingProjects.map((project) => ({
-            value: `${project.name}:${project.source}`,
-            // Unique key
-            label: `${project.name} ${pc8.dim(`(${project.source})`)}`,
-            hint: pc8.dim(
-              project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
-            )
-          })),
-          required: false
-        });
-      },
-      addToGitignore: () => confirm4({
-        message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
-        initialValue: true
-      }),
-      confirm: () => confirm4({
-        message: "Create configuration?",
-        initialValue: true
-      }),
-      enableRAG: () => confirm4({
-        message: "Enable Semantic Search (Local Mini RAG)?",
-        initialValue: true
-      }),
-      enableRAGConfirm: ({ results }) => {
-        if (results.enableRAG) {
-          return confirm4({
-            message: `${pc8.yellow("Warning:")} This will download a ~100MB model (Xenova/all-MiniLM-L6-v2) on first use. Proceed?`,
-            initialValue: true
-          });
-        }
-        return Promise.resolve(true);
-      }
-    },
-    {
-      onCancel: () => {
-        cancel2("Setup process cancelled.");
-        process.exit(0);
-      }
+import { spinner as spinner3, note as note8, outro as outro2, cancel as cancel3, isCancel as isCancel7, confirm as confirm5, select as select3 } from "@clack/prompts";
+import pc10 from "picocolors";
+async function runExpressSetup(workspacePath, workspaceName, existingProjects, s) {
+  const storageModeResult = await select3({
+    message: "Where should workflow data be stored?",
+    options: [
+      { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Recommended - cross-project access" },
+      { value: "workspace", label: "Workspace (.rrce-workflow/)", hint: "Self-contained" }
+    ],
+    initialValue: "global"
+  });
+  if (isCancel7(storageModeResult)) {
+    cancel3("Setup cancelled.");
+    process.exit(0);
+  }
+  const storageMode = storageModeResult;
+  let customGlobalPath;
+  if (storageMode === "global") {
+    customGlobalPath = await resolveGlobalPath();
+    if (!customGlobalPath) {
+      cancel3("Setup cancelled - no global path selected.");
+      process.exit(0);
     }
+  }
+  note8(
+    `${pc10.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`,
+    "Configuration Preview"
   );
-  if (!config.confirm) {
-    outro2("Setup cancelled by user.");
+  const confirmed = await confirm5({
+    message: "Proceed with express setup?",
+    initialValue: true
+  });
+  if (isCancel7(confirmed) || !confirmed) {
+    cancel3("Setup cancelled.");
+    process.exit(0);
+  }
+  const config = {
+    storageMode,
+    globalPath: customGlobalPath,
+    tools: ["copilot", "antigravity"],
+    linkedProjects: [],
+    addToGitignore: true,
+    exposeToMCP: true,
+    enableRAG: true
+  };
+  await executeSetup(config, workspacePath, workspaceName, existingProjects, s);
+  const startMCP = await confirm5({
+    message: "Start MCP server now?",
+    initialValue: true
+  });
+  if (startMCP && !isCancel7(startMCP)) {
+    const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+    await runMCP2();
+  } else {
+    outro2(pc10.green(`\u2713 Express setup complete! Run ${pc10.cyan("npx rrce-workflow mcp")} to start the server.`));
+  }
+}
+async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
+  const s = spinner3();
+  const setupModeResult = await select3({
+    message: "Setup mode:",
+    options: [
+      { value: "express", label: "Express Setup", hint: "Quick start with recommended defaults (3 steps)" },
+      { value: "custom", label: "Custom Setup", hint: "Full configuration options" }
+    ],
+    initialValue: "express"
+  });
+  if (isCancel7(setupModeResult)) {
+    cancel3("Setup cancelled.");
     process.exit(0);
   }
+  if (setupModeResult === "express") {
+    return runExpressSetup(workspacePath, workspaceName, existingProjects, s);
+  }
+  const storageMode = await promptStorageMode();
   let customGlobalPath;
-  if (config.storageMode === "global") {
+  if (storageMode === "global") {
     customGlobalPath = await resolveGlobalPath();
     if (!customGlobalPath) {
-      cancel2("Setup cancelled - no writable global path available.");
-      process.exit(1);
+      cancel3("Setup cancelled - no global path selected.");
+      process.exit(0);
     }
   }
-  if (config.storageMode === "global") {
-    const targetGlobalPath = path14.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-    if (fs14.existsSync(targetGlobalPath)) {
-      const overwriteAction = await select2({
-        message: `Project '${workspaceName}' already exists globally.`,
-        options: [
-          { value: "overwrite", label: "Overwrite existing project", hint: "Will replace global config" },
-          { value: "cancel", label: "Cancel setup" }
-        ]
-      });
-      if (isCancel6(overwriteAction) || overwriteAction === "cancel") {
-        cancel2("Setup cancelled.");
-        process.exit(0);
-      }
-    }
+  const tools = await promptTools();
+  const exposeToMCP = await promptMCPExposure();
+  const linkedProjects = await promptLinkedProjects(existingProjects);
+  const addToGitignore = await promptGitignore();
+  const enableRAG = await promptRAG();
+  const confirmed = await promptConfirmation();
+  if (!confirmed) {
+    outro2("Setup cancelled by user.");
+    process.exit(0);
   }
+  const config = {
+    storageMode,
+    globalPath: customGlobalPath,
+    tools,
+    linkedProjects,
+    addToGitignore,
+    exposeToMCP,
+    enableRAG
+  };
+  await executeSetup(config, workspacePath, workspaceName, existingProjects, s);
+  await handlePostSetup(config, workspacePath, workspaceName, linkedProjects);
+}
+async function executeSetup(config, workspacePath, workspaceName, allProjects, s) {
   s.start("Generating configuration");
   try {
-    await generateConfiguration({
-      storageMode: config.storageMode,
-      globalPath: customGlobalPath,
-      tools: config.tools,
-      linkedProjects: config.linkedProjects,
-      addToGitignore: config.addToGitignore,
-      exposeToMCP: config.exposeToMCP,
-      enableRAG: config.enableRAG && config.enableRAGConfirm
-    }, workspacePath, workspaceName, existingProjects);
+    const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
+    createDirectoryStructure(dataPaths);
+    installAgentPrompts(config, workspacePath, dataPaths);
+    createWorkspaceConfig(config, workspacePath, workspaceName);
+    if (config.addToGitignore) {
+      const { updateGitignore: updateGitignore2 } = await Promise.resolve().then(() => (init_gitignore(), gitignore_exports));
+      updateGitignore2(workspacePath, config.storageMode, config.tools);
+    }
+    if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
+      const selectedProjects = allProjects.filter(
+        (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
+      );
+      generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
+    }
+    await registerWithMCP(config, workspacePath, workspaceName);
     s.stop("Configuration generated");
-    const dataPaths = getDataPaths(
-      config.storageMode,
-      workspaceName,
-      workspacePath,
-      customGlobalPath
-    );
+    const dataSummary = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
     const summary = [
-      `Storage: ${config.storageMode}`
-    ];
-    if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc8.cyan(customGlobalPath)}`);
-    }
-    if (dataPaths.length > 0) {
-      summary.push(`Data paths:`);
-      dataPaths.forEach((p) => summary.push(`  - ${p}`));
-    }
-    const selectedTools = config.tools;
-    if (selectedTools.length > 0) {
-      summary.push(`Tools: ${selectedTools.join(", ")}`);
-    }
-    const linkedProjects = config.linkedProjects;
-    if (linkedProjects.length > 0) {
-      summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
-      summary.push(`Workspace file: ${pc8.cyan(`${workspaceName}.code-workspace`)}`);
-    }
-    note7(summary.join("\n"), "Setup Summary");
-    if (config.exposeToMCP) {
-      note7(`${pc8.green("\u2713")} Project exposed to MCP Hub`, "MCP Configuration");
-      if (linkedProjects.length > 0) {
-        outro2(pc8.green(`\u2713 Setup complete! Open ${pc8.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
-      } else {
-        outro2(pc8.green(`\u2713 Setup complete! Your agents are ready to use.`));
-      }
-    } else {
-      const shouldConfigureMCP = await confirm4({
-        message: "Would you like to configure the MCP server now?",
-        initialValue: true
-      });
-      if (shouldConfigureMCP && !isCancel6(shouldConfigureMCP)) {
-        const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-        await runMCP2();
-      } else {
-        if (linkedProjects.length > 0) {
-          outro2(pc8.green(`\u2713 Setup complete! Open ${pc8.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
-        } else {
-          outro2(pc8.green(`\u2713 Setup complete! Your agents are ready to use.`));
-        }
-      }
-    }
+      `${pc10.green("\u2713")} Data stored at: ${pc10.dim(dataSummary[0])}`,
+      config.tools.length > 0 ? `${pc10.green("\u2713")} Tools: ${config.tools.join(", ")}` : null,
+      config.exposeToMCP ? `${pc10.green("\u2713")} MCP server configured` : null,
+      config.enableRAG ? `${pc10.green("\u2713")} Semantic Search enabled` : null,
+      config.linkedProjects.length > 0 ? `${pc10.green("\u2713")} Linked ${config.linkedProjects.length} project(s)` : null
+    ].filter(Boolean);
+    note8(summary.join("\n"), "Setup Complete");
   } catch (error) {
     s.stop("Error occurred");
-    cancel2(`Failed to setup: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
-}
-async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
-  const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
-  for (const dataPath of dataPaths) {
-    ensureDir(dataPath);
-    ensureDir(path14.join(dataPath, "knowledge"));
-    ensureDir(path14.join(dataPath, "refs"));
-    ensureDir(path14.join(dataPath, "tasks"));
-    ensureDir(path14.join(dataPath, "templates"));
-  }
-  const agentCoreDir = getAgentCoreDir();
-  syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path14.join(agentCoreDir, "templates"), "templates", dataPaths);
-  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-  if (config.storageMode === "workspace") {
-    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");
-    }
-  }
-  if (config.storageMode === "workspace") {
-    const workspaceConfigPath = path14.join(workspacePath, ".rrce-workflow", "config.yaml");
-    ensureDir(path14.dirname(workspaceConfigPath));
-    let configContent = `# RRCE-Workflow Configuration
-version: 1
-
-storage:
-  mode: ${config.storageMode}`;
-    if (config.globalPath && config.globalPath !== getDefaultRRCEHome()) {
-      configContent += `
-  globalPath: "${config.globalPath}"`;
-    }
-    configContent += `
-
-project:
-  name: "${workspaceName}"
+    cancel3(
+      `Setup failed: ${error instanceof Error ? error.message : String(error)}
 
-tools:
-  copilot: ${config.tools.includes("copilot")}
-  antigravity: ${config.tools.includes("antigravity")}
-`;
-    if (config.linkedProjects.length > 0) {
-      configContent += `
-linked_projects:
-`;
-      config.linkedProjects.forEach((name) => {
-        configContent += `  - ${name}
-`;
-      });
-    }
-    fs14.writeFileSync(workspaceConfigPath, configContent);
-  }
-  if (config.addToGitignore) {
-    updateGitignore(workspacePath, config.storageMode, config.tools);
-  }
-  if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
-    const selectedProjects = allProjects.filter(
-      (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
+${pc10.dim("Tip: You can re-run the wizard to try again.")}`
     );
-    generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
+    process.exit(1);
   }
+}
+async function handlePostSetup(config, workspacePath, workspaceName, linkedProjects) {
   if (config.exposeToMCP) {
-    try {
-      const { loadMCPConfig: loadMCPConfig3, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-      const { getWorkspaceName: getWorkspaceName2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-      const mcpConfig = loadMCPConfig3();
-      const currentProjectName = workspaceName;
-      if (config.storageMode === "workspace") {
-        setProjectConfig2(
-          mcpConfig,
-          currentProjectName,
-          true,
-          void 0,
-          // permissions
-          void 0,
-          // path
-          config.enableRAG ? { enabled: true } : void 0
-          // semanticSearch
-        );
-        saveMCPConfig2(mcpConfig);
-        saveMCPConfig2(mcpConfig);
+    const shouldConfigureMCP = await confirm5({
+      message: "Would you like to start the MCP server now?",
+      initialValue: true
+    });
+    if (shouldConfigureMCP && !isCancel7(shouldConfigureMCP)) {
+      const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      await runMCP2();
+    } else {
+      if (linkedProjects.length > 0) {
+        outro2(pc10.green(`\u2713 Setup complete! Open ${pc10.bold(`${workspaceName}.code-workspace`)} in VSCode.`));
       } else {
-        setProjectConfig2(
-          mcpConfig,
-          currentProjectName,
-          true,
-          void 0,
-          // permissions
-          workspacePath,
-          // <--- IMPORTANT: Register absolute path so config scanner finds it
-          config.enableRAG ? { enabled: true } : void 0
-          // semanticSearch
-        );
-        saveMCPConfig2(mcpConfig);
-      }
-    } catch (e) {
-      console.error("Failed to update MCP config:", e);
-    }
-  }
-}
-function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path14.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path14.join(workspaceRoot, ".rrce-workflow");
-  switch (mode) {
-    case "global":
-      return [globalPath];
-    case "workspace":
-      return [workspacePath];
-    default:
-      return [globalPath];
-  }
-}
-function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path14.join(workspacePath, ".gitignore");
-  const entries = [];
-  if (storageMode === "workspace") {
-    entries.push(".rrce-workflow/");
-  }
-  if (tools.includes("copilot")) {
-    entries.push(".github/agents/");
-  }
-  if (tools.includes("antigravity")) {
-    entries.push(".agent/");
-  }
-  if (entries.length === 0) {
-    return false;
-  }
-  try {
-    let content = "";
-    if (fs14.existsSync(gitignorePath)) {
-      content = fs14.readFileSync(gitignorePath, "utf-8");
-    }
-    const lines = content.split("\n").map((line) => line.trim());
-    const newEntries = [];
-    for (const entry of entries) {
-      const entryWithoutSlash = entry.replace(/\/$/, "");
-      const commentedEntry = `# ${entry}`;
-      const commentedEntryNoSlash = `# ${entryWithoutSlash}`;
-      if (!lines.some(
-        (line) => line === entry || line === entryWithoutSlash || line === commentedEntry || line === commentedEntryNoSlash
-      )) {
-        newEntries.push(entry);
+        outro2(pc10.green(`\u2713 Setup complete! Run ${pc10.cyan("npx rrce-workflow mcp")} to start the server.`));
       }
     }
-    if (newEntries.length === 0) {
-      return false;
-    }
-    let newContent = content;
-    if (!newContent.endsWith("\n") && newContent !== "") {
-      newContent += "\n";
-    }
-    if (newContent === "" || !content.includes("# rrce-workflow")) {
-      newContent += "\n# rrce-workflow generated folders (uncomment to ignore)\n";
+  } else {
+    if (linkedProjects.length > 0) {
+      outro2(pc10.green(`\u2713 Setup complete! Open ${pc10.bold(`${workspaceName}.code-workspace`)} in VSCode.`));
+    } else {
+      outro2(pc10.green(`\u2713 Setup complete! Your agents are ready to use.`));
     }
-    newContent += newEntries.map((e) => `# ${e}`).join("\n") + "\n";
-    fs14.writeFileSync(gitignorePath, newContent);
-    return true;
-  } catch {
-    return false;
   }
 }
 var init_setup_flow = __esm({
   "src/commands/wizard/setup-flow.ts"() {
     "use strict";
-    init_paths();
-    init_prompts();
-    init_utils();
-    init_vscode();
     init_detection();
     init_tui_utils();
+    init_setup_prompts();
+    init_setup_actions();
+    init_gitignore();
+    init_vscode();
   }
 });
 
 // src/commands/wizard/link-flow.ts
-import { multiselect as multiselect4, spinner as spinner4, note as note8, outro as outro3, cancel as cancel3, isCancel as isCancel7, confirm as confirm5 } from "@clack/prompts";
-import pc9 from "picocolors";
-import * as fs15 from "fs";
+import { multiselect as multiselect4, spinner as spinner4, note as note9, outro as outro3, cancel as cancel4, isCancel as isCancel8, confirm as confirm6 } from "@clack/prompts";
+import pc11 from "picocolors";
+import * as fs16 from "fs";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
     workspacePath
   });
   if (projects.length === 0) {
-    outro3(pc9.yellow("No other projects found. Try setting up another project first."));
+    outro3(pc11.yellow("No other projects found. Try setting up another project first."));
     return;
   }
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
@@ -3653,15 +3568,15 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     options: projects.map((project) => ({
       value: `${project.name}:${project.source}`,
       // Unique key
-      label: `${project.name} ${pc9.dim(`(${project.source})`)}`,
-      hint: pc9.dim(
+      label: `${project.name} ${pc11.dim(`(${project.source})`)}`,
+      hint: pc11.dim(
         project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
       )
     })),
     required: true
   });
-  if (isCancel7(linkedProjects)) {
-    cancel3("Cancelled.");
+  if (isCancel8(linkedProjects)) {
+    cancel4("Cancelled.");
     process.exit(0);
   }
   const selectedKeys = linkedProjects;
@@ -3675,7 +3590,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs15.readFileSync(configFilePath, "utf-8");
+  let configContent = fs16.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -3702,23 +3617,23 @@ linked_projects:
 `;
     });
   }
-  fs15.writeFileSync(configFilePath, configContent);
+  fs16.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
   const summary = [
     `Linked projects:`,
-    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc9.dim(`(${p.source})`)}`),
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc11.dim(`(${p.source})`)}`),
     ``,
-    `Workspace file: ${pc9.cyan(workspaceFile)}`
+    `Workspace file: ${pc11.cyan(workspaceFile)}`
   ];
-  note8(summary.join("\n"), "Link Summary");
-  outro3(pc9.green(`\u2713 Projects linked! Open ${pc9.bold(workspaceFile)} in VSCode to access linked data.`));
-  const shouldExpose = await confirm5({
+  note9(summary.join("\n"), "Link Summary");
+  outro3(pc11.green(`\u2713 Projects linked! Open ${pc11.bold(workspaceFile)} in VSCode to access linked data.`));
+  const shouldExpose = await confirm6({
     message: "Also expose these linked projects to the MCP server (for Agent access)?",
     initialValue: true
   });
-  if (shouldExpose && !isCancel7(shouldExpose)) {
+  if (shouldExpose && !isCancel8(shouldExpose)) {
     try {
       const { loadMCPConfig: loadMCPConfig3, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       const mcpConfig = loadMCPConfig3();
@@ -3726,9 +3641,9 @@ linked_projects:
         setProjectConfig2(mcpConfig, project.name, true, void 0, project.dataPath);
       }
       saveMCPConfig2(mcpConfig);
-      note8("Projects have been added to the global MCP configuration.", "MCP Updated");
+      note9("Projects have been added to the global MCP configuration.", "MCP Updated");
     } catch (err) {
-      note8(`Failed to update MCP config: ${err}`, "MCP Update Failed");
+      note9(`Failed to update MCP config: ${err}`, "MCP Update Failed");
     }
   }
 }
@@ -3742,34 +3657,34 @@ var init_link_flow = __esm({
 });
 
 // src/commands/wizard/sync-flow.ts
-import { confirm as confirm6, spinner as spinner5, note as note9, outro as outro4, cancel as cancel4, isCancel as isCancel8 } from "@clack/prompts";
-import pc10 from "picocolors";
-import * as fs16 from "fs";
-import * as path15 from "path";
+import { confirm as confirm7, spinner as spinner5, note as note10, outro as outro4, cancel as cancel5, isCancel as isCancel9 } from "@clack/prompts";
+import pc12 from "picocolors";
+import * as fs17 from "fs";
+import * as path16 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path15.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path16.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs16.existsSync(path15.join(localPath, dir))
+    (dir) => fs17.existsSync(path16.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
-    outro4(pc10.yellow("No data found in workspace storage to sync."));
+    outro4(pc12.yellow("No data found in workspace storage to sync."));
     return;
   }
-  note9(
+  note10(
     `The following will be copied to global storage:
 ${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 
-Destination: ${pc10.cyan(globalPath)}`,
+Destination: ${pc12.cyan(globalPath)}`,
     "Sync Preview"
   );
-  const shouldSync = await confirm6({
+  const shouldSync = await confirm7({
     message: "Proceed with sync to global storage?",
     initialValue: true
   });
-  if (isCancel8(shouldSync) || !shouldSync) {
+  if (isCancel9(shouldSync) || !shouldSync) {
     outro4("Sync cancelled.");
     return;
   }
@@ -3778,8 +3693,8 @@ Destination: ${pc10.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path15.join(localPath, dir);
-      const destDir = path15.join(globalPath, dir);
+      const srcDir = path16.join(localPath, dir);
+      const destDir = path16.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -3788,15 +3703,15 @@ Destination: ${pc10.cyan(globalPath)}`,
       `Synced directories:`,
       ...existingDirs.map((d) => `  \u2713 ${d}/`),
       ``,
-      `Global path: ${pc10.cyan(globalPath)}`,
+      `Global path: ${pc12.cyan(globalPath)}`,
       ``,
       `Other projects can now link this knowledge!`
     ];
-    note9(summary.join("\n"), "Sync Summary");
-    outro4(pc10.green("\u2713 Workspace knowledge synced to global storage!"));
+    note10(summary.join("\n"), "Sync Summary");
+    outro4(pc12.green("\u2713 Workspace knowledge synced to global storage!"));
   } catch (error) {
     s.stop("Error occurred");
-    cancel4(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
+    cancel5(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
@@ -3809,10 +3724,10 @@ var init_sync_flow = __esm({
 });
 
 // src/commands/wizard/update-flow.ts
-import { confirm as confirm7, spinner as spinner6, note as note10, outro as outro5, cancel as cancel5, isCancel as isCancel9 } from "@clack/prompts";
-import pc11 from "picocolors";
-import * as fs17 from "fs";
-import * as path16 from "path";
+import { confirm as confirm8, spinner as spinner6, note as note11, outro as outro5, cancel as cancel6, isCancel as isCancel10 } from "@clack/prompts";
+import pc13 from "picocolors";
+import * as fs18 from "fs";
+import * as path17 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner6();
   s.start("Checking for updates");
@@ -3823,7 +3738,7 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const customGlobalPath = getEffectiveRRCEHome(workspacePath);
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     s.stop("Updates found");
-    note10(
+    note11(
       `The following will be updated from the package:
   \u2022 prompts/ (${prompts.length} agent prompts)
   \u2022 templates/ (output templates)
@@ -3832,20 +3747,20 @@ Target locations:
 ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       "Update Preview"
     );
-    const shouldUpdate = await confirm7({
+    const shouldUpdate = await confirm8({
       message: "Proceed with update?",
       initialValue: true
     });
-    if (isCancel9(shouldUpdate) || !shouldUpdate) {
+    if (isCancel10(shouldUpdate) || !shouldUpdate) {
       outro5("Update cancelled.");
       return;
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path16.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path17.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs17.readFileSync(configFilePath, "utf-8");
+    const configContent = fs18.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -3864,17 +3779,17 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       ``,
       `Your configuration and knowledge files were preserved.`
     ];
-    note10(summary.join("\n"), "Update Summary");
-    outro5(pc11.green("\u2713 Successfully updated from package!"));
+    note11(summary.join("\n"), "Update Summary");
+    outro5(pc13.green("\u2713 Successfully updated from package!"));
   } catch (error) {
     s.stop("Error occurred");
-    cancel5(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
+    cancel6(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path16.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path16.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path17.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path17.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -3894,13 +3809,13 @@ var init_update_flow = __esm({
 });
 
 // src/commands/wizard/delete-flow.ts
-import { multiselect as multiselect5, confirm as confirm8, spinner as spinner7, note as note11, cancel as cancel6, isCancel as isCancel10 } from "@clack/prompts";
-import pc12 from "picocolors";
-import * as fs18 from "fs";
+import { multiselect as multiselect5, confirm as confirm9, spinner as spinner7, note as note12, cancel as cancel7, isCancel as isCancel11 } from "@clack/prompts";
+import pc14 from "picocolors";
+import * as fs19 from "fs";
 async function runDeleteGlobalProjectFlow(availableProjects) {
   const globalProjects = availableProjects.filter((p) => p.source === "global");
   if (globalProjects.length === 0) {
-    note11("No globally stored projects found to delete.", "Info");
+    note12("No globally stored projects found to delete.", "Info");
     return;
   }
   const selectedProjects = await multiselect5({
@@ -3912,22 +3827,22 @@ async function runDeleteGlobalProjectFlow(availableProjects) {
     })),
     required: false
   });
-  if (isCancel10(selectedProjects)) {
-    cancel6("Deletion cancelled.");
+  if (isCancel11(selectedProjects)) {
+    cancel7("Deletion cancelled.");
     return;
   }
   const projectsToDelete = selectedProjects;
   if (projectsToDelete.length === 0) {
-    note11("No projects selected.", "Cancelled");
+    note12("No projects selected.", "Cancelled");
     return;
   }
-  const confirmed = await confirm8({
-    message: `${pc12.red("WARNING:")} This will PERMANENTLY DELETE the knowledge/config for ${projectsToDelete.length} detected global projects.
+  const confirmed = await confirm9({
+    message: `${pc14.red("WARNING:")} This will PERMANENTLY DELETE the knowledge/config for ${projectsToDelete.length} detected global projects.
 Are you sure?`,
     initialValue: false
   });
-  if (!confirmed || isCancel10(confirmed)) {
-    cancel6("Deletion cancelled.");
+  if (!confirmed || isCancel11(confirmed)) {
+    cancel7("Deletion cancelled.");
     return;
   }
   const s = spinner7();
@@ -3938,8 +3853,8 @@ Are you sure?`,
     for (const projectName of projectsToDelete) {
       const project = globalProjects.find((p) => p.name === projectName);
       if (!project) continue;
-      if (fs18.existsSync(project.dataPath)) {
-        fs18.rmSync(project.dataPath, { recursive: true, force: true });
+      if (fs19.existsSync(project.dataPath)) {
+        fs19.rmSync(project.dataPath, { recursive: true, force: true });
       }
       const newConfig = removeProjectConfig(mcpConfig, projectName);
       configChanged = true;
@@ -3951,7 +3866,7 @@ Are you sure?`,
     await new Promise((r) => setTimeout(r, 1e3));
   } catch (error) {
     s.stop("Error occurred during deletion");
-    note11(`Failed to delete some projects: ${error}`, "Error");
+    note12(`Failed to delete some projects: ${error}`, "Error");
   }
 }
 var init_delete_flow = __esm({
@@ -3967,11 +3882,11 @@ var wizard_exports = {};
 __export(wizard_exports, {
   runWizard: () => runWizard
 });
-import { intro as intro2, select as select4, spinner as spinner8, note as note12, outro as outro7, isCancel as isCancel11 } from "@clack/prompts";
-import pc13 from "picocolors";
-import * as fs19 from "fs";
+import { intro as intro2, select as select5, spinner as spinner8, note as note13, outro as outro7, isCancel as isCancel12 } from "@clack/prompts";
+import pc15 from "picocolors";
+import * as fs20 from "fs";
 async function runWizard() {
-  intro2(pc13.cyan(pc13.inverse(" RRCE-Workflow Setup ")));
+  intro2(pc15.cyan(pc15.inverse(" RRCE-Workflow Setup ")));
   const s = spinner8();
   s.start("Detecting environment");
   const workspacePath = detectWorkspaceRoot();
@@ -3987,9 +3902,9 @@ async function runWizard() {
   }
   await new Promise((r) => setTimeout(r, 800));
   s.stop("Environment detected");
-  note12(
-    `Git User:  ${pc13.bold(gitUser || "(not found)")}
-Workspace: ${pc13.bold(workspaceName)}`,
+  note13(
+    `Git User:  ${pc15.bold(gitUser || "(not found)")}
+Workspace: ${pc15.bold(workspaceName)}`,
     "Context"
   );
   const detectedProjects = scanForProjects({
@@ -3997,11 +3912,11 @@ Workspace: ${pc13.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  let isAlreadyConfigured = fs19.existsSync(configFilePath);
+  let isAlreadyConfigured = fs20.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs19.readFileSync(configFilePath, "utf-8");
+      const configContent = fs20.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
@@ -4018,7 +3933,7 @@ Workspace: ${pc13.bold(workspaceName)}`,
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs19.existsSync(localDataPath);
+  const hasLocalData = fs20.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     menuOptions.push({
@@ -4050,11 +3965,11 @@ Workspace: ${pc13.bold(workspaceName)}`,
     menuOptions.push({ value: "update", label: "\u{1F4E6} Update from package", hint: "Get latest prompts & templates" });
     menuOptions.push({ value: "reconfigure", label: "\u{1F527} Reconfigure project", hint: "Change storage mode, tools, etc." });
     menuOptions.push({ value: "exit", label: "\u21A9  Exit" });
-    const action = await select4({
+    const action = await select5({
       message: "This workspace is already configured. What would you like to do?",
       options: menuOptions
     });
-    if (isCancel11(action) || action === "exit") {
+    if (isCancel12(action) || action === "exit") {
       outro7("Exited.");
       process.exit(0);
     }
@@ -4104,18 +4019,18 @@ init_wizard();
 
 // src/commands/selector.ts
 init_prompts();
-import { intro as intro3, select as select5, note as note13, cancel as cancel8, isCancel as isCancel12, outro as outro8 } from "@clack/prompts";
-import pc14 from "picocolors";
-import * as path17 from "path";
+import { intro as intro3, select as select6, note as note14, cancel as cancel9, isCancel as isCancel13, outro as outro8 } from "@clack/prompts";
+import pc16 from "picocolors";
+import * as path18 from "path";
 async function runSelector() {
-  const workspaceName = path17.basename(process.cwd());
-  intro3(pc14.cyan(pc14.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const workspaceName = path18.basename(process.cwd());
+  intro3(pc16.cyan(pc16.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {
-    cancel8("No agents found. Run `rrce-workflow` to set up.");
+    cancel9("No agents found. Run `rrce-workflow` to set up.");
     process.exit(0);
   }
-  const selection = await select5({
+  const selection = await select6({
     message: "Select an agent:",
     options: [
       {
@@ -4135,8 +4050,8 @@ async function runSelector() {
       }))
     ]
   });
-  if (isCancel12(selection)) {
-    cancel8("Selection cancelled.");
+  if (isCancel13(selection)) {
+    cancel9("Selection cancelled.");
     process.exit(0);
   }
   if (selection === "mcp") {
@@ -4150,9 +4065,9 @@ async function runSelector() {
     return;
   }
   const prompt = selection;
-  note13(
+  note14(
     `Use this agent in your IDE by invoking:
-${pc14.bold(pc14.cyan(`@${prompt.frontmatter.name}`))}`,
+${pc16.bold(pc16.cyan(`@${prompt.frontmatter.name}`))}`,
     "Agent Selected"
   );
   outro8("Done");