rrce-workflow 0.3.19 → 0.3.20

package/dist/index.js

@@ -1646,9 +1646,434 @@ ${JSON.stringify(data, null, 2)}`;
   }
 });
 
+// src/mcp/resources/types.ts
+var init_types2 = __esm({
+  "src/mcp/resources/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/resources/constants.ts
+var INDEXABLE_EXTENSIONS, CODE_EXTENSIONS, SKIP_DIRS;
+var init_constants = __esm({
+  "src/mcp/resources/constants.ts"() {
+    "use strict";
+    INDEXABLE_EXTENSIONS = [
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".pyw",
+      ".go",
+      ".rs",
+      ".java",
+      ".kt",
+      ".kts",
+      ".c",
+      ".cpp",
+      ".h",
+      ".hpp",
+      ".cs",
+      ".rb",
+      ".php",
+      ".swift",
+      ".md",
+      ".mdx",
+      ".json",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".sh",
+      ".bash",
+      ".zsh",
+      ".sql",
+      ".html",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less"
+    ];
+    CODE_EXTENSIONS = [
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".pyw",
+      ".go",
+      ".rs",
+      ".java",
+      ".kt",
+      ".kts",
+      ".c",
+      ".cpp",
+      ".h",
+      ".hpp",
+      ".cs",
+      ".rb",
+      ".php",
+      ".swift",
+      ".sh",
+      ".bash",
+      ".zsh",
+      ".sql"
+    ];
+    SKIP_DIRS = [
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      ".next",
+      "__pycache__",
+      "venv",
+      ".venv",
+      "target",
+      "vendor"
+    ];
+  }
+});
+
+// src/mcp/resources/utils.ts
+import * as fs13 from "fs";
+import * as path15 from "path";
+import ignore from "ignore";
+function estimateTokens(text2) {
+  return Math.ceil(text2.length / 4);
+}
+function getScanContext(project, scanRoot) {
+  const gitignorePath = path15.join(scanRoot, ".gitignore");
+  const ig = fs13.existsSync(gitignorePath) ? ignore().add(fs13.readFileSync(gitignorePath, "utf-8")) : null;
+  const toPosixRelativePath = (absolutePath) => {
+    const rel = path15.relative(scanRoot, absolutePath);
+    return rel.split(path15.sep).join("/");
+  };
+  const isUnderGitDir = (absolutePath) => {
+    const rel = toPosixRelativePath(absolutePath);
+    return rel === ".git" || rel.startsWith(".git/");
+  };
+  const isIgnoredByGitignore = (absolutePath, isDir) => {
+    if (!ig) return false;
+    const rel = toPosixRelativePath(absolutePath);
+    return ig.ignores(isDir ? `${rel}/` : rel);
+  };
+  const shouldSkipEntryDir = (absolutePath) => {
+    const dirName = path15.basename(absolutePath);
+    if (dirName === ".git") return true;
+    if (SKIP_DIRS.includes(dirName)) return true;
+    if (isIgnoredByGitignore(absolutePath, true)) return true;
+    return false;
+  };
+  const shouldSkipEntryFile = (absolutePath) => {
+    if (isUnderGitDir(absolutePath)) return true;
+    if (isIgnoredByGitignore(absolutePath, false)) return true;
+    return false;
+  };
+  return { shouldSkipEntryDir, shouldSkipEntryFile };
+}
+var init_utils2 = __esm({
+  "src/mcp/resources/utils.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/mcp/resources/paths.ts
+import * as fs14 from "fs";
+function resolveProjectPaths(project, pathInput) {
+  const config = loadMCPConfig();
+  let workspaceRoot = pathInput;
+  let workspaceName = project;
+  if (!workspaceRoot && project) {
+    const projConfig = findProjectConfig(config, { name: project });
+    if (projConfig?.path) {
+      workspaceRoot = projConfig.path;
+    }
+  }
+  if (!workspaceName && workspaceRoot) {
+    const projConfig = findProjectConfig(config, { path: workspaceRoot });
+    workspaceName = projConfig?.name || getWorkspaceName(workspaceRoot);
+  }
+  if (!workspaceName) {
+    workspaceName = "unknown";
+  }
+  let rrceData = "";
+  let mode = "global";
+  let configFilePath = "";
+  if (workspaceRoot) {
+    configFilePath = getConfigPath(workspaceRoot);
+    const rrceHome = getEffectiveGlobalPath();
+    if (configFilePath.startsWith(rrceHome)) {
+      mode = "global";
+    } else {
+      mode = "workspace";
+      if (fs14.existsSync(configFilePath)) {
+        const content = fs14.readFileSync(configFilePath, "utf-8");
+        if (content.includes("mode: global")) mode = "global";
+        if (content.includes("mode: workspace")) mode = "workspace";
+      }
+    }
+    rrceData = resolveDataPath(mode, workspaceName, workspaceRoot);
+  } else {
+    rrceData = resolveDataPath("global", workspaceName, "");
+  }
+  return {
+    RRCE_HOME: getRRCEHome(),
+    RRCE_DATA: rrceData,
+    WORKSPACE_ROOT: workspaceRoot || null,
+    WORKSPACE_NAME: workspaceName,
+    storage_mode: mode,
+    config_path: configFilePath || null
+  };
+}
+var init_paths2 = __esm({
+  "src/mcp/resources/paths.ts"() {
+    "use strict";
+    init_config();
+    init_config_utils();
+    init_paths();
+  }
+});
+
+// src/mcp/resources/projects.ts
+import * as fs15 from "fs";
+import * as path16 from "path";
+function getExposedProjects() {
+  const config = loadMCPConfig();
+  const knownProjects = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
+  const allProjects = projectService.scan({ knownProjects });
+  const activeProject = detectActiveProject(allProjects);
+  const potentialProjects = [...allProjects];
+  if (activeProject) {
+    let cfgContent = null;
+    if (fs15.existsSync(path16.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
+      cfgContent = fs15.readFileSync(path16.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
+    } else if (fs15.existsSync(path16.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
+      cfgContent = fs15.readFileSync(path16.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
+    }
+    if (cfgContent) {
+      if (cfgContent.includes("linked_projects:")) {
+        const lines = cfgContent.split("\n");
+        let inLinked = false;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("linked_projects:")) {
+            inLinked = true;
+            continue;
+          }
+          if (inLinked) {
+            if (trimmed.startsWith("-") || trimmed.startsWith("linked_projects")) {
+            } else if (trimmed !== "" && !trimmed.startsWith("#")) {
+              inLinked = false;
+            }
+            if (inLinked && trimmed.startsWith("-")) {
+              const val = trimmed.replace(/^-\s*/, "").trim();
+              const [pName] = val.split(":");
+              if (!potentialProjects.some((p) => p.name === pName)) {
+                const found = allProjects.find((p) => p.name === pName);
+                if (found) {
+                  potentialProjects.push(found);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return potentialProjects.filter((project) => isProjectExposed(config, project.name, project.sourcePath || project.path));
+}
+function detectActiveProject(knownProjects) {
+  let scanList = knownProjects;
+  if (!scanList) {
+    const config = loadMCPConfig();
+    const knownProjectsMap = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
+    const all = projectService.scan({ knownProjects: knownProjectsMap });
+    scanList = all.filter((project) => isProjectExposed(config, project.name, project.sourcePath || project.path));
+  }
+  return findClosestProject(scanList);
+}
+function getProjectContext(projectName) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project) {
+    return null;
+  }
+  const permissions = getProjectPermissions(config, projectName, project.sourcePath || project.path);
+  if (!permissions.knowledge) {
+    return null;
+  }
+  if (!project.knowledgePath) {
+    return null;
+  }
+  const contextPath = path16.join(project.knowledgePath, "project-context.md");
+  if (!fs15.existsSync(contextPath)) {
+    return null;
+  }
+  return fs15.readFileSync(contextPath, "utf-8");
+}
+function getCodeIndexPath(project) {
+  const scanRoot = project.path || project.dataPath;
+  return path16.join(project.knowledgePath || path16.join(scanRoot, ".rrce-workflow", "knowledge"), "code-embeddings.json");
+}
+var init_projects = __esm({
+  "src/mcp/resources/projects.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    init_detection();
+    init_detection_service();
+  }
+});
+
+// src/mcp/resources/tasks.ts
+import * as fs16 from "fs";
+import * as path17 from "path";
+import * as os3 from "os";
+import * as crypto from "crypto";
+function getProjectTasks(projectName) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project) {
+    return [];
+  }
+  const permissions = getProjectPermissions(config, projectName, project.sourcePath || project.path);
+  if (!permissions.tasks) {
+    return [];
+  }
+  if (!project.tasksPath || !fs16.existsSync(project.tasksPath)) {
+    return [];
+  }
+  const tasks = [];
+  try {
+    const taskDirs = fs16.readdirSync(project.tasksPath, { withFileTypes: true });
+    for (const dir of taskDirs) {
+      if (!dir.isDirectory()) continue;
+      const metaPath = path17.join(project.tasksPath, dir.name, "meta.json");
+      if (fs16.existsSync(metaPath)) {
+        try {
+          const meta = JSON.parse(fs16.readFileSync(metaPath, "utf-8"));
+          tasks.push(meta);
+        } catch (err) {
+          logger.error(`[getProjectTasks] Failed to parse meta.json in ${dir.name}`, err);
+        }
+      }
+    }
+  } catch (err) {
+    logger.error(`[getProjectTasks] Failed to read tasks directory ${project.tasksPath}`, err);
+  }
+  return tasks;
+}
+function getTask(projectName, taskSlug) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project || !project.tasksPath) return null;
+  const metaPath = path17.join(project.tasksPath, taskSlug, "meta.json");
+  if (!fs16.existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(fs16.readFileSync(metaPath, "utf-8"));
+  } catch (err) {
+    logger.error(`[getTask] Failed to parse meta.json for task ${taskSlug}`, err);
+    return null;
+  }
+}
+async function createTask(projectName, taskSlug, taskData) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project || !project.tasksPath) {
+    throw new Error(`Project '${projectName}' not found or not configured with a tasks path.`);
+  }
+  const taskDir = path17.join(project.tasksPath, taskSlug);
+  if (fs16.existsSync(taskDir)) {
+    throw new Error(`Task with slug '${taskSlug}' already exists.`);
+  }
+  fs16.mkdirSync(taskDir, { recursive: true });
+  fs16.mkdirSync(path17.join(taskDir, "research"), { recursive: true });
+  fs16.mkdirSync(path17.join(taskDir, "planning"), { recursive: true });
+  fs16.mkdirSync(path17.join(taskDir, "execution"), { recursive: true });
+  fs16.mkdirSync(path17.join(taskDir, "docs"), { recursive: true });
+  const rrceHome = process.env.RRCE_HOME || path17.join(os3.homedir(), ".rrce-workflow");
+  const templatePath = path17.join(rrceHome, "templates", "meta.template.json");
+  let meta = {
+    task_id: crypto.randomUUID(),
+    task_slug: taskSlug,
+    status: "draft",
+    agents: {}
+  };
+  if (fs16.existsSync(templatePath)) {
+    try {
+      const template = JSON.parse(fs16.readFileSync(templatePath, "utf-8"));
+      meta = { ...template, ...meta };
+    } catch (e) {
+      logger.error("Failed to load meta template", e);
+    }
+  }
+  meta.created_at = (/* @__PURE__ */ new Date()).toISOString();
+  meta.updated_at = meta.created_at;
+  meta.workspace = {
+    name: project.name,
+    path: project.path || project.dataPath,
+    hash: project.name
+  };
+  Object.assign(meta, taskData);
+  const metaPath = path17.join(taskDir, "meta.json");
+  fs16.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+  return meta;
+}
+async function updateTask(projectName, taskSlug, taskData) {
+  const meta = getTask(projectName, taskSlug);
+  if (!meta) throw new Error(`Task '${taskSlug}' not found.`);
+  const updatedMeta = {
+    ...meta,
+    ...taskData,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Ensure nested objects are merged if they exist in taskData
+    agents: taskData.agents ? { ...meta.agents, ...taskData.agents } : meta.agents,
+    workspace: meta.workspace
+    // Protect workspace metadata
+  };
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project || !project.tasksPath) return null;
+  const metaPath = path17.join(project.tasksPath, taskSlug, "meta.json");
+  fs16.writeFileSync(metaPath, JSON.stringify(updatedMeta, null, 2));
+  return updatedMeta;
+}
+function deleteTask(projectName, taskSlug) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project || !project.tasksPath) return false;
+  const taskDir = path17.join(project.tasksPath, taskSlug);
+  if (!fs16.existsSync(taskDir)) return false;
+  if (fs16.rmSync) {
+    fs16.rmSync(taskDir, { recursive: true, force: true });
+  } else {
+    fs16.rmdirSync(taskDir, { recursive: true });
+  }
+  return true;
+}
+var init_tasks = __esm({
+  "src/mcp/resources/tasks.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    init_detection_service();
+  }
+});
+
 // src/mcp/services/rag.ts
-import * as fs13 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 var INDEX_VERSION, DEFAULT_MODEL, RAGService;
 var init_rag = __esm({
   "src/mcp/services/rag.ts"() {
@@ -1702,9 +2127,9 @@ var init_rag = __esm({
        */
       loadIndex() {
         if (this.index) return;
-        if (fs13.existsSync(this.indexPath)) {
+        if (fs17.existsSync(this.indexPath)) {
           try {
-            const data = fs13.readFileSync(this.indexPath, "utf-8");
+            const data = fs17.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) {
@@ -1730,11 +2155,11 @@ var init_rag = __esm({
       saveIndex() {
         if (!this.index) return;
         try {
-          const dir = path15.dirname(this.indexPath);
-          if (!fs13.existsSync(dir)) {
-            fs13.mkdirSync(dir, { recursive: true });
+          const dir = path18.dirname(this.indexPath);
+          if (!fs17.existsSync(dir)) {
+            fs17.mkdirSync(dir, { recursive: true });
           }
-          fs13.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+          fs17.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);
@@ -1745,13 +2170,13 @@ var init_rag = __esm({
        */
       saveIndexAtomic() {
         if (!this.index) return;
-        const dir = path15.dirname(this.indexPath);
-        if (!fs13.existsSync(dir)) {
-          fs13.mkdirSync(dir, { recursive: true });
+        const dir = path18.dirname(this.indexPath);
+        if (!fs17.existsSync(dir)) {
+          fs17.mkdirSync(dir, { recursive: true });
         }
         const tmpPath = `${this.indexPath}.tmp`;
-        fs13.writeFileSync(tmpPath, JSON.stringify(this.index, null, 2));
-        fs13.renameSync(tmpPath, this.indexPath);
+        fs17.writeFileSync(tmpPath, JSON.stringify(this.index, null, 2));
+        fs17.renameSync(tmpPath, this.indexPath);
       }
       /**
        * Save index only if enough time passed since last save
@@ -2284,10 +2709,10 @@ var init_context_extractor = __esm({
 });
 
 // src/mcp/services/dependency-graph.ts
-import * as fs14 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path19 from "path";
 function parseImports(filePath, content) {
-  const ext = path16.extname(filePath).toLowerCase();
+  const ext = path19.extname(filePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   const edges = [];
   const patterns = IMPORT_PATTERNS[language] || IMPORT_PATTERNS.javascript || [];
@@ -2317,20 +2742,20 @@ function parseImports(filePath, content) {
   return edges;
 }
 function resolveImport(fromFile, importPath, language) {
-  const fromDir = path16.dirname(fromFile);
+  const fromDir = path19.dirname(fromFile);
   if (importPath.startsWith(".")) {
-    const candidates = generateCandidates(path16.resolve(fromDir, importPath), language);
+    const candidates = generateCandidates(path19.resolve(fromDir, importPath), language);
     for (const candidate of candidates) {
-      if (fs14.existsSync(candidate)) {
+      if (fs18.existsSync(candidate)) {
         return { path: candidate, isResolved: true };
       }
     }
-    return { path: path16.resolve(fromDir, importPath), isResolved: false };
+    return { path: path19.resolve(fromDir, importPath), isResolved: false };
   }
   if (importPath.startsWith("/")) {
     const candidates = generateCandidates(importPath, language);
     for (const candidate of candidates) {
-      if (fs14.existsSync(candidate)) {
+      if (fs18.existsSync(candidate)) {
         return { path: candidate, isResolved: true };
       }
     }
@@ -2340,7 +2765,7 @@ function resolveImport(fromFile, importPath, language) {
 }
 function generateCandidates(basePath, language) {
   const candidates = [];
-  if (path16.extname(basePath)) {
+  if (path19.extname(basePath)) {
     candidates.push(basePath);
   }
   switch (language) {
@@ -2455,18 +2880,18 @@ async function scanProjectDependencies(projectRoot, options = {}) {
   const files = [];
   function scanDir(dir) {
     try {
-      const entries = fs14.readdirSync(dir, { withFileTypes: true });
+      const entries = fs18.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path16.join(dir, entry.name);
+        const fullPath = path19.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (!skipDirs.includes(entry.name) && !entry.name.startsWith(".")) {
             scanDir(fullPath);
           }
         } else if (entry.isFile()) {
-          const ext = path16.extname(entry.name).toLowerCase();
+          const ext = path19.extname(entry.name).toLowerCase();
           if (extensions.includes(ext)) {
             try {
-              const content = fs14.readFileSync(fullPath, "utf-8");
+              const content = fs18.readFileSync(fullPath, "utf-8");
               files.push({ path: fullPath, content });
             } catch {
             }
@@ -2715,222 +3140,57 @@ function getLanguageFromPath(filePath) {
   const langMap = {
     "ts": "typescript",
     "tsx": "typescript",
-    "js": "javascript",
-    "jsx": "javascript",
-    "mjs": "javascript",
-    "cjs": "javascript",
-    "py": "python",
-    "go": "go",
-    "rs": "rust",
-    "java": "java",
-    "kt": "kotlin",
-    "rb": "ruby",
-    "php": "php",
-    "swift": "swift",
-    "c": "c",
-    "cpp": "cpp",
-    "h": "c",
-    "hpp": "cpp",
-    "cs": "csharp"
-  };
-  return langMap[ext] ?? "unknown";
-}
-function searchSymbols(symbolResults, query, options = {}) {
-  const { type = "any", fuzzy = true, limit = 10, minScore = 0.3 } = options;
-  const matches = [];
-  for (const result of symbolResults) {
-    for (const symbol of result.symbols) {
-      if (type !== "any" && symbol.type !== type) continue;
-      const score = fuzzy ? fuzzyMatchScore(query, symbol.name) : symbol.name.toLowerCase().includes(query.toLowerCase()) ? 1 : 0;
-      if (score >= minScore) {
-        matches.push({
-          ...symbol,
-          file: result.filePath,
-          score
-        });
-      }
-    }
-  }
-  matches.sort((a, b) => {
-    if (b.score !== a.score) return b.score - a.score;
-    return a.name.length - b.name.length;
-  });
-  return matches.slice(0, limit);
-}
-var init_symbol_extractor = __esm({
-  "src/mcp/services/symbol-extractor.ts"() {
-    "use strict";
-  }
-});
-
-// src/mcp/resources.ts
-import * as fs15 from "fs";
-import * as path17 from "path";
-import * as os3 from "os";
-import * as crypto from "crypto";
-import ignore from "ignore";
-function resolveProjectPaths(project, pathInput) {
-  const config = loadMCPConfig();
-  let workspaceRoot = pathInput;
-  let workspaceName = project;
-  if (!workspaceRoot && project) {
-    const projConfig = findProjectConfig(config, { name: project });
-    if (projConfig?.path) {
-      workspaceRoot = projConfig.path;
-    }
-  }
-  if (!workspaceName && workspaceRoot) {
-    const projConfig = findProjectConfig(config, { path: workspaceRoot });
-    workspaceName = projConfig?.name || getWorkspaceName(workspaceRoot);
-  }
-  if (!workspaceName) {
-    workspaceName = "unknown";
-  }
-  let rrceData = "";
-  let mode = "global";
-  let configFilePath = "";
-  if (workspaceRoot) {
-    configFilePath = getConfigPath(workspaceRoot);
-    const rrceHome = getEffectiveGlobalPath();
-    if (configFilePath.startsWith(rrceHome)) {
-      mode = "global";
-    } else {
-      mode = "workspace";
-      if (fs15.existsSync(configFilePath)) {
-        const content = fs15.readFileSync(configFilePath, "utf-8");
-        if (content.includes("mode: global")) mode = "global";
-        if (content.includes("mode: workspace")) mode = "workspace";
-      }
-    }
-    rrceData = resolveDataPath(mode, workspaceName, workspaceRoot);
-  } else {
-    rrceData = resolveDataPath("global", workspaceName, "");
-  }
-  return {
-    RRCE_HOME: getRRCEHome(),
-    RRCE_DATA: rrceData,
-    WORKSPACE_ROOT: workspaceRoot || null,
-    WORKSPACE_NAME: workspaceName,
-    storage_mode: mode,
-    config_path: configFilePath || null
-  };
-}
-function getExposedProjects() {
-  const config = loadMCPConfig();
-  const knownProjects = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
-  const allProjects = projectService.scan({ knownProjects });
-  const activeProject = detectActiveProject(allProjects);
-  const potentialProjects = [...allProjects];
-  if (activeProject) {
-    let cfgContent = null;
-    if (fs15.existsSync(path17.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
-      cfgContent = fs15.readFileSync(path17.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
-    } else if (fs15.existsSync(path17.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
-      cfgContent = fs15.readFileSync(path17.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
-    }
-    if (cfgContent) {
-      if (cfgContent.includes("linked_projects:")) {
-        const lines = cfgContent.split("\n");
-        let inLinked = false;
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed.startsWith("linked_projects:")) {
-            inLinked = true;
-            continue;
-          }
-          if (inLinked) {
-            if (trimmed.startsWith("-") || trimmed.startsWith("linked_projects")) {
-            } else if (trimmed !== "" && !trimmed.startsWith("#")) {
-              inLinked = false;
-            }
-            if (inLinked && trimmed.startsWith("-")) {
-              const val = trimmed.replace(/^-\s*/, "").trim();
-              const [pName] = val.split(":");
-              if (!potentialProjects.some((p) => p.name === pName)) {
-                const found = allProjects.find((p) => p.name === pName);
-                if (found) {
-                  potentialProjects.push(found);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return potentialProjects.filter((project) => isProjectExposed(config, project.name, project.sourcePath || project.path));
-}
-function getCodeIndexPath(project) {
-  const scanRoot = project.path || project.dataPath;
-  return path17.join(project.knowledgePath || path17.join(scanRoot, ".rrce-workflow", "knowledge"), "code-embeddings.json");
-}
-function detectActiveProject(knownProjects) {
-  let scanList = knownProjects;
-  if (!scanList) {
-    const config = loadMCPConfig();
-    const knownProjectsMap = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
-    const all = projectService.scan({ knownProjects: knownProjectsMap });
-    scanList = all.filter((project) => isProjectExposed(config, project.name, project.sourcePath || project.path));
-  }
-  return findClosestProject(scanList);
-}
-function getProjectContext(projectName) {
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
-  if (!project) {
-    return null;
-  }
-  const permissions = getProjectPermissions(config, projectName, project.sourcePath || project.path);
-  if (!permissions.knowledge) {
-    return null;
-  }
-  if (!project.knowledgePath) {
-    return null;
-  }
-  const contextPath = path17.join(project.knowledgePath, "project-context.md");
-  if (!fs15.existsSync(contextPath)) {
-    return null;
-  }
-  return fs15.readFileSync(contextPath, "utf-8");
-}
-function getProjectTasks(projectName) {
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
-  if (!project) {
-    return [];
-  }
-  const permissions = getProjectPermissions(config, projectName, project.sourcePath || project.path);
-  if (!permissions.tasks) {
-    return [];
-  }
-  if (!project.tasksPath || !fs15.existsSync(project.tasksPath)) {
-    return [];
-  }
-  const tasks = [];
-  try {
-    const taskDirs = fs15.readdirSync(project.tasksPath, { withFileTypes: true });
-    for (const dir of taskDirs) {
-      if (!dir.isDirectory()) continue;
-      const metaPath = path17.join(project.tasksPath, dir.name, "meta.json");
-      if (fs15.existsSync(metaPath)) {
-        try {
-          const meta = JSON.parse(fs15.readFileSync(metaPath, "utf-8"));
-          tasks.push(meta);
-        } catch (err) {
-          logger.error(`[getProjectTasks] Failed to parse meta.json in ${dir.name}`, err);
-        }
+    "js": "javascript",
+    "jsx": "javascript",
+    "mjs": "javascript",
+    "cjs": "javascript",
+    "py": "python",
+    "go": "go",
+    "rs": "rust",
+    "java": "java",
+    "kt": "kotlin",
+    "rb": "ruby",
+    "php": "php",
+    "swift": "swift",
+    "c": "c",
+    "cpp": "cpp",
+    "h": "c",
+    "hpp": "cpp",
+    "cs": "csharp"
+  };
+  return langMap[ext] ?? "unknown";
+}
+function searchSymbols(symbolResults, query, options = {}) {
+  const { type = "any", fuzzy = true, limit = 10, minScore = 0.3 } = options;
+  const matches = [];
+  for (const result of symbolResults) {
+    for (const symbol of result.symbols) {
+      if (type !== "any" && symbol.type !== type) continue;
+      const score = fuzzy ? fuzzyMatchScore(query, symbol.name) : symbol.name.toLowerCase().includes(query.toLowerCase()) ? 1 : 0;
+      if (score >= minScore) {
+        matches.push({
+          ...symbol,
+          file: result.filePath,
+          score
+        });
       }
     }
-  } catch (err) {
-    logger.error(`[getProjectTasks] Failed to read tasks directory ${project.tasksPath}`, err);
   }
-  return tasks;
-}
-function estimateTokens(text2) {
-  return Math.ceil(text2.length / 4);
+  matches.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.name.length - b.name.length;
+  });
+  return matches.slice(0, limit);
 }
+var init_symbol_extractor = __esm({
+  "src/mcp/services/symbol-extractor.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/resources/search.ts
+import * as fs19 from "fs";
+import * as path20 from "path";
 async function searchCode(query, projectFilter, limit = 10, options) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
@@ -2949,7 +3209,7 @@ async function searchCode(query, projectFilter, limit = 10, options) {
     }
     try {
       const codeIndexPath = getCodeIndexPath(project);
-      if (!fs15.existsSync(codeIndexPath)) {
+      if (!fs19.existsSync(codeIndexPath)) {
         logger.debug(`[searchCode] Code index not found for project '${project.name}'`);
         continue;
       }
@@ -2959,7 +3219,7 @@ async function searchCode(query, projectFilter, limit = 10, options) {
         const codeChunk = r;
         results.push({
           project: project.name,
-          file: path17.relative(project.sourcePath || project.path || "", codeChunk.filePath),
+          file: path20.relative(project.sourcePath || project.path || "", codeChunk.filePath),
           snippet: codeChunk.content,
           lineStart: codeChunk.lineStart ?? 1,
           lineEnd: codeChunk.lineEnd ?? 1,
@@ -3040,15 +3300,14 @@ async function searchKnowledge(query, projectFilter, options) {
     if (useRAG) {
       logger.info(`[RAG] Using semantic search for project '${project.name}'`);
       try {
-        const indexPath = path17.join(project.knowledgePath, "embeddings.json");
+        const indexPath = path20.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: path17.relative(project.knowledgePath, r.filePath),
+            file: path20.relative(project.knowledgePath, r.filePath),
             matches: [r.content],
-            // The chunk content is the match
             score: r.score,
             indexingInProgress: indexingInProgress2 || void 0,
             advisoryMessage: advisoryMessage2
@@ -3060,11 +3319,11 @@ async function searchKnowledge(query, projectFilter, options) {
       }
     }
     try {
-      const files = fs15.readdirSync(project.knowledgePath);
+      const files = fs19.readdirSync(project.knowledgePath);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path17.join(project.knowledgePath, file);
-        const content = fs15.readFileSync(filePath, "utf-8");
+        const filePath = path20.join(project.knowledgePath, file);
+        const content = fs19.readFileSync(filePath, "utf-8");
         const lines = content.split("\n");
         const matches = [];
         for (const line of lines) {
@@ -3072,373 +3331,69 @@ async function searchKnowledge(query, projectFilter, options) {
             matches.push(line.trim());
           }
         }
-        if (matches.length > 0) {
-          results.push({
-            project: project.name,
-            file,
-            matches: matches.slice(0, 5),
-            // Limit to 5 matches per file
-            indexingInProgress: indexingInProgress2 || void 0,
-            advisoryMessage: advisoryMessage2
-          });
-        }
-      }
-    } catch (err) {
-      logger.error(`[searchKnowledge] Failed to read knowledge directory ${project.knowledgePath}`, err);
-    }
-  }
-  let filteredResults = results;
-  if (options?.min_score !== void 0 && options.min_score > 0) {
-    filteredResults = results.filter((r) => (r.score ?? 1) >= options.min_score);
-  }
-  filteredResults.sort((a, b) => (b.score ?? 1) - (a.score ?? 1));
-  let truncated = false;
-  let tokenCount = 0;
-  let budgetedResults = filteredResults;
-  if (options?.max_tokens !== void 0 && options.max_tokens > 0) {
-    budgetedResults = [];
-    for (const result of filteredResults) {
-      const resultTokens = estimateTokens(result.matches.join("\n"));
-      if (tokenCount + resultTokens > options.max_tokens) {
-        truncated = true;
-        break;
-      }
-      budgetedResults.push(result);
-      tokenCount += resultTokens;
-    }
-  } else {
-    tokenCount = filteredResults.reduce((sum, r) => sum + estimateTokens(r.matches.join("\n")), 0);
-  }
-  let indexAgeSeconds;
-  let lastIndexedAt;
-  let indexingInProgress;
-  let advisoryMessage;
-  if (projectFilter) {
-    const project = projects.find((p) => p.name === projectFilter);
-    if (project) {
-      indexingInProgress = indexingJobs.isRunning(project.name);
-      advisoryMessage = indexingInProgress ? "Indexing in progress; results may be stale/incomplete." : void 0;
-      const progress = indexingJobs.getProgress(project.name);
-      if (progress.completedAt) {
-        lastIndexedAt = new Date(progress.completedAt).toISOString();
-        indexAgeSeconds = Math.floor((Date.now() - progress.completedAt) / 1e3);
-      }
-    }
-  }
-  const cleanResults = budgetedResults.map(({ indexingInProgress: _, advisoryMessage: __, ...rest }) => rest);
-  return {
-    results: cleanResults,
-    token_count: tokenCount,
-    truncated,
-    index_age_seconds: indexAgeSeconds,
-    last_indexed_at: lastIndexedAt,
-    indexingInProgress,
-    advisoryMessage
-  };
-}
-function getScanContext(project, scanRoot) {
-  const gitignorePath = path17.join(scanRoot, ".gitignore");
-  const ig = fs15.existsSync(gitignorePath) ? ignore().add(fs15.readFileSync(gitignorePath, "utf-8")) : null;
-  const toPosixRelativePath = (absolutePath) => {
-    const rel = path17.relative(scanRoot, absolutePath);
-    return rel.split(path17.sep).join("/");
-  };
-  const isUnderGitDir = (absolutePath) => {
-    const rel = toPosixRelativePath(absolutePath);
-    return rel === ".git" || rel.startsWith(".git/");
-  };
-  const isIgnoredByGitignore = (absolutePath, isDir) => {
-    if (!ig) return false;
-    const rel = toPosixRelativePath(absolutePath);
-    return ig.ignores(isDir ? `${rel}/` : rel);
-  };
-  const shouldSkipEntryDir = (absolutePath) => {
-    const dirName = path17.basename(absolutePath);
-    if (dirName === ".git") return true;
-    if (SKIP_DIRS.includes(dirName)) return true;
-    if (isIgnoredByGitignore(absolutePath, true)) return true;
-    return false;
-  };
-  const shouldSkipEntryFile = (absolutePath) => {
-    if (isUnderGitDir(absolutePath)) return true;
-    if (isIgnoredByGitignore(absolutePath, false)) return true;
-    return false;
-  };
-  return { shouldSkipEntryDir, shouldSkipEntryFile };
-}
-async function indexKnowledge(projectName, force = false) {
-  const config = loadMCPConfig();
-  const projects = getExposedProjects();
-  const project = projects.find((p2) => p2.name === projectName || p2.path && p2.path === projectName);
-  if (!project) {
-    return {
-      state: "failed",
-      status: "failed",
-      success: false,
-      message: `Project '${projectName}' not found`,
-      filesIndexed: 0,
-      filesSkipped: 0,
-      progress: { itemsDone: 0 }
-    };
-  }
-  const projConfig = findProjectConfig(config, { name: project.name, path: project.sourcePath || project.path }) || (project.source === "global" ? { semanticSearch: { enabled: true, model: "Xenova/all-MiniLM-L6-v2" } } : void 0);
-  const isEnabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled;
-  if (!isEnabled) {
-    return {
-      state: "failed",
-      status: "failed",
-      success: false,
-      message: "Semantic Search is not enabled for this project",
-      filesIndexed: 0,
-      filesSkipped: 0,
-      progress: { itemsDone: 0 }
-    };
-  }
-  const scanRoot = project.sourcePath || project.path || project.dataPath;
-  if (!fs15.existsSync(scanRoot)) {
-    return {
-      state: "failed",
-      status: "failed",
-      success: false,
-      message: "Project root not found",
-      filesIndexed: 0,
-      filesSkipped: 0,
-      progress: { itemsDone: 0 }
-    };
-  }
-  const runIndexing = async () => {
-    const { shouldSkipEntryDir, shouldSkipEntryFile } = getScanContext(project, scanRoot);
-    const indexPath = path17.join(project.knowledgePath || path17.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
-    const codeIndexPath = path17.join(project.knowledgePath || path17.join(scanRoot, ".rrce-workflow", "knowledge"), "code-embeddings.json");
-    const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
-    const rag = new RAGService(indexPath, model);
-    const codeRag = new RAGService(codeIndexPath, model);
-    let indexed = 0;
-    let codeIndexed = 0;
-    let skipped = 0;
-    let itemsTotal = 0;
-    let itemsDone = 0;
-    const preCount = (dir) => {
-      const entries = fs15.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path17.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (shouldSkipEntryDir(fullPath)) continue;
-          preCount(fullPath);
-        } else if (entry.isFile()) {
-          const ext = path17.extname(entry.name).toLowerCase();
-          if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
-          if (shouldSkipEntryFile(fullPath)) continue;
-          itemsTotal++;
-        }
-      }
-    };
-    preCount(scanRoot);
-    indexingJobs.update(project.name, { itemsTotal });
-    const cleanupIgnoredFiles = async () => {
-      const indexedFiles = [...rag.getIndexedFiles(), ...codeRag.getIndexedFiles()];
-      const unique = Array.from(new Set(indexedFiles));
-      for (const filePath of unique) {
-        if (!path17.isAbsolute(filePath)) continue;
-        const relFilePath = filePath.split(path17.sep).join("/");
-        const relScanRoot = scanRoot.split(path17.sep).join("/");
-        const isInScanRoot = relFilePath === relScanRoot || relFilePath.startsWith(`${relScanRoot}/`);
-        if (!isInScanRoot) continue;
-        if (shouldSkipEntryFile(filePath)) {
-          await rag.removeFile(filePath);
-          await codeRag.removeFile(filePath);
-        }
-      }
-    };
-    await cleanupIgnoredFiles();
-    const scanDir = async (dir) => {
-      const entries = fs15.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path17.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (shouldSkipEntryDir(fullPath)) continue;
-          await scanDir(fullPath);
-        } else if (entry.isFile()) {
-          const ext = path17.extname(entry.name).toLowerCase();
-          if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
-          if (shouldSkipEntryFile(fullPath)) continue;
-          try {
-            indexingJobs.update(project.name, { currentItem: fullPath, itemsDone });
-            const stat = fs15.statSync(fullPath);
-            const mtime = force ? void 0 : stat.mtimeMs;
-            const content = fs15.readFileSync(fullPath, "utf-8");
-            const wasIndexed = await rag.indexFile(fullPath, content, mtime);
-            if (wasIndexed) {
-              indexed++;
-            } else {
-              skipped++;
-            }
-            if (CODE_EXTENSIONS.includes(ext)) {
-              if (!mtime || codeRag.needsReindex(fullPath, mtime)) {
-                const language = getLanguageFromExtension(ext);
-                const chunks = codeRag.chunkContentWithLines(content);
-                codeRag.clearFileChunks(fullPath);
-                for (const chunk of chunks) {
-                  const context = extractContext(content, chunk.lineStart, language);
-                  await codeRag.indexCodeChunk(fullPath, chunk, context, language, mtime);
-                }
-                codeRag.updateFileMetadata(fullPath, chunks.length, mtime ?? Date.now(), language);
-                codeIndexed++;
-              }
-            }
-          } catch (err) {
-            logger.error(`[indexKnowledge] Failed to index ${fullPath}`, err);
-          } finally {
-            itemsDone++;
-            indexingJobs.update(project.name, { itemsDone });
-            if (itemsDone % 10 === 0) {
-              await new Promise((resolve4) => setImmediate(resolve4));
-            }
-          }
+        if (matches.length > 0) {
+          results.push({
+            project: project.name,
+            file,
+            matches: matches.slice(0, 5),
+            // Limit to 5 matches per file
+            indexingInProgress: indexingInProgress2 || void 0,
+            advisoryMessage: advisoryMessage2
+          });
         }
       }
-    };
-    await scanDir(scanRoot);
-    rag.markFullIndex();
-    codeRag.markFullIndex();
-    const stats = rag.getStats();
-    const codeStats = codeRag.getStats();
-    const message = `Indexed ${indexed} files (${codeIndexed} code files), skipped ${skipped} unchanged. Knowledge: ${stats.totalChunks} chunks. Code: ${codeStats.totalChunks} chunks.`;
-    logger.info(`[RAG] ${project.name}: ${message}`);
-    indexingJobs.update(project.name, { currentItem: void 0 });
-  };
-  const startResult = indexingJobs.startOrStatus(project.name, runIndexing);
-  const p = startResult.progress;
-  return {
-    state: startResult.state,
-    status: startResult.status,
-    success: startResult.status === "started" || startResult.status === "already_running",
-    message: startResult.status === "started" ? `Indexing started in background for '${project.name}'.` : `Indexing already running for '${project.name}'.`,
-    filesIndexed: 0,
-    filesSkipped: 0,
-    progress: {
-      itemsDone: p.itemsDone,
-      itemsTotal: p.itemsTotal,
-      currentItem: p.currentItem,
-      startedAt: p.startedAt,
-      completedAt: p.completedAt,
-      lastError: p.lastError
+    } catch (err) {
+      logger.error(`[searchKnowledge] Failed to read knowledge directory ${project.knowledgePath}`, err);
     }
-  };
-}
-function getContextPreamble() {
-  const activeProject = detectActiveProject();
-  if (!activeProject) {
-    return `## System Context
-No active project detected. Run \`rrce-workflow mcp configure\` to expose projects.
----
-`;
-  }
-  const rrceHome = process.env.RRCE_HOME || path17.join(os3.homedir(), ".rrce-workflow");
-  const workspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
-  const rrceData = activeProject.dataPath;
-  return `## System Context
-| Key | Value |
-|-----|-------|
-| WORKSPACE_ROOT | \`${workspaceRoot}\` |
-| WORKSPACE_NAME | \`${activeProject.name}\` |
-| RRCE_DATA | \`${rrceData}\` |
-| RRCE_HOME | \`${rrceHome}\` |
-
----
-`;
-}
-function getTask(projectName, taskSlug) {
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
-  if (!project || !project.tasksPath) return null;
-  const metaPath = path17.join(project.tasksPath, taskSlug, "meta.json");
-  if (!fs15.existsSync(metaPath)) return null;
-  try {
-    return JSON.parse(fs15.readFileSync(metaPath, "utf-8"));
-  } catch (err) {
-    logger.error(`[getTask] Failed to parse meta.json for task ${taskSlug}`, err);
-    return null;
   }
-}
-async function createTask(projectName, taskSlug, taskData) {
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
-  if (!project || !project.tasksPath) {
-    throw new Error(`Project '${projectName}' not found or not configured with a tasks path.`);
+  let filteredResults = results;
+  if (options?.min_score !== void 0 && options.min_score > 0) {
+    filteredResults = results.filter((r) => (r.score ?? 1) >= options.min_score);
   }
-  const taskDir = path17.join(project.tasksPath, taskSlug);
-  if (fs15.existsSync(taskDir)) {
-    throw new Error(`Task with slug '${taskSlug}' already exists.`);
+  filteredResults.sort((a, b) => (b.score ?? 1) - (a.score ?? 1));
+  let truncated = false;
+  let tokenCount = 0;
+  let budgetedResults = filteredResults;
+  if (options?.max_tokens !== void 0 && options.max_tokens > 0) {
+    budgetedResults = [];
+    for (const result of filteredResults) {
+      const resultTokens = estimateTokens(result.matches.join("\n"));
+      if (tokenCount + resultTokens > options.max_tokens) {
+        truncated = true;
+        break;
+      }
+      budgetedResults.push(result);
+      tokenCount += resultTokens;
+    }
+  } else {
+    tokenCount = filteredResults.reduce((sum, r) => sum + estimateTokens(r.matches.join("\n")), 0);
   }
-  fs15.mkdirSync(taskDir, { recursive: true });
-  fs15.mkdirSync(path17.join(taskDir, "research"), { recursive: true });
-  fs15.mkdirSync(path17.join(taskDir, "planning"), { recursive: true });
-  fs15.mkdirSync(path17.join(taskDir, "execution"), { recursive: true });
-  fs15.mkdirSync(path17.join(taskDir, "docs"), { recursive: true });
-  const rrceHome = process.env.RRCE_HOME || path17.join(os3.homedir(), ".rrce-workflow");
-  const templatePath = path17.join(rrceHome, "templates", "meta.template.json");
-  let meta = {
-    task_id: crypto.randomUUID(),
-    task_slug: taskSlug,
-    status: "draft",
-    agents: {}
-  };
-  if (fs15.existsSync(templatePath)) {
-    try {
-      const template = JSON.parse(fs15.readFileSync(templatePath, "utf-8"));
-      meta = { ...template, ...meta };
-    } catch (e) {
-      logger.error("Failed to load meta template", e);
+  let indexAgeSeconds;
+  let lastIndexedAt;
+  let indexingInProgress;
+  let advisoryMessage;
+  if (projectFilter) {
+    const project = projects.find((p) => p.name === projectFilter);
+    if (project) {
+      indexingInProgress = indexingJobs.isRunning(project.name);
+      advisoryMessage = indexingInProgress ? "Indexing in progress; results may be stale/incomplete." : void 0;
+      const progress = indexingJobs.getProgress(project.name);
+      if (progress.completedAt) {
+        lastIndexedAt = new Date(progress.completedAt).toISOString();
+        indexAgeSeconds = Math.floor((Date.now() - progress.completedAt) / 1e3);
+      }
     }
   }
-  meta.created_at = (/* @__PURE__ */ new Date()).toISOString();
-  meta.updated_at = meta.created_at;
-  meta.workspace = {
-    name: project.name,
-    path: project.path || project.dataPath,
-    hash: project.name
-  };
-  Object.assign(meta, taskData);
-  const metaPath = path17.join(taskDir, "meta.json");
-  fs15.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
-  return meta;
-}
-async function updateTask(projectName, taskSlug, taskData) {
-  const meta = getTask(projectName, taskSlug);
-  if (!meta) throw new Error(`Task '${taskSlug}' not found.`);
-  const updatedMeta = {
-    ...meta,
-    ...taskData,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    // Ensure nested objects are merged if they exist in taskData
-    agents: taskData.agents ? { ...meta.agents, ...taskData.agents } : meta.agents,
-    workspace: meta.workspace
-    // Protect workspace metadata
+  const cleanResults = budgetedResults.map(({ indexingInProgress: _, advisoryMessage: __, ...rest }) => rest);
+  return {
+    results: cleanResults,
+    token_count: tokenCount,
+    truncated,
+    index_age_seconds: indexAgeSeconds,
+    last_indexed_at: lastIndexedAt,
+    indexingInProgress,
+    advisoryMessage
   };
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
-  if (!project || !project.tasksPath) return null;
-  const metaPath = path17.join(project.tasksPath, taskSlug, "meta.json");
-  fs15.writeFileSync(metaPath, JSON.stringify(updatedMeta, null, 2));
-  return updatedMeta;
-}
-function deleteTask(projectName, taskSlug) {
-  const config = loadMCPConfig();
-  const projects = projectService.scan();
-  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
-  if (!project || !project.tasksPath) return false;
-  const taskDir = path17.join(project.tasksPath, taskSlug);
-  if (!fs15.existsSync(taskDir)) return false;
-  if (fs15.rmSync) {
-    fs15.rmSync(taskDir, { recursive: true, force: true });
-  } else {
-    fs15.rmdirSync(taskDir, { recursive: true });
-  }
-  return true;
 }
 async function findRelatedFiles2(filePath, projectName, options = {}) {
   const config = loadMCPConfig();
@@ -3455,10 +3410,10 @@ async function findRelatedFiles2(filePath, projectName, options = {}) {
   }
   const projectRoot = project.sourcePath || project.path || "";
   let absoluteFilePath = filePath;
-  if (!path17.isAbsolute(filePath)) {
-    absoluteFilePath = path17.resolve(projectRoot, filePath);
+  if (!path20.isAbsolute(filePath)) {
+    absoluteFilePath = path20.resolve(projectRoot, filePath);
   }
-  if (!fs15.existsSync(absoluteFilePath)) {
+  if (!fs19.existsSync(absoluteFilePath)) {
     return {
       success: false,
       file: filePath,
@@ -3475,13 +3430,13 @@ async function findRelatedFiles2(filePath, projectName, options = {}) {
       depth: options.depth ?? 1
     });
     const relationships = related.map((r) => ({
-      file: path17.relative(projectRoot, r.file),
+      file: path20.relative(projectRoot, r.file),
       relationship: r.relationship,
       importPath: r.importPath
     }));
     return {
       success: true,
-      file: path17.relative(projectRoot, absoluteFilePath),
+      file: path20.relative(projectRoot, absoluteFilePath),
       project: projectName,
       relationships
     };
@@ -3509,7 +3464,7 @@ async function searchSymbols2(name, projectName, options = {}) {
     };
   }
   const projectRoot = project.sourcePath || project.path || "";
-  if (!fs15.existsSync(projectRoot)) {
+  if (!fs19.existsSync(projectRoot)) {
     return {
       success: false,
       project: projectName,
@@ -3520,14 +3475,14 @@ async function searchSymbols2(name, projectName, options = {}) {
   try {
     const codeFiles = [];
     const scanDir = (dir) => {
-      const entries = fs15.readdirSync(dir, { withFileTypes: true });
+      const entries = fs19.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path17.join(dir, entry.name);
+        const fullPath = path20.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (SKIP_DIRS.includes(entry.name)) continue;
           scanDir(fullPath);
         } else if (entry.isFile()) {
-          const ext = path17.extname(entry.name).toLowerCase();
+          const ext = path20.extname(entry.name).toLowerCase();
           if (CODE_EXTENSIONS.includes(ext)) {
             codeFiles.push(fullPath);
           }
@@ -3538,7 +3493,7 @@ async function searchSymbols2(name, projectName, options = {}) {
     const symbolResults = [];
     for (const file of codeFiles.slice(0, 500)) {
       try {
-        const content = fs15.readFileSync(file, "utf-8");
+        const content = fs19.readFileSync(file, "utf-8");
         const result = extractSymbols(content, file);
         symbolResults.push(result);
       } catch (e) {
@@ -3553,7 +3508,7 @@ async function searchSymbols2(name, projectName, options = {}) {
     const results = matches.map((m) => ({
       name: m.name,
       type: m.type,
-      file: path17.relative(projectRoot, m.file),
+      file: path20.relative(projectRoot, m.file),
       line: m.line,
       signature: m.signature,
       exported: m.exported,
@@ -3586,24 +3541,24 @@ async function getFileSummary(filePath, projectName) {
   }
   const projectRoot = project.sourcePath || project.path || "";
   let absolutePath = filePath;
-  if (!path17.isAbsolute(filePath)) {
-    absolutePath = path17.resolve(projectRoot, filePath);
+  if (!path20.isAbsolute(filePath)) {
+    absolutePath = path20.resolve(projectRoot, filePath);
   }
-  if (!fs15.existsSync(absolutePath)) {
+  if (!fs19.existsSync(absolutePath)) {
     return {
       success: false,
       message: `File not found: ${filePath}`
     };
   }
   try {
-    const stat = fs15.statSync(absolutePath);
-    const content = fs15.readFileSync(absolutePath, "utf-8");
+    const stat = fs19.statSync(absolutePath);
+    const content = fs19.readFileSync(absolutePath, "utf-8");
     const lines = content.split("\n");
     const symbolResult = extractSymbols(content, absolutePath);
     return {
       success: true,
       summary: {
-        path: path17.relative(projectRoot, absolutePath),
+        path: path20.relative(projectRoot, absolutePath),
         language: symbolResult.language,
         lines: lines.length,
         size_bytes: stat.size,
@@ -3617,13 +3572,239 @@ async function getFileSummary(filePath, projectName) {
         }))
       }
     };
-  } catch (e) {
-    logger.error(`[getFileSummary] Error reading ${filePath}`, e);
-    return {
-      success: false,
-      message: `Error reading file: ${e instanceof Error ? e.message : String(e)}`
+  } catch (e) {
+    logger.error(`[getFileSummary] Error reading ${filePath}`, e);
+    return {
+      success: false,
+      message: `Error reading file: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+var init_search = __esm({
+  "src/mcp/resources/search.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    init_config_utils();
+    init_detection_service();
+    init_rag();
+    init_indexing_jobs();
+    init_dependency_graph();
+    init_symbol_extractor();
+    init_projects();
+    init_utils2();
+    init_constants();
+  }
+});
+
+// src/mcp/resources/indexing.ts
+import * as fs20 from "fs";
+import * as path21 from "path";
+async function indexKnowledge(projectName, force = false) {
+  const config = loadMCPConfig();
+  const projects = getExposedProjects();
+  const project = projects.find((p2) => p2.name === projectName || p2.path && p2.path === projectName);
+  if (!project) {
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: `Project '${projectName}' not found`,
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
+  }
+  const projConfig = findProjectConfig(config, { name: project.name, path: project.sourcePath || project.path }) || (project.source === "global" ? { semanticSearch: { enabled: true, model: "Xenova/all-MiniLM-L6-v2" } } : void 0);
+  const isEnabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled;
+  if (!isEnabled) {
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: "Semantic Search is not enabled for this project",
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
+  }
+  const scanRoot = project.sourcePath || project.path || project.dataPath;
+  if (!fs20.existsSync(scanRoot)) {
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: "Project root not found",
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
+  }
+  const runIndexing = async () => {
+    const { shouldSkipEntryDir, shouldSkipEntryFile } = getScanContext(project, scanRoot);
+    const indexPath = path21.join(project.knowledgePath || path21.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
+    const codeIndexPath = path21.join(project.knowledgePath || path21.join(scanRoot, ".rrce-workflow", "knowledge"), "code-embeddings.json");
+    const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
+    const rag = new RAGService(indexPath, model);
+    const codeRag = new RAGService(codeIndexPath, model);
+    let indexed = 0;
+    let codeIndexed = 0;
+    let skipped = 0;
+    let itemsTotal = 0;
+    let itemsDone = 0;
+    const preCount = (dir) => {
+      const entries = fs20.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path21.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (shouldSkipEntryDir(fullPath)) continue;
+          preCount(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path21.extname(entry.name).toLowerCase();
+          if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
+          if (shouldSkipEntryFile(fullPath)) continue;
+          itemsTotal++;
+        }
+      }
+    };
+    preCount(scanRoot);
+    indexingJobs.update(project.name, { itemsTotal });
+    const cleanupIgnoredFiles = async () => {
+      const indexedFiles = [...rag.getIndexedFiles(), ...codeRag.getIndexedFiles()];
+      const unique = Array.from(new Set(indexedFiles));
+      for (const filePath of unique) {
+        if (!path21.isAbsolute(filePath)) continue;
+        const relFilePath = filePath.split(path21.sep).join("/");
+        const relScanRoot = scanRoot.split(path21.sep).join("/");
+        const isInScanRoot = relFilePath === relScanRoot || relFilePath.startsWith(`${relScanRoot}/`);
+        if (!isInScanRoot) continue;
+        if (shouldSkipEntryFile(filePath)) {
+          await rag.removeFile(filePath);
+          await codeRag.removeFile(filePath);
+        }
+      }
+    };
+    await cleanupIgnoredFiles();
+    const scanDir = async (dir) => {
+      const entries = fs20.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path21.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (shouldSkipEntryDir(fullPath)) continue;
+          await scanDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path21.extname(entry.name).toLowerCase();
+          if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
+          if (shouldSkipEntryFile(fullPath)) continue;
+          try {
+            indexingJobs.update(project.name, { currentItem: fullPath, itemsDone });
+            const stat = fs20.statSync(fullPath);
+            const mtime = force ? void 0 : stat.mtimeMs;
+            const content = fs20.readFileSync(fullPath, "utf-8");
+            const wasIndexed = await rag.indexFile(fullPath, content, mtime);
+            if (wasIndexed) {
+              indexed++;
+            } else {
+              skipped++;
+            }
+            if (CODE_EXTENSIONS.includes(ext)) {
+              if (!mtime || codeRag.needsReindex(fullPath, mtime)) {
+                const language = getLanguageFromExtension(ext);
+                const chunks = codeRag.chunkContentWithLines(content);
+                codeRag.clearFileChunks(fullPath);
+                for (const chunk of chunks) {
+                  const context = extractContext(content, chunk.lineStart, language);
+                  await codeRag.indexCodeChunk(fullPath, chunk, context, language, mtime);
+                }
+                codeRag.updateFileMetadata(fullPath, chunks.length, mtime ?? Date.now(), language);
+                codeIndexed++;
+              }
+            }
+          } catch (err) {
+            logger.error(`[indexKnowledge] Failed to index ${fullPath}`, err);
+          } finally {
+            itemsDone++;
+            indexingJobs.update(project.name, { itemsDone });
+            if (itemsDone % 10 === 0) {
+              await new Promise((resolve4) => setImmediate(resolve4));
+            }
+          }
+        }
+      }
     };
+    await scanDir(scanRoot);
+    rag.markFullIndex();
+    codeRag.markFullIndex();
+    const stats = rag.getStats();
+    const codeStats = codeRag.getStats();
+    const message = `Indexed ${indexed} files (${codeIndexed} code files), skipped ${skipped} unchanged. Knowledge: ${stats.totalChunks} chunks. Code: ${codeStats.totalChunks} chunks.`;
+    logger.info(`[RAG] ${project.name}: ${message}`);
+    indexingJobs.update(project.name, { currentItem: void 0 });
+  };
+  const startResult = indexingJobs.startOrStatus(project.name, runIndexing);
+  const p = startResult.progress;
+  return {
+    state: startResult.state,
+    status: startResult.status,
+    success: startResult.status === "started" || startResult.status === "already_running",
+    message: startResult.status === "started" ? `Indexing started in background for '${project.name}'.` : `Indexing already running for '${project.name}'.`,
+    filesIndexed: 0,
+    filesSkipped: 0,
+    progress: {
+      itemsDone: p.itemsDone,
+      itemsTotal: p.itemsTotal,
+      currentItem: p.currentItem,
+      startedAt: p.startedAt,
+      completedAt: p.completedAt,
+      lastError: p.lastError
+    }
+  };
+}
+var init_indexing = __esm({
+  "src/mcp/resources/indexing.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+    init_config_utils();
+    init_rag();
+    init_indexing_jobs();
+    init_context_extractor();
+    init_projects();
+    init_utils2();
+    init_constants();
+  }
+});
+
+// src/mcp/resources/context.ts
+import * as path22 from "path";
+import * as os4 from "os";
+function getContextPreamble() {
+  const activeProject = detectActiveProject();
+  if (!activeProject) {
+    return `## System Context
+No active project detected.
+
+**To resolve paths manually:** 
+- Call \`rrce_resolve_path(project: "your-project-name")\`
+- Or call \`rrce_list_projects()\` to see available projects
+
+If the above tools fail, ask the user for clarification.
+---
+`;
   }
+  const rrceHome = process.env.RRCE_HOME || path22.join(os4.homedir(), ".rrce-workflow");
+  const workspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
+  const rrceData = activeProject.dataPath;
+  return `## System Context
+| Key | Value |
+|-----|-------|
+| WORKSPACE_ROOT | \`${workspaceRoot}\` |
+| WORKSPACE_NAME | \`${activeProject.name}\` |
+| RRCE_DATA | \`${rrceData}\` |
+| RRCE_HOME | \`${rrceHome}\` |
+
+---
+`;
 }
 async function getContextBundle(query, projectName, options = {}) {
   const maxTokens = options.max_tokens ?? 4e3;
@@ -3768,6 +3949,18 @@ async function prefetchTaskContext(projectName, taskSlug, options = {}) {
     truncated: bundle.truncated
   };
 }
+var init_context = __esm({
+  "src/mcp/resources/context.ts"() {
+    "use strict";
+    init_config_utils();
+    init_projects();
+    init_search();
+    init_tasks();
+    init_utils2();
+  }
+});
+
+// src/mcp/resources/validation.ts
 function searchTasks(projectName, options = {}) {
   const allTasks = getProjectTasks(projectName);
   const limit = options.limit ?? 20;
@@ -3886,6 +4079,16 @@ function validatePhase(projectName, taskSlug, phase) {
     suggestions
   };
 }
+var init_validation = __esm({
+  "src/mcp/resources/validation.ts"() {
+    "use strict";
+    init_tasks();
+  }
+});
+
+// src/mcp/resources/sessions.ts
+import * as fs21 from "fs";
+import * as path23 from "path";
 function startSession(projectName, taskSlug, agent, phase) {
   const config = loadMCPConfig();
   const projects = projectService.scan();
@@ -3893,8 +4096,8 @@ function startSession(projectName, taskSlug, agent, phase) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const taskDir = path17.join(project.tasksPath, taskSlug);
-  if (!fs15.existsSync(taskDir)) {
+  const taskDir = path23.join(project.tasksPath, taskSlug);
+  if (!fs21.existsSync(taskDir)) {
     return { success: false, message: `Task '${taskSlug}' not found.` };
   }
   const session = {
@@ -3904,8 +4107,8 @@ function startSession(projectName, taskSlug, agent, phase) {
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
     heartbeat: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const sessionPath = path17.join(taskDir, "session.json");
-  fs15.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+  const sessionPath = path23.join(taskDir, "session.json");
+  fs21.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
   return { success: true, message: `Session started for ${agent} agent on task '${taskSlug}' (phase: ${phase})` };
 }
 function endSession(projectName, taskSlug) {
@@ -3915,11 +4118,11 @@ function endSession(projectName, taskSlug) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const sessionPath = path17.join(project.tasksPath, taskSlug, "session.json");
-  if (!fs15.existsSync(sessionPath)) {
+  const sessionPath = path23.join(project.tasksPath, taskSlug, "session.json");
+  if (!fs21.existsSync(sessionPath)) {
     return { success: true, message: `No active session for task '${taskSlug}'.` };
   }
-  fs15.unlinkSync(sessionPath);
+  fs21.unlinkSync(sessionPath);
   return { success: true, message: `Session ended for task '${taskSlug}'.` };
 }
 function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
@@ -3929,9 +4132,9 @@ function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const taskDir = path17.join(project.tasksPath, taskSlug);
-  if (!fs15.existsSync(taskDir)) {
-    fs15.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path23.join(project.tasksPath, taskSlug);
+  if (!fs21.existsSync(taskDir)) {
+    fs21.mkdirSync(taskDir, { recursive: true });
   }
   const todos = {
     phase,
@@ -3939,91 +4142,41 @@ function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
     items,
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const todosPath = path17.join(taskDir, "agent-todos.json");
-  fs15.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
+  const todosPath = path23.join(taskDir, "agent-todos.json");
+  fs21.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
   return { success: true, message: `Updated ${items.length} todo items for task '${taskSlug}'.`, count: items.length };
 }
-var INDEXABLE_EXTENSIONS, CODE_EXTENSIONS, SKIP_DIRS;
-var init_resources = __esm({
-  "src/mcp/resources.ts"() {
+var init_sessions = __esm({
+  "src/mcp/resources/sessions.ts"() {
     "use strict";
-    init_logger();
     init_config();
-    init_config_utils();
-    init_detection();
     init_detection_service();
-    init_rag();
-    init_indexing_jobs();
-    init_context_extractor();
-    init_dependency_graph();
-    init_symbol_extractor();
-    init_paths();
-    INDEXABLE_EXTENSIONS = [
-      ".ts",
-      ".tsx",
-      ".js",
-      ".jsx",
-      ".mjs",
-      ".cjs",
-      ".py",
-      ".pyw",
-      ".go",
-      ".rs",
-      ".java",
-      ".kt",
-      ".kts",
-      ".c",
-      ".cpp",
-      ".h",
-      ".hpp",
-      ".cs",
-      ".rb",
-      ".php",
-      ".swift",
-      ".md",
-      ".mdx",
-      ".json",
-      ".yaml",
-      ".yml",
-      ".toml",
-      ".sh",
-      ".bash",
-      ".zsh",
-      ".sql",
-      ".html",
-      ".css",
-      ".scss",
-      ".sass",
-      ".less"
-    ];
-    CODE_EXTENSIONS = [
-      ".ts",
-      ".tsx",
-      ".js",
-      ".jsx",
-      ".mjs",
-      ".cjs",
-      ".py",
-      ".pyw",
-      ".go",
-      ".rs",
-      ".java",
-      ".kt",
-      ".kts",
-      ".c",
-      ".cpp",
-      ".h",
-      ".hpp",
-      ".cs",
-      ".rb",
-      ".php",
-      ".swift",
-      ".sh",
-      ".bash",
-      ".zsh",
-      ".sql"
-    ];
-    SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor"];
+  }
+});
+
+// src/mcp/resources/index.ts
+var init_resources = __esm({
+  "src/mcp/resources/index.ts"() {
+    "use strict";
+    init_types2();
+    init_constants();
+    init_utils2();
+    init_paths2();
+    init_projects();
+    init_tasks();
+    init_search();
+    init_indexing();
+    init_context();
+    init_validation();
+    init_sessions();
+  }
+});
+
+// src/mcp/resources.ts
+var init_resources2 = __esm({
+  "src/mcp/resources.ts"() {
+    "use strict";
+    init_resources();
   }
 });
 
@@ -4101,25 +4254,25 @@ function registerResourceHandlers(server) {
     }
   });
 }
-var init_resources2 = __esm({
+var init_resources3 = __esm({
   "src/mcp/handlers/resources.ts"() {
     "use strict";
     init_logger();
     init_config();
-    init_resources();
+    init_resources2();
   }
 });
 
 // src/mcp/prompts.ts
-import * as path18 from "path";
-import * as fs16 from "fs";
+import * as path24 from "path";
+import * as fs22 from "fs";
 function loadBaseProtocol2() {
   if (baseProtocolCache !== null) {
     return baseProtocolCache;
   }
-  const basePath = path18.join(getAgentCorePromptsDir(), "_base.md");
-  if (fs16.existsSync(basePath)) {
-    const content = fs16.readFileSync(basePath, "utf-8");
+  const basePath = path24.join(getAgentCorePromptsDir(), "_base.md");
+  if (fs22.existsSync(basePath)) {
+    const content = fs22.readFileSync(basePath, "utf-8");
     baseProtocolCache = content.replace(/^---[\s\S]*?---\n*/, "");
     return baseProtocolCache;
   }
@@ -4182,15 +4335,15 @@ function renderPromptWithContext(content, args) {
     resolvedWorkspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
     resolvedWorkspaceName = activeProject.name;
     if (activeProject.source === "global") {
-      const workspacesDir = path18.dirname(activeProject.dataPath);
-      resolvedRrceHome = path18.dirname(workspacesDir);
+      const workspacesDir = path24.dirname(activeProject.dataPath);
+      resolvedRrceHome = path24.dirname(workspacesDir);
     }
   } else {
     try {
       const workspaceRoot = detectWorkspaceRoot();
-      const workspaceName = path18.basename(workspaceRoot);
-      const globalWorkspacePath = path18.join(DEFAULT_RRCE_HOME, "workspaces", workspaceName);
-      if (fs16.existsSync(globalWorkspacePath)) {
+      const workspaceName = path24.basename(workspaceRoot);
+      const globalWorkspacePath = path24.join(DEFAULT_RRCE_HOME, "workspaces", workspaceName);
+      if (fs22.existsSync(globalWorkspacePath)) {
         resolvedRrceData = globalWorkspacePath;
         resolvedWorkspaceRoot = workspaceRoot;
         resolvedWorkspaceName = workspaceName;
@@ -4231,7 +4384,7 @@ var init_prompts2 = __esm({
   "src/mcp/prompts.ts"() {
     "use strict";
     init_prompts();
-    init_resources();
+    init_resources2();
     init_paths();
     init_detection_service();
     baseProtocolCache = null;
@@ -4792,7 +4945,7 @@ var init_tools = __esm({
   "src/mcp/handlers/tools.ts"() {
     "use strict";
     init_logger();
-    init_resources();
+    init_resources2();
     init_prompts2();
   }
 });
@@ -4860,7 +5013,7 @@ var init_prompts3 = __esm({
   "src/mcp/handlers/prompts.ts"() {
     "use strict";
     init_logger();
-    init_resources();
+    init_resources2();
     init_prompts2();
     init_paths();
   }
@@ -4928,8 +5081,8 @@ var init_server = __esm({
     "use strict";
     init_logger();
     init_config();
-    init_resources();
     init_resources2();
+    init_resources3();
     init_tools();
     init_prompts3();
     serverState = { running: false };
@@ -5019,8 +5172,8 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs27 = await import("fs");
-  const path26 = await import("path");
+  const fs33 = await import("fs");
+  const path32 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -5034,8 +5187,8 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs27.existsSync(resolvedPath)) {
-      fs27.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs33.existsSync(resolvedPath)) {
+      fs33.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
@@ -5043,7 +5196,7 @@ locally in each project. MCP needs a central location.`,
       `${pc5.green("\u2713")} Global path configured: ${pc5.cyan(resolvedPath)}
 
 MCP config will be stored at:
-${path26.join(resolvedPath, "mcp.yaml")}`,
+${path32.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -5140,8 +5293,8 @@ var init_Header = __esm({
 });
 
 // src/lib/drift-service.ts
-import * as fs17 from "fs";
-import * as path19 from "path";
+import * as fs23 from "fs";
+import * as path25 from "path";
 import * as crypto2 from "crypto";
 var DriftService;
 var init_drift_service = __esm({
@@ -5150,26 +5303,26 @@ var init_drift_service = __esm({
     DriftService = class {
       static CHECKSUM_FILENAME = ".rrce-checksums.json";
       static calculateHash(filePath) {
-        const content = fs17.readFileSync(filePath);
+        const content = fs23.readFileSync(filePath);
         return crypto2.createHash("md5").update(content).digest("hex");
       }
       static getManifestPath(projectPath) {
-        return path19.join(projectPath, this.CHECKSUM_FILENAME);
+        return path25.join(projectPath, this.CHECKSUM_FILENAME);
       }
       static loadManifest(projectPath) {
         const manifestPath = this.getManifestPath(projectPath);
-        if (!fs17.existsSync(manifestPath)) {
+        if (!fs23.existsSync(manifestPath)) {
           return {};
         }
         try {
-          return JSON.parse(fs17.readFileSync(manifestPath, "utf8"));
+          return JSON.parse(fs23.readFileSync(manifestPath, "utf8"));
         } catch (e) {
           return {};
         }
       }
       static saveManifest(projectPath, manifest) {
         const manifestPath = this.getManifestPath(projectPath);
-        fs17.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+        fs23.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
       }
       /**
        * Generates a manifest for the current state of files in the project
@@ -5177,9 +5330,9 @@ var init_drift_service = __esm({
       static generateManifest(projectPath, files) {
         const manifest = {};
         for (const file of files) {
-          const fullPath = path19.join(projectPath, file);
-          if (fs17.existsSync(fullPath)) {
-            const stats = fs17.statSync(fullPath);
+          const fullPath = path25.join(projectPath, file);
+          if (fs23.existsSync(fullPath)) {
+            const stats = fs23.statSync(fullPath);
             manifest[file] = {
               hash: this.calculateHash(fullPath),
               mtime: stats.mtimeMs
@@ -5195,11 +5348,11 @@ var init_drift_service = __esm({
         const manifest = this.loadManifest(projectPath);
         const modifiedFiles = [];
         for (const [relPath, entry] of Object.entries(manifest)) {
-          const fullPath = path19.join(projectPath, relPath);
-          if (!fs17.existsSync(fullPath)) {
+          const fullPath = path25.join(projectPath, relPath);
+          if (!fs23.existsSync(fullPath)) {
             continue;
           }
-          const stats = fs17.statSync(fullPath);
+          const stats = fs23.statSync(fullPath);
           if (stats.mtimeMs === entry.mtime) {
             continue;
           }
@@ -5246,15 +5399,15 @@ __export(ConfigContext_exports, {
   useConfig: () => useConfig
 });
 import { createContext, useContext, useState, useCallback, useMemo, useEffect } from "react";
-import * as fs18 from "fs";
-import * as path20 from "path";
+import * as fs24 from "fs";
+import * as path26 from "path";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function getPackageVersion() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path20.join(path20.dirname(agentCoreDir), "package.json");
-    if (fs18.existsSync(packageJsonPath)) {
-      return JSON.parse(fs18.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path26.join(path26.dirname(agentCoreDir), "package.json");
+    if (fs24.existsSync(packageJsonPath)) {
+      return JSON.parse(fs24.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -5321,16 +5474,16 @@ var init_ConfigContext = __esm({
 });
 
 // src/mcp/ui/lib/tasks-fs.ts
-import * as fs19 from "fs";
-import * as path21 from "path";
+import * as fs25 from "fs";
+import * as path27 from "path";
 function readSession(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const sessionPath = path21.join(rrceData, "tasks", taskSlug, "session.json");
-  if (!fs19.existsSync(sessionPath)) {
+  const sessionPath = path27.join(rrceData, "tasks", taskSlug, "session.json");
+  if (!fs25.existsSync(sessionPath)) {
     return null;
   }
   try {
-    const raw = fs19.readFileSync(sessionPath, "utf-8");
+    const raw = fs25.readFileSync(sessionPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5343,12 +5496,12 @@ function isSessionStale(session, thresholdMs = SESSION_STALE_THRESHOLD_MS) {
 }
 function readAgentTodos(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const todosPath = path21.join(rrceData, "tasks", taskSlug, "agent-todos.json");
-  if (!fs19.existsSync(todosPath)) {
+  const todosPath = path27.join(rrceData, "tasks", taskSlug, "agent-todos.json");
+  if (!fs25.existsSync(todosPath)) {
     return null;
   }
   try {
-    const raw = fs19.readFileSync(todosPath, "utf-8");
+    const raw = fs25.readFileSync(todosPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5361,8 +5514,8 @@ function detectStorageModeFromConfig(workspaceRoot) {
     if (configPath.startsWith(rrceHome)) {
       return "global";
     }
-    if (fs19.existsSync(configPath)) {
-      const content = fs19.readFileSync(configPath, "utf-8");
+    if (fs25.existsSync(configPath)) {
+      const content = fs25.readFileSync(configPath, "utf-8");
       if (content.includes("mode: workspace")) return "workspace";
       if (content.includes("mode: global")) return "global";
     }
@@ -5372,7 +5525,7 @@ function detectStorageModeFromConfig(workspaceRoot) {
 }
 function getEffectiveGlobalBase() {
   const dummy = resolveDataPath("global", "__rrce_dummy__", "");
-  return path21.dirname(path21.dirname(dummy));
+  return path27.dirname(path27.dirname(dummy));
 }
 function getProjectRRCEData(project) {
   const workspaceRoot = project.sourcePath || project.path;
@@ -5381,19 +5534,19 @@ function getProjectRRCEData(project) {
 }
 function listProjectTasks(project) {
   const rrceData = getProjectRRCEData(project);
-  const tasksPath = path21.join(rrceData, "tasks");
-  if (!fs19.existsSync(tasksPath)) {
+  const tasksPath = path27.join(rrceData, "tasks");
+  if (!fs25.existsSync(tasksPath)) {
     return { projectName: project.name, tasksPath, tasks: [] };
   }
   const tasks = [];
   try {
-    const entries = fs19.readdirSync(tasksPath, { withFileTypes: true });
+    const entries = fs25.readdirSync(tasksPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const metaPath = path21.join(tasksPath, entry.name, "meta.json");
-      if (!fs19.existsSync(metaPath)) continue;
+      const metaPath = path27.join(tasksPath, entry.name, "meta.json");
+      if (!fs25.existsSync(metaPath)) continue;
       try {
-        const raw = fs19.readFileSync(metaPath, "utf-8");
+        const raw = fs25.readFileSync(metaPath, "utf-8");
         const meta = JSON.parse(raw);
         if (!meta.task_slug) meta.task_slug = entry.name;
         tasks.push(meta);
@@ -5412,18 +5565,18 @@ function listProjectTasks(project) {
 }
 function updateTaskStatus(project, taskSlug, status) {
   const rrceData = getProjectRRCEData(project);
-  const metaPath = path21.join(rrceData, "tasks", taskSlug, "meta.json");
-  if (!fs19.existsSync(metaPath)) {
+  const metaPath = path27.join(rrceData, "tasks", taskSlug, "meta.json");
+  if (!fs25.existsSync(metaPath)) {
     return { ok: false, error: `meta.json not found for task '${taskSlug}'` };
   }
   try {
-    const meta = JSON.parse(fs19.readFileSync(metaPath, "utf-8"));
+    const meta = JSON.parse(fs25.readFileSync(metaPath, "utf-8"));
     const next = {
       ...meta,
       status,
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs19.writeFileSync(metaPath, JSON.stringify(next, null, 2));
+    fs25.writeFileSync(metaPath, JSON.stringify(next, null, 2));
     return { ok: true, meta: next };
   } catch (e) {
     return { ok: false, error: String(e) };
@@ -5784,28 +5937,28 @@ var init_project_utils = __esm({
 // src/mcp/ui/ProjectsView.tsx
 import { useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
 import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
-import * as fs20 from "fs";
-import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path28 from "path";
 import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 function getIndexStats(project) {
   const stats = { knowledgeCount: 0, codeCount: 0, lastIndexed: null };
   try {
     const knowledgePath = project.knowledgePath;
     if (knowledgePath) {
-      const embPath = path22.join(knowledgePath, "embeddings.json");
-      const codeEmbPath = path22.join(knowledgePath, "code-embeddings.json");
-      if (fs20.existsSync(embPath)) {
-        const stat = fs20.statSync(embPath);
+      const embPath = path28.join(knowledgePath, "embeddings.json");
+      const codeEmbPath = path28.join(knowledgePath, "code-embeddings.json");
+      if (fs26.existsSync(embPath)) {
+        const stat = fs26.statSync(embPath);
         stats.lastIndexed = stat.mtime.toISOString();
         try {
-          const data = JSON.parse(fs20.readFileSync(embPath, "utf-8"));
+          const data = JSON.parse(fs26.readFileSync(embPath, "utf-8"));
           stats.knowledgeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
       }
-      if (fs20.existsSync(codeEmbPath)) {
+      if (fs26.existsSync(codeEmbPath)) {
         try {
-          const data = JSON.parse(fs20.readFileSync(codeEmbPath, "utf-8"));
+          const data = JSON.parse(fs26.readFileSync(codeEmbPath, "utf-8"));
           stats.codeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
@@ -6506,7 +6659,7 @@ __export(App_exports, {
 });
 import { useState as useState5, useEffect as useEffect6, useMemo as useMemo5, useCallback as useCallback3 } from "react";
 import { Box as Box11, useInput as useInput5, useApp } from "ink";
-import fs21 from "fs";
+import fs27 from "fs";
 import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 var App;
 var init_App = __esm({
@@ -6579,18 +6732,18 @@ var init_App = __esm({
       useEffect6(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs21.existsSync(logPath)) {
-          const stats = fs21.statSync(logPath);
+        if (fs27.existsSync(logPath)) {
+          const stats = fs27.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs21.existsSync(logPath)) {
-            const stats = fs21.statSync(logPath);
+          if (fs27.existsSync(logPath)) {
+            const stats = fs27.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs21.openSync(logPath, "r");
-              fs21.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs21.closeSync(fd);
+              const fd = fs27.openSync(logPath, "r");
+              fs27.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs27.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -6815,15 +6968,15 @@ __export(update_flow_exports, {
 });
 import { confirm as confirm5, spinner as spinner2, note as note6, outro as outro2, cancel as cancel2, isCancel as isCancel7 } from "@clack/prompts";
 import pc8 from "picocolors";
-import * as fs22 from "fs";
-import * as path23 from "path";
+import * as fs28 from "fs";
+import * as path29 from "path";
 import { stringify as stringify2, parse } from "yaml";
 function backupFile(filePath) {
-  if (!fs22.existsSync(filePath)) return null;
+  if (!fs28.existsSync(filePath)) return null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
   const backupPath = `${filePath}.${timestamp}.bak`;
   try {
-    fs22.copyFileSync(filePath, backupPath);
+    fs28.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (e) {
     console.error(`Failed to backup ${filePath}:`, e);
@@ -6833,9 +6986,9 @@ function backupFile(filePath) {
 function getPackageVersion2() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path23.join(path23.dirname(agentCoreDir), "package.json");
-    if (fs22.existsSync(packageJsonPath)) {
-      return JSON.parse(fs22.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path29.join(path29.dirname(agentCoreDir), "package.json");
+    if (fs28.existsSync(packageJsonPath)) {
+      return JSON.parse(fs28.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -6850,9 +7003,9 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
   const configFilePath = getConfigPath(workspacePath);
   let currentSyncedVersion;
-  if (fs22.existsSync(configFilePath)) {
+  if (fs28.existsSync(configFilePath)) {
     try {
-      const content = fs22.readFileSync(configFilePath, "utf-8");
+      const content = fs28.readFileSync(configFilePath, "utf-8");
       const config = parse(content);
       currentSyncedVersion = config.last_synced_version;
     } catch (e) {
@@ -6860,8 +7013,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   }
   const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
   const ideTargets = [];
-  if (fs22.existsSync(configFilePath)) {
-    const configContent = fs22.readFileSync(configFilePath, "utf-8");
+  if (fs28.existsSync(configFilePath)) {
+    const configContent = fs28.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("opencode: true")) ideTargets.push("OpenCode agents");
     if (configContent.includes("copilot: true")) ideTargets.push("GitHub Copilot");
     if (configContent.includes("antigravity: true")) ideTargets.push("Antigravity");
@@ -6870,14 +7023,14 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     const dirs = ["templates", "prompts", "docs"];
     const updatedFiles = [];
     for (const dir of dirs) {
-      const srcDir = path23.join(agentCoreDir, dir);
-      if (!fs22.existsSync(srcDir)) continue;
+      const srcDir = path29.join(agentCoreDir, dir);
+      if (!fs28.existsSync(srcDir)) continue;
       const syncFiles = (src, rel) => {
-        const entries = fs22.readdirSync(src, { withFileTypes: true });
+        const entries = fs28.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const entrySrc = path23.join(src, entry.name);
-          const entryRel = path23.join(rel, entry.name);
-          const entryDest = path23.join(dataPath, entryRel);
+          const entrySrc = path29.join(src, entry.name);
+          const entryRel = path29.join(rel, entry.name);
+          const entryDest = path29.join(dataPath, entryRel);
           if (entry.isDirectory()) {
             ensureDir(entryDest);
             syncFiles(entrySrc, entryRel);
@@ -6885,8 +7038,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
             if (driftReport.modifiedFiles.includes(entryRel)) {
               backupFile(entryDest);
             }
-            ensureDir(path23.dirname(entryDest));
-            fs22.copyFileSync(entrySrc, entryDest);
+            ensureDir(path29.dirname(entryDest));
+            fs28.copyFileSync(entrySrc, entryDest);
             updatedFiles.push(entryRel);
           }
         }
@@ -6897,12 +7050,12 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     DriftService.saveManifest(dataPath, manifest);
   }
   const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-  ensureDir(path23.join(rrceHome, "templates"));
-  ensureDir(path23.join(rrceHome, "docs"));
-  copyDirRecursive(path23.join(agentCoreDir, "templates"), path23.join(rrceHome, "templates"));
-  copyDirRecursive(path23.join(agentCoreDir, "docs"), path23.join(rrceHome, "docs"));
-  if (fs22.existsSync(configFilePath)) {
-    const configContent = fs22.readFileSync(configFilePath, "utf-8");
+  ensureDir(path29.join(rrceHome, "templates"));
+  ensureDir(path29.join(rrceHome, "docs"));
+  copyDirRecursive(path29.join(agentCoreDir, "templates"), path29.join(rrceHome, "templates"));
+  copyDirRecursive(path29.join(agentCoreDir, "docs"), path29.join(rrceHome, "docs"));
+  if (fs28.existsSync(configFilePath)) {
+    const configContent = fs28.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -6924,21 +7077,21 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     try {
       const yaml = parse(configContent);
       yaml.last_synced_version = runningVersion;
-      fs22.writeFileSync(configFilePath, stringify2(yaml));
+      fs28.writeFileSync(configFilePath, stringify2(yaml));
     } catch (e) {
       console.error("Failed to update config.yaml version:", e);
     }
   }
-  const mcpPath = path23.join(rrceHome, "mcp.yaml");
-  if (fs22.existsSync(mcpPath)) {
+  const mcpPath = path29.join(rrceHome, "mcp.yaml");
+  if (fs28.existsSync(mcpPath)) {
     try {
-      const content = fs22.readFileSync(mcpPath, "utf-8");
+      const content = fs28.readFileSync(mcpPath, "utf-8");
       const yaml = parse(content);
       if (yaml.projects) {
         const project = yaml.projects.find((p) => p.name === workspaceName);
         if (project) {
           project.last_synced_version = runningVersion;
-          fs22.writeFileSync(mcpPath, stringify2(yaml));
+          fs28.writeFileSync(mcpPath, stringify2(yaml));
         }
       }
     } catch (e) {
@@ -6974,9 +7127,9 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     const configFilePath = getConfigPath(workspacePath);
     let currentSyncedVersion;
-    if (fs22.existsSync(configFilePath)) {
+    if (fs28.existsSync(configFilePath)) {
       try {
-        const content = fs22.readFileSync(configFilePath, "utf-8");
+        const content = fs28.readFileSync(configFilePath, "utf-8");
         const config = parse(content);
         currentSyncedVersion = config.last_synced_version;
       } catch (e) {
@@ -7000,8 +7153,8 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
       `  \u2022 docs/ (documentation)`
     ];
     const ideTargets = [];
-    if (fs22.existsSync(configFilePath)) {
-      const configContent = fs22.readFileSync(configFilePath, "utf-8");
+    if (fs28.existsSync(configFilePath)) {
+      const configContent = fs28.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("opencode: true")) ideTargets.push("OpenCode agents");
       if (configContent.includes("copilot: true")) ideTargets.push("GitHub Copilot");
       if (configContent.includes("antigravity: true")) ideTargets.push("Antigravity");
@@ -7030,14 +7183,14 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       const dirs = ["templates", "prompts", "docs"];
       const updatedFiles = [];
       for (const dir of dirs) {
-        const srcDir = path23.join(agentCoreDir, dir);
-        if (!fs22.existsSync(srcDir)) continue;
+        const srcDir = path29.join(agentCoreDir, dir);
+        if (!fs28.existsSync(srcDir)) continue;
         const syncFiles = (src, rel) => {
-          const entries = fs22.readdirSync(src, { withFileTypes: true });
+          const entries = fs28.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
-            const entrySrc = path23.join(src, entry.name);
-            const entryRel = path23.join(rel, entry.name);
-            const entryDest = path23.join(dataPath, entryRel);
+            const entrySrc = path29.join(src, entry.name);
+            const entryRel = path29.join(rel, entry.name);
+            const entryDest = path29.join(dataPath, entryRel);
             if (entry.isDirectory()) {
               ensureDir(entryDest);
               syncFiles(entrySrc, entryRel);
@@ -7045,8 +7198,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
               if (driftReport.modifiedFiles.includes(entryRel)) {
                 backupFile(entryDest);
               }
-              ensureDir(path23.dirname(entryDest));
-              fs22.copyFileSync(entrySrc, entryDest);
+              ensureDir(path29.dirname(entryDest));
+              fs28.copyFileSync(entrySrc, entryDest);
               updatedFiles.push(entryRel);
             }
           }
@@ -7057,12 +7210,12 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       DriftService.saveManifest(dataPath, manifest);
     }
     const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-    ensureDir(path23.join(rrceHome, "templates"));
-    ensureDir(path23.join(rrceHome, "docs"));
-    copyDirRecursive(path23.join(agentCoreDir, "templates"), path23.join(rrceHome, "templates"));
-    copyDirRecursive(path23.join(agentCoreDir, "docs"), path23.join(rrceHome, "docs"));
-    if (fs22.existsSync(configFilePath)) {
-      const configContent = fs22.readFileSync(configFilePath, "utf-8");
+    ensureDir(path29.join(rrceHome, "templates"));
+    ensureDir(path29.join(rrceHome, "docs"));
+    copyDirRecursive(path29.join(agentCoreDir, "templates"), path29.join(rrceHome, "templates"));
+    copyDirRecursive(path29.join(agentCoreDir, "docs"), path29.join(rrceHome, "docs"));
+    if (fs28.existsSync(configFilePath)) {
+      const configContent = fs28.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
@@ -7084,21 +7237,21 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       try {
         const yaml = parse(configContent);
         yaml.last_synced_version = runningVersion;
-        fs22.writeFileSync(configFilePath, stringify2(yaml));
+        fs28.writeFileSync(configFilePath, stringify2(yaml));
       } catch (e) {
         console.error("Failed to update config.yaml version:", e);
       }
     }
-    const mcpPath = path23.join(rrceHome, "mcp.yaml");
-    if (fs22.existsSync(mcpPath)) {
+    const mcpPath = path29.join(rrceHome, "mcp.yaml");
+    if (fs28.existsSync(mcpPath)) {
       try {
-        const content = fs22.readFileSync(mcpPath, "utf-8");
+        const content = fs28.readFileSync(mcpPath, "utf-8");
         const yaml = parse(content);
         if (yaml.projects) {
           const project = yaml.projects.find((p) => p.name === workspaceName);
           if (project) {
             project.last_synced_version = runningVersion;
-            fs22.writeFileSync(mcpPath, stringify2(yaml));
+            fs28.writeFileSync(mcpPath, stringify2(yaml));
           }
         }
       } catch (e) {
@@ -7133,8 +7286,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path23.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path23.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path29.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path29.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -7157,8 +7310,8 @@ var init_update_flow = __esm({
 // src/commands/wizard/index.ts
 import { intro as intro2, select as select5, spinner as spinner7, note as note11, outro as outro7, isCancel as isCancel12, confirm as confirm10 } from "@clack/prompts";
 import pc13 from "picocolors";
-import * as fs26 from "fs";
-import * as path25 from "path";
+import * as fs32 from "fs";
+import * as path31 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/lib/git.ts
@@ -7835,7 +7988,7 @@ async function handlePostSetup(config, workspacePath, workspaceName, linkedProje
 init_paths();
 import { multiselect as multiselect4, spinner as spinner4, note as note8, outro as outro4, cancel as cancel4, isCancel as isCancel9, confirm as confirm7 } from "@clack/prompts";
 import pc10 from "picocolors";
-import * as fs23 from "fs";
+import * as fs29 from "fs";
 init_detection();
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
@@ -7874,7 +8027,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs23.readFileSync(configFilePath, "utf-8");
+  let configContent = fs29.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -7901,7 +8054,7 @@ linked_projects:
 `;
     });
   }
-  fs23.writeFileSync(configFilePath, configContent);
+  fs29.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -7937,15 +8090,15 @@ init_paths();
 init_utils();
 import { confirm as confirm8, spinner as spinner5, note as note9, outro as outro5, cancel as cancel5, isCancel as isCancel10 } from "@clack/prompts";
 import pc11 from "picocolors";
-import * as fs24 from "fs";
-import * as path24 from "path";
+import * as fs30 from "fs";
+import * as path30 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path24.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path30.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs24.existsSync(path24.join(localPath, dir))
+    (dir) => fs30.existsSync(path30.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro5(pc11.yellow("No data found in workspace storage to sync."));
@@ -7971,8 +8124,8 @@ Destination: ${pc11.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path24.join(localPath, dir);
-      const destDir = path24.join(globalPath, dir);
+      const srcDir = path30.join(localPath, dir);
+      const destDir = path30.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -8000,7 +8153,7 @@ init_update_flow();
 // src/commands/wizard/delete-flow.ts
 import { multiselect as multiselect5, confirm as confirm9, spinner as spinner6, note as note10, cancel as cancel6, isCancel as isCancel11 } from "@clack/prompts";
 import pc12 from "picocolors";
-import * as fs25 from "fs";
+import * as fs31 from "fs";
 init_detection();
 init_config();
 async function runDeleteGlobalProjectFlow(availableProjects) {
@@ -8044,8 +8197,8 @@ Are you sure?`,
     for (const projectName of projectsToDelete) {
       const project = globalProjects.find((p) => p.name === projectName);
       if (!project) continue;
-      if (fs25.existsSync(project.dataPath)) {
-        fs25.rmSync(project.dataPath, { recursive: true, force: true });
+      if (fs31.existsSync(project.dataPath)) {
+        fs31.rmSync(project.dataPath, { recursive: true, force: true });
       }
       const newConfig = removeProjectConfig(mcpConfig, projectName);
       configChanged = true;
@@ -8067,9 +8220,9 @@ init_config();
 function getPackageVersion3() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path25.join(path25.dirname(agentCoreDir), "package.json");
-    if (fs26.existsSync(packageJsonPath)) {
-      return JSON.parse(fs26.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path31.join(path31.dirname(agentCoreDir), "package.json");
+    if (fs32.existsSync(packageJsonPath)) {
+      return JSON.parse(fs32.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -8077,9 +8230,9 @@ function getPackageVersion3() {
 }
 function getLastSyncedVersion(workspacePath, workspaceName) {
   const configFilePath = getConfigPath(workspacePath);
-  if (fs26.existsSync(configFilePath)) {
+  if (fs32.existsSync(configFilePath)) {
     try {
-      const content = fs26.readFileSync(configFilePath, "utf-8");
+      const content = fs32.readFileSync(configFilePath, "utf-8");
       const config = parse2(content);
       if (config.last_synced_version) {
         return config.last_synced_version;
@@ -8088,10 +8241,10 @@ function getLastSyncedVersion(workspacePath, workspaceName) {
     }
   }
   const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
-  const mcpPath = path25.join(rrceHome, "mcp.yaml");
-  if (fs26.existsSync(mcpPath)) {
+  const mcpPath = path31.join(rrceHome, "mcp.yaml");
+  if (fs32.existsSync(mcpPath)) {
     try {
-      const content = fs26.readFileSync(mcpPath, "utf-8");
+      const content = fs32.readFileSync(mcpPath, "utf-8");
       const config = parse2(content);
       const project = config.projects?.find((p) => p.name === workspaceName);
       if (project?.last_synced_version) {
@@ -8161,11 +8314,11 @@ Workspace: ${pc13.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  let isAlreadyConfigured = fs26.existsSync(configFilePath);
+  let isAlreadyConfigured = fs32.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs26.readFileSync(configFilePath, "utf-8");
+      const configContent = fs32.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
@@ -8182,7 +8335,7 @@ Workspace: ${pc13.bold(workspaceName)}`,
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs26.existsSync(localDataPath);
+  const hasLocalData = fs32.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const continueToMenu = await checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode);
     if (!continueToMenu) {