rrce-workflow 0.3.20 → 0.3.23

package/dist/index.js

@@ -1028,19 +1028,60 @@ var init_install = __esm({
   }
 });
 
-// src/commands/wizard/utils.ts
+// src/commands/wizard/fs-utils.ts
 import * as fs7 from "fs";
 import * as path8 from "path";
+function copyDirRecursive(src, dest) {
+  const entries = fs7.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path8.join(src, entry.name);
+    const destPath = path8.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      ensureDir(destPath);
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs7.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function clearDirectory(dirPath) {
+  if (!fs7.existsSync(dirPath)) return;
+  const entries = fs7.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      fs7.unlinkSync(path8.join(dirPath, entry.name));
+    }
+  }
+}
+function copyPromptsToDir(prompts, targetDir, extension) {
+  for (const prompt of prompts) {
+    const baseName = path8.basename(prompt.filePath, ".md");
+    const targetName = baseName + extension;
+    const targetPath = path8.join(targetDir, targetName);
+    const content = fs7.readFileSync(prompt.filePath, "utf-8");
+    fs7.writeFileSync(targetPath, content);
+  }
+}
+var init_fs_utils = __esm({
+  "src/commands/wizard/fs-utils.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/commands/wizard/opencode-service.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
 import * as os2 from "os";
 import { stringify } from "yaml";
 function getOpenCodeConfigPath() {
-  return path8.join(os2.homedir(), ".config", "opencode", "opencode.json");
+  return path9.join(os2.homedir(), ".config", "opencode", "opencode.json");
 }
 function getOpenCodeCommandDir(mode, dataPath) {
   if (mode === "global") {
-    return path8.join(os2.homedir(), ".config", "opencode", "command");
+    return path9.join(os2.homedir(), ".config", "opencode", "command");
   }
-  return path8.join(dataPath, ".opencode", "command");
+  return path9.join(dataPath, ".opencode", "command");
 }
 function mapPromptToCommandName(baseName) {
   const mapping = {
@@ -1054,9 +1095,9 @@ function mapPromptToCommandName(baseName) {
   return mapping[baseName] || baseName;
 }
 function loadBaseProtocol() {
-  const basePath = path8.join(getAgentCorePromptsDir(), "_base.md");
-  if (fs7.existsSync(basePath)) {
-    return fs7.readFileSync(basePath, "utf-8");
+  const basePath = path9.join(getAgentCorePromptsDir(), "_base.md");
+  if (fs8.existsSync(basePath)) {
+    return fs8.readFileSync(basePath, "utf-8");
   }
   return "";
 }
@@ -1073,18 +1114,18 @@ function buildCommandFrontmatter(prompt, baseName) {
 function generateOpenCodeCommands(prompts, mode, dataPath) {
   const commandDir = getOpenCodeCommandDir(mode, dataPath);
   ensureDir(commandDir);
-  if (fs7.existsSync(commandDir)) {
-    const entries = fs7.readdirSync(commandDir, { withFileTypes: true });
+  if (fs8.existsSync(commandDir)) {
+    const entries = fs8.readdirSync(commandDir, { withFileTypes: true });
     for (const entry of entries) {
       const fileName = entry.name;
       if (entry.isFile() && fileName.startsWith("rrce_") && fileName.endsWith(".md")) {
-        fs7.unlinkSync(path8.join(commandDir, fileName));
+        fs8.unlinkSync(path9.join(commandDir, fileName));
       }
     }
   }
   const baseProtocol = loadBaseProtocol();
   for (const prompt of prompts) {
-    const baseName = path8.basename(prompt.filePath, ".md");
+    const baseName = path9.basename(prompt.filePath, ".md");
     if (baseName === "orchestrator") continue;
     if (baseName.startsWith("_")) continue;
     const commandName = mapPromptToCommandName(baseName);
@@ -1095,52 +1136,16 @@ ${prompt.content}` : prompt.content;
     const content = `---
 ${stringify(frontmatter)}---
 ${fullContent}`;
-    fs7.writeFileSync(path8.join(commandDir, commandFile), content);
-  }
-}
-function enableProviderCaching() {
-  const opencodePath = getOpenCodeConfigPath();
-  let config = {};
-  if (fs7.existsSync(opencodePath)) {
-    try {
-      config = JSON.parse(fs7.readFileSync(opencodePath, "utf8"));
-    } catch (e) {
-      console.error("Warning: Could not parse existing OpenCode config, creating new provider section");
-    }
-  } else {
-    ensureDir(path8.dirname(opencodePath));
-  }
-  if (!config.provider) {
-    config.provider = {};
-  }
-  const providers = ["anthropic", "openai", "openrouter", "google"];
-  for (const provider of providers) {
-    if (!config.provider[provider]) {
-      config.provider[provider] = {};
-    }
-    if (!config.provider[provider].options) {
-      config.provider[provider].options = {};
-    }
-    config.provider[provider].options.setCacheKey = true;
-  }
-  fs7.writeFileSync(opencodePath, JSON.stringify(config, null, 2));
-}
-function copyPromptsToDir(prompts, targetDir, extension) {
-  for (const prompt of prompts) {
-    const baseName = path8.basename(prompt.filePath, ".md");
-    const targetName = baseName + extension;
-    const targetPath = path8.join(targetDir, targetName);
-    const content = fs7.readFileSync(prompt.filePath, "utf-8");
-    fs7.writeFileSync(targetPath, content);
+    fs8.writeFileSync(path9.join(commandDir, commandFile), content);
   }
 }
 function updateOpenCodeConfig(newAgents) {
   const opencodePath = getOpenCodeConfigPath();
-  if (!fs7.existsSync(opencodePath)) {
+  if (!fs8.existsSync(opencodePath)) {
     return;
   }
   try {
-    const config = JSON.parse(fs7.readFileSync(opencodePath, "utf8"));
+    const config = JSON.parse(fs8.readFileSync(opencodePath, "utf8"));
     const agentConfig = config.agent ?? config.agents ?? {};
     const existingAgentKeys = Object.keys(agentConfig);
     const rrceKeys = existingAgentKeys.filter((key) => key.startsWith("rrce_"));
@@ -1156,7 +1161,7 @@ function updateOpenCodeConfig(newAgents) {
     }
     config.agent = agentConfig;
     if (config.agents) delete config.agents;
-    fs7.writeFileSync(opencodePath, JSON.stringify(config, null, 2));
+    fs8.writeFileSync(opencodePath, JSON.stringify(config, null, 2));
   } catch (e) {
     console.error("Failed to update OpenCode config:", e);
   }
@@ -1164,7 +1169,6 @@ function updateOpenCodeConfig(newAgents) {
 function convertToOpenCodeAgent(prompt, useFileReference = false, promptFilePath) {
   const { frontmatter, content } = prompt;
   const tools = {};
-  const hostTools = ["read", "write", "edit", "bash", "grep", "glob", "webfetch", "terminalLastCommand", "task"];
   if (frontmatter.tools) {
     for (const tool of frontmatter.tools) {
       tools[tool] = true;
@@ -1180,48 +1184,26 @@ function convertToOpenCodeAgent(prompt, useFileReference = false, promptFilePath
     tools
   };
 }
-function copyDirRecursive(src, dest) {
-  const entries = fs7.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path8.join(src, entry.name);
-    const destPath = path8.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs7.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-function clearDirectory(dirPath) {
-  if (!fs7.existsSync(dirPath)) return;
-  const entries = fs7.readdirSync(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isFile()) {
-      fs7.unlinkSync(path8.join(dirPath, entry.name));
-    }
-  }
-}
 function surgicalUpdateOpenCodeAgents(prompts, mode, dataPath) {
   const agentPrompts = prompts.filter((p) => {
-    const baseName = path8.basename(p.filePath, ".md");
+    const baseName = path9.basename(p.filePath, ".md");
     return baseName === "orchestrator" || baseName === "develop";
   });
   if (mode === "global") {
     try {
-      const openCodeConfig = getOpenCodeConfigPath();
-      const promptsDir = path8.join(path8.dirname(openCodeConfig), "prompts");
+      const openCodeConfigPath = getOpenCodeConfigPath();
+      const promptsDir = path9.join(path9.dirname(openCodeConfigPath), "prompts");
       ensureDir(promptsDir);
       const baseProtocol = loadBaseProtocol();
       const newAgents = {};
       for (const prompt of agentPrompts) {
-        const baseName = path8.basename(prompt.filePath, ".md");
+        const baseName = path9.basename(prompt.filePath, ".md");
         const agentId = `rrce_${baseName}`;
         const promptFileName = `rrce-${baseName}.md`;
-        const promptFilePath = path8.join(promptsDir, promptFileName);
+        const promptFilePath = path9.join(promptsDir, promptFileName);
         const fullContent = baseProtocol ? `${baseProtocol}
 ${prompt.content}` : prompt.content;
-        fs7.writeFileSync(promptFilePath, fullContent);
+        fs8.writeFileSync(promptFilePath, fullContent);
         const agentConfig = convertToOpenCodeAgent(prompt, true, `./prompts/${promptFileName}`);
         if (baseName === "develop") {
           agentConfig.description = "Develop planned tasks - use /rrce_develop (in-context) or @rrce_develop (isolated)";
@@ -1229,24 +1211,22 @@ ${prompt.content}` : prompt.content;
         newAgents[agentId] = agentConfig;
       }
       updateOpenCodeConfig(newAgents);
-      if (fs7.existsSync(openCodeConfig)) {
-        const config = JSON.parse(fs7.readFileSync(openCodeConfig, "utf8"));
+      if (fs8.existsSync(openCodeConfigPath)) {
+        const config = JSON.parse(fs8.readFileSync(openCodeConfigPath, "utf8"));
         if (!config.agent) config.agent = {};
-        if (!config.agent.plan) config.agent.plan = {};
-        config.agent.plan.disable = true;
-        fs7.writeFileSync(openCodeConfig, JSON.stringify(config, null, 2));
+        fs8.writeFileSync(openCodeConfigPath, JSON.stringify(config, null, 2));
       }
     } catch (e) {
       console.error("Failed to update global OpenCode config with agents:", e);
       throw e;
     }
   } else {
-    const opencodeBaseDir = path8.join(dataPath, ".opencode", "agent");
+    const opencodeBaseDir = path9.join(dataPath, ".opencode", "agent");
     ensureDir(opencodeBaseDir);
     clearDirectory(opencodeBaseDir);
     const baseProtocol = loadBaseProtocol();
     for (const prompt of agentPrompts) {
-      const baseName = path8.basename(prompt.filePath, ".md");
+      const baseName = path9.basename(prompt.filePath, ".md");
       const agentId = `rrce_${baseName}`;
       const agentConfig = convertToOpenCodeAgent(prompt);
       if (baseName === "develop") {
@@ -1261,16 +1241,53 @@ ${stringify({
         tools: agentConfig.tools
       })}---
 ${fullContent}`;
-      fs7.writeFileSync(path8.join(opencodeBaseDir, `${agentId}.md`), content);
+      fs8.writeFileSync(path9.join(opencodeBaseDir, `${agentId}.md`), content);
     }
   }
   generateOpenCodeCommands(prompts, mode, dataPath);
 }
-var init_utils = __esm({
-  "src/commands/wizard/utils.ts"() {
+function enableProviderCaching() {
+  const opencodePath = getOpenCodeConfigPath();
+  let config = {};
+  if (fs8.existsSync(opencodePath)) {
+    try {
+      config = JSON.parse(fs8.readFileSync(opencodePath, "utf8"));
+    } catch (e) {
+      console.error("Warning: Could not parse existing OpenCode config, creating new provider section");
+    }
+  } else {
+    ensureDir(path9.dirname(opencodePath));
+  }
+  if (!config.provider) {
+    config.provider = {};
+  }
+  const providers = ["anthropic", "openai", "openrouter", "google"];
+  for (const provider of providers) {
+    if (!config.provider[provider]) {
+      config.provider[provider] = {};
+    }
+    if (!config.provider[provider].options) {
+      config.provider[provider].options = {};
+    }
+    config.provider[provider].options.setCacheKey = true;
+  }
+  fs8.writeFileSync(opencodePath, JSON.stringify(config, null, 2));
+}
+var init_opencode_service = __esm({
+  "src/commands/wizard/opencode-service.ts"() {
     "use strict";
     init_paths();
     init_prompts();
+    init_fs_utils();
+  }
+});
+
+// src/commands/wizard/utils.ts
+var init_utils = __esm({
+  "src/commands/wizard/utils.ts"() {
+    "use strict";
+    init_fs_utils();
+    init_opencode_service();
   }
 });
 
@@ -1303,14 +1320,14 @@ var init_types = __esm({
 });
 
 // src/mcp/config-utils.ts
-import * as path10 from "path";
+import * as path11 from "path";
 function normalizeProjectPath(projectPath) {
   let normalized = projectPath;
   while (normalized.length > 1 && (normalized.endsWith("/") || normalized.endsWith("\\"))) {
     normalized = normalized.slice(0, -1);
   }
   if (normalized.endsWith(".rrce-workflow")) {
-    return path10.dirname(normalized);
+    return path11.dirname(normalized);
   }
   return normalized;
 }
@@ -1349,8 +1366,8 @@ __export(config_exports, {
   saveMCPConfig: () => saveMCPConfig,
   setProjectConfig: () => setProjectConfig
 });
-import * as fs9 from "fs";
-import * as path11 from "path";
+import * as fs10 from "fs";
+import * as path12 from "path";
 import YAML from "yaml";
 function migrateConfig(config) {
   let changed = false;
@@ -1369,15 +1386,15 @@ function migrateConfig(config) {
 function getMCPConfigPath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path11.join(rrceHome, "mcp.yaml");
+  return path12.join(rrceHome, "mcp.yaml");
 }
 function loadMCPConfig() {
   const configPath = getMCPConfigPath();
-  if (!fs9.existsSync(configPath)) {
+  if (!fs10.existsSync(configPath)) {
     return { ...DEFAULT_MCP_CONFIG };
   }
   try {
-    const content = fs9.readFileSync(configPath, "utf-8");
+    const content = fs10.readFileSync(configPath, "utf-8");
     let config = parseMCPConfig(content);
     config = migrateConfig(config);
     return config;
@@ -1389,9 +1406,9 @@ function ensureMCPGlobalPath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
   if (rrceHome.startsWith(".") || rrceHome.includes(".rrce-workflow/")) {
-    const configPath = path11.join(workspaceRoot, ".rrce-workflow", "config.yaml");
-    if (fs9.existsSync(configPath)) {
-      const content = fs9.readFileSync(configPath, "utf-8");
+    const configPath = path12.join(workspaceRoot, ".rrce-workflow", "config.yaml");
+    if (fs10.existsSync(configPath)) {
+      const content = fs10.readFileSync(configPath, "utf-8");
       const modeMatch = content.match(/mode:\s*(global|workspace)/);
       if (modeMatch?.[1] === "workspace") {
         return {
@@ -1409,12 +1426,12 @@ function ensureMCPGlobalPath() {
 }
 function saveMCPConfig(config) {
   const configPath = getMCPConfigPath();
-  const dir = path11.dirname(configPath);
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, { recursive: true });
+  const dir = path12.dirname(configPath);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
   const content = serializeMCPConfig(config);
-  fs9.writeFileSync(configPath, content);
+  fs10.writeFileSync(configPath, content);
 }
 function parseMCPConfig(content) {
   try {
@@ -1503,16 +1520,16 @@ function getProjectPermissions(config, name, projectPath) {
 }
 function cleanStaleProjects(config) {
   const rrceHome = getEffectiveGlobalPath();
-  const globalWorkspacesDir = path11.join(rrceHome, "workspaces");
+  const globalWorkspacesDir = path12.join(rrceHome, "workspaces");
   const validProjects = [];
   const removed = [];
   for (const project of config.projects) {
     let exists = false;
     if (project.path) {
-      exists = fs9.existsSync(project.path);
+      exists = fs10.existsSync(project.path);
     } else {
-      const globalPath = path11.join(globalWorkspacesDir, project.name);
-      exists = fs9.existsSync(globalPath);
+      const globalPath = path12.join(globalWorkspacesDir, project.name);
+      exists = fs10.existsSync(globalPath);
     }
     if (exists) {
       validProjects.push(project);
@@ -1539,10 +1556,10 @@ var gitignore_exports = {};
 __export(gitignore_exports, {
   updateGitignore: () => updateGitignore
 });
-import * as fs11 from "fs";
-import * as path13 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path13.join(workspacePath, ".gitignore");
+  const gitignorePath = path14.join(workspacePath, ".gitignore");
   const entries = [];
   if (storageMode === "workspace") {
     entries.push(".rrce-workflow/");
@@ -1561,8 +1578,8 @@ function updateGitignore(workspacePath, storageMode, tools) {
     return false;
   }
   let existingContent = "";
-  if (fs11.existsSync(gitignorePath)) {
-    existingContent = fs11.readFileSync(gitignorePath, "utf-8");
+  if (fs12.existsSync(gitignorePath)) {
+    existingContent = fs12.readFileSync(gitignorePath, "utf-8");
   }
   const sectionMarker = "# RRCE-Workflow Generated";
   if (existingContent.includes(sectionMarker)) {
@@ -1573,7 +1590,7 @@ ${sectionMarker}
 ${entries.join("\n")}
 `;
   const updatedContent = existingContent.trimEnd() + newSection;
-  fs11.writeFileSync(gitignorePath, updatedContent);
+  fs12.writeFileSync(gitignorePath, updatedContent);
   return true;
 }
 var init_gitignore = __esm({
@@ -1583,12 +1600,12 @@ var init_gitignore = __esm({
 });
 
 // src/mcp/logger.ts
-import * as fs12 from "fs";
-import * as path14 from "path";
+import * as fs13 from "fs";
+import * as path15 from "path";
 function getLogFilePath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path14.join(rrceHome, "mcp-server.log");
+  return path15.join(rrceHome, "mcp-server.log");
 }
 var Logger, logger;
 var init_logger = __esm({
@@ -1619,11 +1636,11 @@ ${JSON.stringify(data, null, 2)}`;
         }
         logMessage += "\n";
         try {
-          const dir = path14.dirname(this.logPath);
-          if (!fs12.existsSync(dir)) {
-            fs12.mkdirSync(dir, { recursive: true });
+          const dir = path15.dirname(this.logPath);
+          if (!fs13.existsSync(dir)) {
+            fs13.mkdirSync(dir, { recursive: true });
           }
-          fs12.appendFileSync(this.logPath, logMessage);
+          fs13.appendFileSync(this.logPath, logMessage);
         } catch (e) {
           console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
           console.error(logMessage);
@@ -1739,18 +1756,18 @@ var init_constants = __esm({
 });
 
 // src/mcp/resources/utils.ts
-import * as fs13 from "fs";
-import * as path15 from "path";
+import * as fs14 from "fs";
+import * as path16 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 gitignorePath = path16.join(scanRoot, ".gitignore");
+  const ig = fs14.existsSync(gitignorePath) ? ignore().add(fs14.readFileSync(gitignorePath, "utf-8")) : null;
   const toPosixRelativePath = (absolutePath) => {
-    const rel = path15.relative(scanRoot, absolutePath);
-    return rel.split(path15.sep).join("/");
+    const rel = path16.relative(scanRoot, absolutePath);
+    return rel.split(path16.sep).join("/");
   };
   const isUnderGitDir = (absolutePath) => {
     const rel = toPosixRelativePath(absolutePath);
@@ -1762,7 +1779,7 @@ function getScanContext(project, scanRoot) {
     return ig.ignores(isDir ? `${rel}/` : rel);
   };
   const shouldSkipEntryDir = (absolutePath) => {
-    const dirName = path15.basename(absolutePath);
+    const dirName = path16.basename(absolutePath);
     if (dirName === ".git") return true;
     if (SKIP_DIRS.includes(dirName)) return true;
     if (isIgnoredByGitignore(absolutePath, true)) return true;
@@ -1783,7 +1800,7 @@ var init_utils2 = __esm({
 });
 
 // src/mcp/resources/paths.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 function resolveProjectPaths(project, pathInput) {
   const config = loadMCPConfig();
   let workspaceRoot = pathInput;
@@ -1811,8 +1828,8 @@ function resolveProjectPaths(project, pathInput) {
       mode = "global";
     } else {
       mode = "workspace";
-      if (fs14.existsSync(configFilePath)) {
-        const content = fs14.readFileSync(configFilePath, "utf-8");
+      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";
       }
@@ -1840,8 +1857,8 @@ var init_paths2 = __esm({
 });
 
 // src/mcp/resources/projects.ts
-import * as fs15 from "fs";
-import * as path16 from "path";
+import * as fs16 from "fs";
+import * as path17 from "path";
 function getExposedProjects() {
   const config = loadMCPConfig();
   const knownProjects = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
@@ -1850,10 +1867,10 @@ function getExposedProjects() {
   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 (fs16.existsSync(path17.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
+      cfgContent = fs16.readFileSync(path17.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
+    } else if (fs16.existsSync(path17.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
+      cfgContent = fs16.readFileSync(path17.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
     }
     if (cfgContent) {
       if (cfgContent.includes("linked_projects:")) {
@@ -1911,15 +1928,15 @@ function getProjectContext(projectName) {
   if (!project.knowledgePath) {
     return null;
   }
-  const contextPath = path16.join(project.knowledgePath, "project-context.md");
-  if (!fs15.existsSync(contextPath)) {
+  const contextPath = path17.join(project.knowledgePath, "project-context.md");
+  if (!fs16.existsSync(contextPath)) {
     return null;
   }
-  return fs15.readFileSync(contextPath, "utf-8");
+  return fs16.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");
+  return path17.join(project.knowledgePath || path17.join(scanRoot, ".rrce-workflow", "knowledge"), "code-embeddings.json");
 }
 var init_projects = __esm({
   "src/mcp/resources/projects.ts"() {
@@ -1932,8 +1949,8 @@ var init_projects = __esm({
 });
 
 // src/mcp/resources/tasks.ts
-import * as fs16 from "fs";
-import * as path17 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 import * as os3 from "os";
 import * as crypto from "crypto";
 function getProjectTasks(projectName) {
@@ -1947,18 +1964,18 @@ function getProjectTasks(projectName) {
   if (!permissions.tasks) {
     return [];
   }
-  if (!project.tasksPath || !fs16.existsSync(project.tasksPath)) {
+  if (!project.tasksPath || !fs17.existsSync(project.tasksPath)) {
     return [];
   }
   const tasks = [];
   try {
-    const taskDirs = fs16.readdirSync(project.tasksPath, { withFileTypes: true });
+    const taskDirs = fs17.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)) {
+      const metaPath = path18.join(project.tasksPath, dir.name, "meta.json");
+      if (fs17.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs16.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs17.readFileSync(metaPath, "utf-8"));
           tasks.push(meta);
         } catch (err) {
           logger.error(`[getProjectTasks] Failed to parse meta.json in ${dir.name}`, err);
@@ -1975,10 +1992,10 @@ function getTask(projectName, taskSlug) {
   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;
+  const metaPath = path18.join(project.tasksPath, taskSlug, "meta.json");
+  if (!fs17.existsSync(metaPath)) return null;
   try {
-    return JSON.parse(fs16.readFileSync(metaPath, "utf-8"));
+    return JSON.parse(fs17.readFileSync(metaPath, "utf-8"));
   } catch (err) {
     logger.error(`[getTask] Failed to parse meta.json for task ${taskSlug}`, err);
     return null;
@@ -1991,26 +2008,26 @@ async function createTask(projectName, taskSlug, taskData) {
   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)) {
+  const taskDir = path18.join(project.tasksPath, taskSlug);
+  if (fs17.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");
+  fs17.mkdirSync(taskDir, { recursive: true });
+  fs17.mkdirSync(path18.join(taskDir, "research"), { recursive: true });
+  fs17.mkdirSync(path18.join(taskDir, "planning"), { recursive: true });
+  fs17.mkdirSync(path18.join(taskDir, "execution"), { recursive: true });
+  fs17.mkdirSync(path18.join(taskDir, "docs"), { recursive: true });
+  const rrceHome = process.env.RRCE_HOME || path18.join(os3.homedir(), ".rrce-workflow");
+  const templatePath = path18.join(rrceHome, "templates", "meta.template.json");
   let meta = {
     task_id: crypto.randomUUID(),
     task_slug: taskSlug,
     status: "draft",
     agents: {}
   };
-  if (fs16.existsSync(templatePath)) {
+  if (fs17.existsSync(templatePath)) {
     try {
-      const template = JSON.parse(fs16.readFileSync(templatePath, "utf-8"));
+      const template = JSON.parse(fs17.readFileSync(templatePath, "utf-8"));
       meta = { ...template, ...meta };
     } catch (e) {
       logger.error("Failed to load meta template", e);
@@ -2024,8 +2041,8 @@ async function createTask(projectName, taskSlug, taskData) {
     hash: project.name
   };
   Object.assign(meta, taskData);
-  const metaPath = path17.join(taskDir, "meta.json");
-  fs16.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+  const metaPath = path18.join(taskDir, "meta.json");
+  fs17.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
   return meta;
 }
 async function updateTask(projectName, taskSlug, taskData) {
@@ -2044,8 +2061,8 @@ async function updateTask(projectName, taskSlug, taskData) {
   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));
+  const metaPath = path18.join(project.tasksPath, taskSlug, "meta.json");
+  fs17.writeFileSync(metaPath, JSON.stringify(updatedMeta, null, 2));
   return updatedMeta;
 }
 function deleteTask(projectName, taskSlug) {
@@ -2053,12 +2070,12 @@ function deleteTask(projectName, taskSlug) {
   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 });
+  const taskDir = path18.join(project.tasksPath, taskSlug);
+  if (!fs17.existsSync(taskDir)) return false;
+  if (fs17.rmSync) {
+    fs17.rmSync(taskDir, { recursive: true, force: true });
   } else {
-    fs16.rmdirSync(taskDir, { recursive: true });
+    fs17.rmdirSync(taskDir, { recursive: true });
   }
   return true;
 }
@@ -2072,8 +2089,8 @@ var init_tasks = __esm({
 });
 
 // src/mcp/services/rag.ts
-import * as fs17 from "fs";
-import * as path18 from "path";
+import * as fs18 from "fs";
+import * as path19 from "path";
 var INDEX_VERSION, DEFAULT_MODEL, RAGService;
 var init_rag = __esm({
   "src/mcp/services/rag.ts"() {
@@ -2127,9 +2144,9 @@ var init_rag = __esm({
        */
       loadIndex() {
         if (this.index) return;
-        if (fs17.existsSync(this.indexPath)) {
+        if (fs18.existsSync(this.indexPath)) {
           try {
-            const data = fs17.readFileSync(this.indexPath, "utf-8");
+            const data = fs18.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) {
@@ -2155,11 +2172,11 @@ var init_rag = __esm({
       saveIndex() {
         if (!this.index) return;
         try {
-          const dir = path18.dirname(this.indexPath);
-          if (!fs17.existsSync(dir)) {
-            fs17.mkdirSync(dir, { recursive: true });
+          const dir = path19.dirname(this.indexPath);
+          if (!fs18.existsSync(dir)) {
+            fs18.mkdirSync(dir, { recursive: true });
           }
-          fs17.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+          fs18.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);
@@ -2170,13 +2187,13 @@ var init_rag = __esm({
        */
       saveIndexAtomic() {
         if (!this.index) return;
-        const dir = path18.dirname(this.indexPath);
-        if (!fs17.existsSync(dir)) {
-          fs17.mkdirSync(dir, { recursive: true });
+        const dir = path19.dirname(this.indexPath);
+        if (!fs18.existsSync(dir)) {
+          fs18.mkdirSync(dir, { recursive: true });
         }
         const tmpPath = `${this.indexPath}.tmp`;
-        fs17.writeFileSync(tmpPath, JSON.stringify(this.index, null, 2));
-        fs17.renameSync(tmpPath, this.indexPath);
+        fs18.writeFileSync(tmpPath, JSON.stringify(this.index, null, 2));
+        fs18.renameSync(tmpPath, this.indexPath);
       }
       /**
        * Save index only if enough time passed since last save
@@ -2709,10 +2726,10 @@ var init_context_extractor = __esm({
 });
 
 // src/mcp/services/dependency-graph.ts
-import * as fs18 from "fs";
-import * as path19 from "path";
+import * as fs19 from "fs";
+import * as path20 from "path";
 function parseImports(filePath, content) {
-  const ext = path19.extname(filePath).toLowerCase();
+  const ext = path20.extname(filePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   const edges = [];
   const patterns = IMPORT_PATTERNS[language] || IMPORT_PATTERNS.javascript || [];
@@ -2742,20 +2759,20 @@ function parseImports(filePath, content) {
   return edges;
 }
 function resolveImport(fromFile, importPath, language) {
-  const fromDir = path19.dirname(fromFile);
+  const fromDir = path20.dirname(fromFile);
   if (importPath.startsWith(".")) {
-    const candidates = generateCandidates(path19.resolve(fromDir, importPath), language);
+    const candidates = generateCandidates(path20.resolve(fromDir, importPath), language);
     for (const candidate of candidates) {
-      if (fs18.existsSync(candidate)) {
+      if (fs19.existsSync(candidate)) {
         return { path: candidate, isResolved: true };
       }
     }
-    return { path: path19.resolve(fromDir, importPath), isResolved: false };
+    return { path: path20.resolve(fromDir, importPath), isResolved: false };
   }
   if (importPath.startsWith("/")) {
     const candidates = generateCandidates(importPath, language);
     for (const candidate of candidates) {
-      if (fs18.existsSync(candidate)) {
+      if (fs19.existsSync(candidate)) {
         return { path: candidate, isResolved: true };
       }
     }
@@ -2765,7 +2782,7 @@ function resolveImport(fromFile, importPath, language) {
 }
 function generateCandidates(basePath, language) {
   const candidates = [];
-  if (path19.extname(basePath)) {
+  if (path20.extname(basePath)) {
     candidates.push(basePath);
   }
   switch (language) {
@@ -2880,18 +2897,18 @@ async function scanProjectDependencies(projectRoot, options = {}) {
   const files = [];
   function scanDir(dir) {
     try {
-      const entries = fs18.readdirSync(dir, { withFileTypes: true });
+      const entries = fs19.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path19.join(dir, entry.name);
+        const fullPath = path20.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (!skipDirs.includes(entry.name) && !entry.name.startsWith(".")) {
             scanDir(fullPath);
           }
         } else if (entry.isFile()) {
-          const ext = path19.extname(entry.name).toLowerCase();
+          const ext = path20.extname(entry.name).toLowerCase();
           if (extensions.includes(ext)) {
             try {
-              const content = fs18.readFileSync(fullPath, "utf-8");
+              const content = fs19.readFileSync(fullPath, "utf-8");
               files.push({ path: fullPath, content });
             } catch {
             }
@@ -3188,9 +3205,53 @@ var init_symbol_extractor = __esm({
   }
 });
 
+// src/mcp/resources/search-utils.ts
+function getSearchAdvisory(projectName) {
+  const indexingInProgress = indexingJobs.isRunning(projectName);
+  const advisoryMessage = indexingInProgress ? "Indexing in progress; results may be stale/incomplete." : void 0;
+  return { indexingInProgress, advisoryMessage };
+}
+function getIndexFreshness(projectName) {
+  const progress = indexingJobs.getProgress(projectName);
+  if (progress.completedAt) {
+    return {
+      lastIndexedAt: new Date(progress.completedAt).toISOString(),
+      indexAgeSeconds: Math.floor((Date.now() - progress.completedAt) / 1e3)
+    };
+  }
+  return {};
+}
+function applyTokenBudget(results, maxTokens, getContent) {
+  let truncated = false;
+  let tokenCount = 0;
+  if (maxTokens !== void 0 && maxTokens > 0) {
+    const budgeted = [];
+    for (const result of results) {
+      const resultTokens = estimateTokens(getContent(result));
+      if (tokenCount + resultTokens > maxTokens) {
+        truncated = true;
+        break;
+      }
+      budgeted.push(result);
+      tokenCount += resultTokens;
+    }
+    return { budgetedResults: budgeted, truncated, tokenCount };
+  } else {
+    tokenCount = results.reduce((sum, r) => sum + estimateTokens(getContent(r)), 0);
+    return { budgetedResults: results, truncated: false, tokenCount };
+  }
+}
+var init_search_utils = __esm({
+  "src/mcp/resources/search-utils.ts"() {
+    "use strict";
+    init_indexing_jobs();
+    init_utils2();
+  }
+});
+
 // src/mcp/resources/search.ts
-import * as fs19 from "fs";
-import * as path20 from "path";
+import * as fs20 from "fs";
+import * as path21 from "path";
 async function searchCode(query, projectFilter, limit = 10, options) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
@@ -3199,8 +3260,7 @@ async function searchCode(query, projectFilter, limit = 10, options) {
     if (projectFilter && project.name !== projectFilter) continue;
     const permissions = getProjectPermissions(config, project.name, project.sourcePath || project.path);
     if (!permissions.knowledge || !project.knowledgePath) continue;
-    const indexingInProgress2 = indexingJobs.isRunning(project.name);
-    const advisoryMessage2 = indexingInProgress2 ? "Indexing in progress; results may be stale/incomplete." : void 0;
+    const { indexingInProgress, advisoryMessage } = getSearchAdvisory(project.name);
     const projConfig = findProjectConfig(config, { name: project.name, path: project.sourcePath || project.path });
     const useRAG = projConfig?.semanticSearch?.enabled;
     if (!useRAG) {
@@ -3209,7 +3269,7 @@ async function searchCode(query, projectFilter, limit = 10, options) {
     }
     try {
       const codeIndexPath = getCodeIndexPath(project);
-      if (!fs19.existsSync(codeIndexPath)) {
+      if (!fs20.existsSync(codeIndexPath)) {
         logger.debug(`[searchCode] Code index not found for project '${project.name}'`);
         continue;
       }
@@ -3219,15 +3279,13 @@ async function searchCode(query, projectFilter, limit = 10, options) {
         const codeChunk = r;
         results.push({
           project: project.name,
-          file: path20.relative(project.sourcePath || project.path || "", codeChunk.filePath),
+          file: path21.relative(project.sourcePath || project.path || "", codeChunk.filePath),
           snippet: codeChunk.content,
           lineStart: codeChunk.lineStart ?? 1,
           lineEnd: codeChunk.lineEnd ?? 1,
           context: codeChunk.context,
           language: codeChunk.language,
-          score: codeChunk.score,
-          indexingInProgress: indexingInProgress2 || void 0,
-          advisoryMessage: advisoryMessage2
+          score: codeChunk.score
         });
       }
     } catch (e) {
@@ -3239,49 +3297,32 @@ async function searchCode(query, projectFilter, limit = 10, options) {
   if (options?.min_score !== void 0 && options.min_score > 0) {
     filteredResults = results.filter((r) => r.score >= options.min_score);
   }
-  let limitedResults = filteredResults.slice(0, limit);
-  let truncated = false;
-  let tokenCount = 0;
-  if (options?.max_tokens !== void 0 && options.max_tokens > 0) {
-    const budgetedResults = [];
-    for (const result of limitedResults) {
-      const resultTokens = estimateTokens(result.snippet + (result.context || ""));
-      if (tokenCount + resultTokens > options.max_tokens) {
-        truncated = true;
-        break;
-      }
-      budgetedResults.push(result);
-      tokenCount += resultTokens;
-    }
-    limitedResults = budgetedResults;
-  } else {
-    tokenCount = limitedResults.reduce((sum, r) => sum + estimateTokens(r.snippet + (r.context || "")), 0);
-  }
+  const limitedResults = filteredResults.slice(0, limit);
+  const { budgetedResults, truncated, tokenCount } = applyTokenBudget(
+    limitedResults,
+    options?.max_tokens,
+    (r) => r.snippet + (r.context || "")
+  );
   let indexAgeSeconds;
   let lastIndexedAt;
-  let indexingInProgress;
-  let advisoryMessage;
+  let indexingInProgressGlobal;
+  let advisoryMessageGlobal;
   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 { indexingInProgress, advisoryMessage } = getSearchAdvisory(projectFilter);
+    const freshness = getIndexFreshness(projectFilter);
+    indexingInProgressGlobal = indexingInProgress;
+    advisoryMessageGlobal = advisoryMessage;
+    indexAgeSeconds = freshness.indexAgeSeconds;
+    lastIndexedAt = freshness.lastIndexedAt;
   }
-  const cleanResults = limitedResults.map(({ indexingInProgress: _, advisoryMessage: __, ...rest }) => rest);
   return {
-    results: cleanResults,
+    results: budgetedResults,
     token_count: tokenCount,
     truncated,
     index_age_seconds: indexAgeSeconds,
     last_indexed_at: lastIndexedAt,
-    indexingInProgress,
-    advisoryMessage
+    indexingInProgress: indexingInProgressGlobal,
+    advisoryMessage: advisoryMessageGlobal
   };
 }
 async function searchKnowledge(query, projectFilter, options) {
@@ -3293,24 +3334,20 @@ async function searchKnowledge(query, projectFilter, options) {
     if (projectFilter && project.name !== projectFilter) continue;
     const permissions = getProjectPermissions(config, project.name, project.sourcePath || project.path);
     if (!permissions.knowledge || !project.knowledgePath) continue;
-    const indexingInProgress2 = indexingJobs.isRunning(project.name);
-    const advisoryMessage2 = indexingInProgress2 ? "Indexing in progress; results may be stale/incomplete." : void 0;
+    const { indexingInProgress, advisoryMessage } = getSearchAdvisory(project.name);
     const projConfig = findProjectConfig(config, { name: project.name, path: project.sourcePath || project.path });
     const useRAG = projConfig?.semanticSearch?.enabled;
     if (useRAG) {
-      logger.info(`[RAG] Using semantic search for project '${project.name}'`);
       try {
-        const indexPath = path20.join(project.knowledgePath, "embeddings.json");
+        const indexPath = path21.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: path20.relative(project.knowledgePath, r.filePath),
+            file: path21.relative(project.knowledgePath, r.filePath),
             matches: [r.content],
-            score: r.score,
-            indexingInProgress: indexingInProgress2 || void 0,
-            advisoryMessage: advisoryMessage2
+            score: r.score
           });
         }
         continue;
@@ -3319,11 +3356,11 @@ async function searchKnowledge(query, projectFilter, options) {
       }
     }
     try {
-      const files = fs19.readdirSync(project.knowledgePath);
+      const files = fs20.readdirSync(project.knowledgePath);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path20.join(project.knowledgePath, file);
-        const content = fs19.readFileSync(filePath, "utf-8");
+        const filePath = path21.join(project.knowledgePath, file);
+        const content = fs20.readFileSync(filePath, "utf-8");
         const lines = content.split("\n");
         const matches = [];
         for (const line of lines) {
@@ -3335,10 +3372,7 @@ async function searchKnowledge(query, projectFilter, options) {
           results.push({
             project: project.name,
             file,
-            matches: matches.slice(0, 5),
-            // Limit to 5 matches per file
-            indexingInProgress: indexingInProgress2 || void 0,
-            advisoryMessage: advisoryMessage2
+            matches: matches.slice(0, 5)
           });
         }
       }
@@ -3351,48 +3385,31 @@ async function searchKnowledge(query, projectFilter, options) {
     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);
-  }
+  const { budgetedResults, truncated, tokenCount } = applyTokenBudget(
+    filteredResults,
+    options?.max_tokens,
+    (r) => r.matches.join("\n")
+  );
   let indexAgeSeconds;
   let lastIndexedAt;
-  let indexingInProgress;
-  let advisoryMessage;
+  let indexingInProgressGlobal;
+  let advisoryMessageGlobal;
   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 { indexingInProgress, advisoryMessage } = getSearchAdvisory(projectFilter);
+    const freshness = getIndexFreshness(projectFilter);
+    indexingInProgressGlobal = indexingInProgress;
+    advisoryMessageGlobal = advisoryMessage;
+    indexAgeSeconds = freshness.indexAgeSeconds;
+    lastIndexedAt = freshness.lastIndexedAt;
   }
-  const cleanResults = budgetedResults.map(({ indexingInProgress: _, advisoryMessage: __, ...rest }) => rest);
   return {
-    results: cleanResults,
+    results: budgetedResults,
     token_count: tokenCount,
     truncated,
     index_age_seconds: indexAgeSeconds,
     last_indexed_at: lastIndexedAt,
-    indexingInProgress,
-    advisoryMessage
+    indexingInProgress: indexingInProgressGlobal,
+    advisoryMessage: advisoryMessageGlobal
   };
 }
 async function findRelatedFiles2(filePath, projectName, options = {}) {
@@ -3410,10 +3427,10 @@ async function findRelatedFiles2(filePath, projectName, options = {}) {
   }
   const projectRoot = project.sourcePath || project.path || "";
   let absoluteFilePath = filePath;
-  if (!path20.isAbsolute(filePath)) {
-    absoluteFilePath = path20.resolve(projectRoot, filePath);
+  if (!path21.isAbsolute(filePath)) {
+    absoluteFilePath = path21.resolve(projectRoot, filePath);
   }
-  if (!fs19.existsSync(absoluteFilePath)) {
+  if (!fs20.existsSync(absoluteFilePath)) {
     return {
       success: false,
       file: filePath,
@@ -3430,13 +3447,13 @@ async function findRelatedFiles2(filePath, projectName, options = {}) {
       depth: options.depth ?? 1
     });
     const relationships = related.map((r) => ({
-      file: path20.relative(projectRoot, r.file),
+      file: path21.relative(projectRoot, r.file),
       relationship: r.relationship,
       importPath: r.importPath
     }));
     return {
       success: true,
-      file: path20.relative(projectRoot, absoluteFilePath),
+      file: path21.relative(projectRoot, absoluteFilePath),
       project: projectName,
       relationships
     };
@@ -3464,7 +3481,7 @@ async function searchSymbols2(name, projectName, options = {}) {
     };
   }
   const projectRoot = project.sourcePath || project.path || "";
-  if (!fs19.existsSync(projectRoot)) {
+  if (!fs20.existsSync(projectRoot)) {
     return {
       success: false,
       project: projectName,
@@ -3475,14 +3492,14 @@ async function searchSymbols2(name, projectName, options = {}) {
   try {
     const codeFiles = [];
     const scanDir = (dir) => {
-      const entries = fs19.readdirSync(dir, { withFileTypes: true });
+      const entries = fs20.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path20.join(dir, entry.name);
+        const fullPath = path21.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (SKIP_DIRS.includes(entry.name)) continue;
           scanDir(fullPath);
         } else if (entry.isFile()) {
-          const ext = path20.extname(entry.name).toLowerCase();
+          const ext = path21.extname(entry.name).toLowerCase();
           if (CODE_EXTENSIONS.includes(ext)) {
             codeFiles.push(fullPath);
           }
@@ -3493,7 +3510,7 @@ async function searchSymbols2(name, projectName, options = {}) {
     const symbolResults = [];
     for (const file of codeFiles.slice(0, 500)) {
       try {
-        const content = fs19.readFileSync(file, "utf-8");
+        const content = fs20.readFileSync(file, "utf-8");
         const result = extractSymbols(content, file);
         symbolResults.push(result);
       } catch (e) {
@@ -3508,7 +3525,7 @@ async function searchSymbols2(name, projectName, options = {}) {
     const results = matches.map((m) => ({
       name: m.name,
       type: m.type,
-      file: path20.relative(projectRoot, m.file),
+      file: path21.relative(projectRoot, m.file),
       line: m.line,
       signature: m.signature,
       exported: m.exported,
@@ -3541,24 +3558,24 @@ async function getFileSummary(filePath, projectName) {
   }
   const projectRoot = project.sourcePath || project.path || "";
   let absolutePath = filePath;
-  if (!path20.isAbsolute(filePath)) {
-    absolutePath = path20.resolve(projectRoot, filePath);
+  if (!path21.isAbsolute(filePath)) {
+    absolutePath = path21.resolve(projectRoot, filePath);
   }
-  if (!fs19.existsSync(absolutePath)) {
+  if (!fs20.existsSync(absolutePath)) {
     return {
       success: false,
       message: `File not found: ${filePath}`
     };
   }
   try {
-    const stat = fs19.statSync(absolutePath);
-    const content = fs19.readFileSync(absolutePath, "utf-8");
+    const stat = fs20.statSync(absolutePath);
+    const content = fs20.readFileSync(absolutePath, "utf-8");
     const lines = content.split("\n");
     const symbolResult = extractSymbols(content, absolutePath);
     return {
       success: true,
       summary: {
-        path: path20.relative(projectRoot, absolutePath),
+        path: path21.relative(projectRoot, absolutePath),
         language: symbolResult.language,
         lines: lines.length,
         size_bytes: stat.size,
@@ -3594,47 +3611,164 @@ var init_search = __esm({
     init_projects();
     init_utils2();
     init_constants();
+    init_search_utils();
   }
 });
 
-// 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",
+// src/lib/drift-service.ts
+import * as fs21 from "fs";
+import * as path22 from "path";
+import * as crypto2 from "crypto";
+var DriftService;
+var init_drift_service = __esm({
+  "src/lib/drift-service.ts"() {
+    "use strict";
+    DriftService = class {
+      static CHECKSUM_FILENAME = ".rrce-checksums.json";
+      static calculateHash(filePath) {
+        const content = fs21.readFileSync(filePath);
+        return crypto2.createHash("md5").update(content).digest("hex");
+      }
+      static getManifestPath(projectPath) {
+        return path22.join(projectPath, this.CHECKSUM_FILENAME);
+      }
+      static loadManifest(projectPath) {
+        const manifestPath = this.getManifestPath(projectPath);
+        if (!fs21.existsSync(manifestPath)) {
+          return {};
+        }
+        try {
+          return JSON.parse(fs21.readFileSync(manifestPath, "utf8"));
+        } catch (e) {
+          return {};
+        }
+      }
+      static saveManifest(projectPath, manifest) {
+        const manifestPath = this.getManifestPath(projectPath);
+        fs21.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+      }
+      /**
+       * Generates a manifest for the current state of files in the project
+       */
+      static generateManifest(projectPath, files) {
+        const manifest = {};
+        for (const file of files) {
+          const fullPath = path22.join(projectPath, file);
+          if (fs21.existsSync(fullPath)) {
+            const stats = fs21.statSync(fullPath);
+            manifest[file] = {
+              hash: this.calculateHash(fullPath),
+              mtime: stats.mtimeMs
+            };
+          }
+        }
+        return manifest;
+      }
+      /**
+       * Compares current files against the manifest to detect modifications and deletions
+       */
+      static detectModifiedFiles(projectPath) {
+        const manifest = this.loadManifest(projectPath);
+        const modified = [];
+        const deleted = [];
+        for (const [relPath, entry] of Object.entries(manifest)) {
+          const fullPath = path22.join(projectPath, relPath);
+          if (!fs21.existsSync(fullPath)) {
+            deleted.push(relPath);
+            continue;
+          }
+          const stats = fs21.statSync(fullPath);
+          if (stats.mtimeMs === entry.mtime) {
+            continue;
+          }
+          const currentHash = this.calculateHash(fullPath);
+          if (currentHash !== entry.hash) {
+            modified.push(relPath);
+          }
+        }
+        return { modified, deleted };
+      }
+      /**
+       * Returns array of deleted file paths from manifest
+       */
+      static detectDeletedFiles(projectPath) {
+        const manifest = this.loadManifest(projectPath);
+        const deleted = [];
+        for (const relPath of Object.keys(manifest)) {
+          const fullPath = path22.join(projectPath, relPath);
+          if (!fs21.existsSync(fullPath)) {
+            deleted.push(relPath);
+          }
+        }
+        return deleted;
+      }
+      /**
+       * Full drift check: version + modifications
+       */
+      static checkDrift(projectPath, currentVersion, runningVersion) {
+        const { modified, deleted } = this.detectModifiedFiles(projectPath);
+        let type = "none";
+        let hasDrift = false;
+        if (currentVersion !== runningVersion) {
+          hasDrift = true;
+          type = "version";
+        } else if (modified.length > 0 || deleted.length > 0) {
+          hasDrift = true;
+          type = "modified";
+        }
+        return {
+          hasDrift,
+          type,
+          modifiedFiles: modified,
+          deletedFiles: deleted,
+          version: {
+            current: currentVersion || "0.0.0",
+            running: runningVersion
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/mcp/resources/indexing.ts
+import * as fs22 from "fs";
+import * as path23 from "path";
+async function indexKnowledge(projectName, force = false, clean = 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 (!fs22.existsSync(scanRoot)) {
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: "Project root not found",
       filesIndexed: 0,
       filesSkipped: 0,
       progress: { itemsDone: 0 }
@@ -3642,8 +3776,14 @@ async function indexKnowledge(projectName, force = false) {
   }
   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 knowledgeDir = project.knowledgePath || path23.join(scanRoot, ".rrce-workflow", "knowledge");
+    const indexPath = path23.join(knowledgeDir, "embeddings.json");
+    const codeIndexPath = path23.join(knowledgeDir, "code-embeddings.json");
+    if (clean) {
+      logger.info(`[RAG] Cleaning knowledge index for ${project.name}`);
+      if (fs22.existsSync(indexPath)) fs22.unlinkSync(indexPath);
+      if (fs22.existsSync(codeIndexPath)) fs22.unlinkSync(codeIndexPath);
+    }
     const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
     const rag = new RAGService(indexPath, model);
     const codeRag = new RAGService(codeIndexPath, model);
@@ -3653,14 +3793,14 @@ async function indexKnowledge(projectName, force = false) {
     let itemsTotal = 0;
     let itemsDone = 0;
     const preCount = (dir) => {
-      const entries = fs20.readdirSync(dir, { withFileTypes: true });
+      const entries = fs22.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path21.join(dir, entry.name);
+        const fullPath = path23.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (shouldSkipEntryDir(fullPath)) continue;
           preCount(fullPath);
         } else if (entry.isFile()) {
-          const ext = path21.extname(entry.name).toLowerCase();
+          const ext = path23.extname(entry.name).toLowerCase();
           if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
           if (shouldSkipEntryFile(fullPath)) continue;
           itemsTotal++;
@@ -3672,13 +3812,18 @@ async function indexKnowledge(projectName, force = false) {
     const cleanupIgnoredFiles = async () => {
       const indexedFiles = [...rag.getIndexedFiles(), ...codeRag.getIndexedFiles()];
       const unique = Array.from(new Set(indexedFiles));
+      const deletedFiles = project.dataPath ? DriftService.detectDeletedFiles(project.dataPath) : [];
+      if (deletedFiles.length > 0) {
+        logger.info(`[RAG] ${project.name}: Detected ${deletedFiles.length} deleted files from manifest`);
+      }
       for (const filePath of unique) {
-        if (!path21.isAbsolute(filePath)) continue;
-        const relFilePath = filePath.split(path21.sep).join("/");
-        const relScanRoot = scanRoot.split(path21.sep).join("/");
+        if (!path23.isAbsolute(filePath)) continue;
+        const relFilePath = filePath.split(path23.sep).join("/");
+        const relScanRoot = scanRoot.split(path23.sep).join("/");
         const isInScanRoot = relFilePath === relScanRoot || relFilePath.startsWith(`${relScanRoot}/`);
         if (!isInScanRoot) continue;
-        if (shouldSkipEntryFile(filePath)) {
+        const isDeleted = deletedFiles.some((df) => filePath.endsWith(df));
+        if (shouldSkipEntryFile(filePath) || isDeleted || !fs22.existsSync(filePath)) {
           await rag.removeFile(filePath);
           await codeRag.removeFile(filePath);
         }
@@ -3686,21 +3831,21 @@ async function indexKnowledge(projectName, force = false) {
     };
     await cleanupIgnoredFiles();
     const scanDir = async (dir) => {
-      const entries = fs20.readdirSync(dir, { withFileTypes: true });
+      const entries = fs22.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path21.join(dir, entry.name);
+        const fullPath = path23.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();
+          const ext = path23.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 stat = fs22.statSync(fullPath);
             const mtime = force ? void 0 : stat.mtimeMs;
-            const content = fs20.readFileSync(fullPath, "utf-8");
+            const content = fs22.readFileSync(fullPath, "utf-8");
             const wasIndexed = await rag.indexFile(fullPath, content, mtime);
             if (wasIndexed) {
               indexed++;
@@ -3772,11 +3917,12 @@ var init_indexing = __esm({
     init_projects();
     init_utils2();
     init_constants();
+    init_drift_service();
   }
 });
 
 // src/mcp/resources/context.ts
-import * as path22 from "path";
+import * as path24 from "path";
 import * as os4 from "os";
 function getContextPreamble() {
   const activeProject = detectActiveProject();
@@ -3792,7 +3938,7 @@ If the above tools fail, ask the user for clarification.
 ---
 `;
   }
-  const rrceHome = process.env.RRCE_HOME || path22.join(os4.homedir(), ".rrce-workflow");
+  const rrceHome = process.env.RRCE_HOME || path24.join(os4.homedir(), ".rrce-workflow");
   const workspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
   const rrceData = activeProject.dataPath;
   return `## System Context
@@ -4087,8 +4233,8 @@ var init_validation = __esm({
 });
 
 // src/mcp/resources/sessions.ts
-import * as fs21 from "fs";
-import * as path23 from "path";
+import * as fs23 from "fs";
+import * as path25 from "path";
 function startSession(projectName, taskSlug, agent, phase) {
   const config = loadMCPConfig();
   const projects = projectService.scan();
@@ -4096,8 +4242,8 @@ function startSession(projectName, taskSlug, agent, phase) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const taskDir = path23.join(project.tasksPath, taskSlug);
-  if (!fs21.existsSync(taskDir)) {
+  const taskDir = path25.join(project.tasksPath, taskSlug);
+  if (!fs23.existsSync(taskDir)) {
     return { success: false, message: `Task '${taskSlug}' not found.` };
   }
   const session = {
@@ -4107,8 +4253,8 @@ function startSession(projectName, taskSlug, agent, phase) {
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
     heartbeat: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const sessionPath = path23.join(taskDir, "session.json");
-  fs21.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+  const sessionPath = path25.join(taskDir, "session.json");
+  fs23.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) {
@@ -4118,11 +4264,11 @@ function endSession(projectName, taskSlug) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const sessionPath = path23.join(project.tasksPath, taskSlug, "session.json");
-  if (!fs21.existsSync(sessionPath)) {
+  const sessionPath = path25.join(project.tasksPath, taskSlug, "session.json");
+  if (!fs23.existsSync(sessionPath)) {
     return { success: true, message: `No active session for task '${taskSlug}'.` };
   }
-  fs21.unlinkSync(sessionPath);
+  fs23.unlinkSync(sessionPath);
   return { success: true, message: `Session ended for task '${taskSlug}'.` };
 }
 function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
@@ -4132,9 +4278,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 = path23.join(project.tasksPath, taskSlug);
-  if (!fs21.existsSync(taskDir)) {
-    fs21.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path25.join(project.tasksPath, taskSlug);
+  if (!fs23.existsSync(taskDir)) {
+    fs23.mkdirSync(taskDir, { recursive: true });
   }
   const todos = {
     phase,
@@ -4142,8 +4288,8 @@ function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
     items,
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const todosPath = path23.join(taskDir, "agent-todos.json");
-  fs21.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
+  const todosPath = path25.join(taskDir, "agent-todos.json");
+  fs23.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
   return { success: true, message: `Updated ${items.length} todo items for task '${taskSlug}'.`, count: items.length };
 }
 var init_sessions = __esm({
@@ -4263,143 +4409,69 @@ var init_resources3 = __esm({
   }
 });
 
-// src/mcp/prompts.ts
-import * as path24 from "path";
-import * as fs22 from "fs";
-function loadBaseProtocol2() {
-  if (baseProtocolCache !== null) {
-    return baseProtocolCache;
-  }
-  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;
-  }
-  baseProtocolCache = "";
-  return "";
-}
-function getAllPrompts() {
-  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-  return prompts.map((p) => {
-    const args = [];
-    if (p.frontmatter["required-args"]) {
-      args.push(...p.frontmatter["required-args"].map((a) => ({
-        name: a.name,
-        description: a.prompt || a.name,
-        required: true
-      })));
-    }
-    if (p.frontmatter["optional-args"]) {
-      args.push(...p.frontmatter["optional-args"].map((a) => ({
-        name: a.name,
-        description: a.prompt || a.name,
-        required: false
-      })));
+// src/mcp/handlers/tools/project.ts
+async function handleProjectTool(name, args) {
+  if (!args) {
+    if (name === "list_projects" || name === "help_setup") {
+    } else {
+      return null;
     }
-    const filename = p.filePath.split("/").pop() || "";
-    const id = filename.replace(/\.md$/, "");
-    return {
-      id,
-      name: p.frontmatter.name,
-      description: p.frontmatter.description,
-      arguments: args,
-      content: p.content
-    };
-  });
-}
-function getPromptDef(name) {
-  const all = getAllPrompts();
-  const search = name.toLowerCase();
-  return all.find(
-    (p) => p.name === name || p.id === name || p.name.toLowerCase() === search || p.id.toLowerCase() === search
-  );
-}
-function renderPromptWithContext(content, args) {
-  const renderArgs = { ...args };
-  let activeProject = detectActiveProject();
-  if (!activeProject) {
-    projectService.refresh();
-    activeProject = detectActiveProject();
   }
-  const DEFAULT_RRCE_HOME = getEffectiveGlobalPath();
-  let resolvedRrceData = ".rrce-workflow/";
-  let resolvedRrceHome = DEFAULT_RRCE_HOME;
-  let resolvedWorkspaceRoot = process.cwd();
-  let resolvedWorkspaceName = "current-project";
-  if (activeProject) {
-    resolvedRrceData = activeProject.dataPath;
-    if (!resolvedRrceData.endsWith("/") && !resolvedRrceData.endsWith("\\")) {
-      resolvedRrceData += "/";
+  switch (name) {
+    case "resolve_path": {
+      const params = args;
+      const result = resolveProjectPaths(params.project, params.path);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
-    resolvedWorkspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
-    resolvedWorkspaceName = activeProject.name;
-    if (activeProject.source === "global") {
-      const workspacesDir = path24.dirname(activeProject.dataPath);
-      resolvedRrceHome = path24.dirname(workspacesDir);
+    case "list_projects": {
+      const projects = getExposedProjects();
+      const list = projects.map((p) => ({ name: p.name, source: p.source, path: p.path }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(list, null, 2) + "\n\nTip: Use these project names for tools like `get_project_context` or `index_knowledge`."
+        }]
+      };
     }
-  } else {
-    try {
-      const workspaceRoot = detectWorkspaceRoot();
-      const workspaceName = path24.basename(workspaceRoot);
-      const globalWorkspacePath = path24.join(DEFAULT_RRCE_HOME, "workspaces", workspaceName);
-      if (fs22.existsSync(globalWorkspacePath)) {
-        resolvedRrceData = globalWorkspacePath;
-        resolvedWorkspaceRoot = workspaceRoot;
-        resolvedWorkspaceName = workspaceName;
-        if (!resolvedRrceData.endsWith("/") && !resolvedRrceData.endsWith("\\")) {
-          resolvedRrceData += "/";
-        }
+    case "get_project_context": {
+      const context = getProjectContext(args.project);
+      if (!context) {
+        const projects = getExposedProjects().map((p) => p.name).join(", ");
+        const msg = `No project context found for "${args.project}".
+Available projects: ${projects}`;
+        logger.warn(msg);
+        return { content: [{ type: "text", text: msg }], isError: true };
       }
-    } catch (e) {
+      return { content: [{ type: "text", text: context }] };
     }
-  }
-  if (!renderArgs["RRCE_DATA"]) renderArgs["RRCE_DATA"] = resolvedRrceData;
-  if (!renderArgs["RRCE_HOME"]) renderArgs["RRCE_HOME"] = resolvedRrceHome;
-  if (!renderArgs["WORKSPACE_ROOT"]) renderArgs["WORKSPACE_ROOT"] = resolvedWorkspaceRoot;
-  if (!renderArgs["WORKSPACE_NAME"]) renderArgs["WORKSPACE_NAME"] = resolvedWorkspaceName;
-  const agentContent = renderPrompt(content, renderArgs);
-  const baseProtocol = loadBaseProtocol2();
-  const rendered = baseProtocol ? `${baseProtocol}
-${agentContent}` : agentContent;
-  return {
-    rendered,
-    context: {
-      RRCE_DATA: resolvedRrceData,
-      RRCE_HOME: resolvedRrceHome,
-      WORKSPACE_ROOT: resolvedWorkspaceRoot,
-      WORKSPACE_NAME: resolvedWorkspaceName
+    case "index_knowledge": {
+      const params = args;
+      const result = await indexKnowledge(params.project, params.force, params.clean);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
-  };
-}
-function renderPrompt(content, args) {
-  let rendered = content;
-  for (const [key, val] of Object.entries(args)) {
-    rendered = rendered.replace(new RegExp(`{{${key}}}`, "g"), val);
+    case "help_setup": {
+      const msg = `
+RRCE MCP Server is running, but no projects are configured/exposed.
+
+To fix this:
+1. Open a terminal.
+2. Run: npx rrce-workflow mcp configure
+3. Select the projects you want to expose to the AI.
+4. Restart the MCP server (or it may pick up changes automatically).
+`;
+      return { content: [{ type: "text", text: msg }] };
+    }
+    default:
+      return null;
   }
-  return rendered;
 }
-var baseProtocolCache;
-var init_prompts2 = __esm({
-  "src/mcp/prompts.ts"() {
+var projectTools;
+var init_project = __esm({
+  "src/mcp/handlers/tools/project.ts"() {
     "use strict";
-    init_prompts();
     init_resources2();
-    init_paths();
-    init_detection_service();
-    baseProtocolCache = null;
-  }
-});
-
-// src/mcp/handlers/tools.ts
-import "@modelcontextprotocol/sdk/server/index.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-function registerToolHandlers(server) {
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const tools = [
+    init_logger();
+    projectTools = [
       {
         name: "resolve_path",
         description: "Resolve configuration paths (RRCE_DATA, etc.) for a project. Helps determine if a project is using global or local storage.",
@@ -4411,6 +4483,124 @@ function registerToolHandlers(server) {
           }
         }
       },
+      {
+        name: "list_projects",
+        description: "List all projects exposed via MCP. Use these names for project-specific tools.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_project_context",
+        description: "Get the project context/architecture for a specific project",
+        inputSchema: {
+          type: "object",
+          properties: { project: { type: "string", description: "Name of the project to get context for" } },
+          required: ["project"]
+        }
+      },
+      {
+        name: "index_knowledge",
+        description: "Update the semantic search index for a specific project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project to index" },
+            force: { type: "boolean", description: "Force re-indexing of all files" },
+            clean: { type: "boolean", description: "Wipe existing index and rebuild from scratch" }
+          },
+          required: ["project"]
+        }
+      }
+    ];
+  }
+});
+
+// src/mcp/handlers/tools/search.ts
+async function handleSearchTool(name, args) {
+  if (!args) return null;
+  switch (name) {
+    case "search_knowledge": {
+      const params = args;
+      const result = await searchKnowledge(params.query, params.project, {
+        max_tokens: params.max_tokens,
+        min_score: params.min_score
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "search_code": {
+      const params = args;
+      const result = await searchCode(params.query, params.project, params.limit, {
+        max_tokens: params.max_tokens,
+        min_score: params.min_score
+      });
+      if (result.results.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No code matches found. The code index may be empty or semantic search is not enabled.\nRun `index_knowledge` first to build the code index."
+          }]
+        };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "find_related_files": {
+      const params = args;
+      const result = await findRelatedFiles2(params.file, params.project, {
+        includeImports: params.include_imports,
+        includeImportedBy: params.include_imported_by,
+        depth: params.depth
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "search_symbols": {
+      const params = args;
+      const result = await searchSymbols2(params.name, params.project, {
+        type: params.type,
+        fuzzy: params.fuzzy,
+        limit: params.limit
+      });
+      if (!result.success) {
+        return { content: [{ type: "text", text: result.message || "Search failed" }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "get_file_summary": {
+      const params = args;
+      const result = await getFileSummary(params.file, params.project);
+      if (!result.success) {
+        return { content: [{ type: "text", text: result.message || "Failed to get file summary" }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result.summary, null, 2) }] };
+    }
+    case "get_context_bundle": {
+      const params = args;
+      const result = await getContextBundle(params.query, params.project, {
+        task_slug: params.task_slug,
+        max_tokens: params.max_tokens,
+        include: params.include
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "prefetch_task_context": {
+      const params = args;
+      const result = await prefetchTaskContext(params.project, params.task_slug, {
+        max_tokens: params.max_tokens
+      });
+      if (!result.success) {
+        return { content: [{ type: "text", text: result.message || "Failed to prefetch task context" }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    default:
+      return null;
+  }
+}
+var searchTools;
+var init_search2 = __esm({
+  "src/mcp/handlers/tools/search.ts"() {
+    "use strict";
+    init_resources2();
+    init_logger();
+    searchTools = [
       {
         name: "search_knowledge",
         description: "Search across all exposed project knowledge bases. Returns results with token count and optional truncation.",
@@ -4518,194 +4708,465 @@ function registerToolHandlers(server) {
           },
           required: ["project", "task_slug"]
         }
-      },
+      }
+    ];
+  }
+});
+
+// src/mcp/handlers/tools/task.ts
+async function handleTaskTool(name, args) {
+  if (!args) return null;
+  switch (name) {
+    case "list_tasks": {
+      const params = args;
+      const tasks = getProjectTasks(params.project);
+      return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+    }
+    case "get_task": {
+      const params = args;
+      const task = getTask(params.project, params.task_slug);
+      if (!task) {
+        return { content: [{ type: "text", text: `Task '${params.task_slug}' not found in project '${params.project}'.` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+    }
+    case "create_task": {
+      const params = args;
+      const taskData = {
+        title: params.title || params.task_slug,
+        summary: params.summary || ""
+      };
+      const task = await createTask(params.project, params.task_slug, taskData);
+      return { content: [{ type: "text", text: `\u2713 Task '${params.task_slug}' created. meta.json saved.
+${JSON.stringify(task, null, 2)}` }] };
+    }
+    case "update_task": {
+      const params = args;
+      const task = await updateTask(params.project, params.task_slug, params.updates);
+      return { content: [{ type: "text", text: `\u2713 Task '${params.task_slug}' updated. meta.json saved.
+${JSON.stringify(task, null, 2)}` }] };
+    }
+    case "delete_task": {
+      const params = args;
+      const success = deleteTask(params.project, params.task_slug);
+      return { content: [{ type: "text", text: success ? `\u2713 Task '${params.task_slug}' deleted.` : `\u2717 Failed to delete '${params.task_slug}'.` }] };
+    }
+    case "search_tasks": {
+      const params = args;
+      const results = searchTasks(params.project, {
+        keyword: params.keyword,
+        status: params.status,
+        agent: params.agent,
+        since: params.since,
+        limit: params.limit
+      });
+      return { content: [{ type: "text", text: JSON.stringify({ count: results.length, tasks: results }, null, 2) }] };
+    }
+    case "validate_phase": {
+      const params = args;
+      const result = validatePhase(params.project, params.task_slug, params.phase);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    default:
+      return null;
+  }
+}
+var taskTools;
+var init_task = __esm({
+  "src/mcp/handlers/tools/task.ts"() {
+    "use strict";
+    init_resources2();
+    taskTools = [
       {
-        name: "search_tasks",
-        description: "Search across all tasks by keyword, status, agent phase, or date. Returns matching tasks sorted by relevance.",
+        name: "list_tasks",
+        description: "List all tasks for a project",
         inputSchema: {
           type: "object",
-          properties: {
-            project: { type: "string", description: "Name of the project" },
-            keyword: { type: "string", description: "Search in title/summary" },
-            status: { type: "string", description: "Filter by status (draft, in_progress, complete, etc.)" },
-            agent: { type: "string", description: "Filter by agent phase (research, planning, executor, documentation)" },
-            since: { type: "string", description: "ISO date - tasks updated after this date" },
-            limit: { type: "number", description: "Max results (default: 20)" }
-          },
+          properties: { project: { type: "string", description: "Name of the project" } },
           required: ["project"]
         }
       },
       {
-        name: "validate_phase",
-        description: "Check if a task phase has all prerequisites complete. Returns validation result with missing items and suggestions.",
+        name: "get_task",
+        description: "Get details of a specific task",
         inputSchema: {
           type: "object",
           properties: {
             project: { type: "string", description: "Name of the project" },
-            task_slug: { type: "string", description: "The task slug" },
-            phase: { type: "string", enum: ["research", "planning", "execution", "documentation"], description: "Phase to validate" }
+            task_slug: { type: "string", description: "The slug of the task" }
           },
-          required: ["project", "task_slug", "phase"]
+          required: ["project", "task_slug"]
         }
       },
       {
-        name: "index_knowledge",
-        description: "Update the semantic search index for a specific project",
+        name: "create_task",
+        description: "Create a new task in the project",
         inputSchema: {
           type: "object",
           properties: {
-            project: { type: "string", description: "Name of the project to index" },
-            force: { type: "boolean", description: "Force re-indexing of all files" }
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug for the new task (kebab-case)" },
+            title: { type: "string", description: "The title of the task" },
+            summary: { type: "string", description: "Brief summary of the task" }
           },
-          required: ["project"]
-        }
-      },
-      {
-        name: "list_projects",
-        description: "List all projects exposed via MCP. Use these names for project-specific tools.",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "get_project_context",
-        description: "Get the project context/architecture for a specific project",
-        inputSchema: {
-          type: "object",
-          properties: { project: { type: "string", description: "Name of the project to get context for" } },
-          required: ["project"]
+          required: ["project", "task_slug"]
         }
       },
       {
-        name: "list_agents",
-        description: "List available agents (e.g. init, plan) and their arguments. Use this to discover which agent to call.",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "get_agent_prompt",
-        description: 'Get the system prompt for a specific agent. Accepts agent Name (e.g. "RRCE Init") or ID (e.g. "init").',
+        name: "update_task",
+        description: "Update an existing task",
         inputSchema: {
           type: "object",
           properties: {
-            agent: { type: "string", description: "Name of the agent (e.g. init, plan, execute)" },
-            args: { type: "object", description: "Arguments for the agent prompt", additionalProperties: true }
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task" },
+            updates: { type: "object", description: "The fields to update in meta.json", additionalProperties: true }
           },
-          required: ["agent"]
+          required: ["project", "task_slug", "updates"]
         }
       },
       {
-        name: "list_tasks",
-        description: "List all tasks for a project",
+        name: "delete_task",
+        description: "Delete a task from the project",
         inputSchema: {
           type: "object",
-          properties: { project: { type: "string", description: "Name of the project" } },
-          required: ["project"]
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task to delete" }
+          },
+          required: ["project", "task_slug"]
         }
       },
       {
-        name: "get_task",
-        description: "Get details of a specific task",
+        name: "search_tasks",
+        description: "Search across all tasks by keyword, status, agent phase, or date. Returns matching tasks sorted by relevance.",
         inputSchema: {
           type: "object",
           properties: {
             project: { type: "string", description: "Name of the project" },
-            task_slug: { type: "string", description: "The slug of the task" }
+            keyword: { type: "string", description: "Search in title/summary" },
+            status: { type: "string", description: "Filter by status (draft, in_progress, complete, etc.)" },
+            agent: { type: "string", description: "Filter by agent phase (research, planning, executor, documentation)" },
+            since: { type: "string", description: "ISO date - tasks updated after this date" },
+            limit: { type: "number", description: "Max results (default: 20)" }
           },
-          required: ["project", "task_slug"]
+          required: ["project"]
         }
       },
       {
-        name: "create_task",
-        description: "Create a new task in the project",
+        name: "validate_phase",
+        description: "Check if a task phase has all prerequisites complete. Returns validation result with missing items and suggestions.",
         inputSchema: {
           type: "object",
           properties: {
             project: { type: "string", description: "Name of the project" },
-            task_slug: { type: "string", description: "The slug for the new task (kebab-case)" },
-            title: { type: "string", description: "The title of the task" },
-            summary: { type: "string", description: "Brief summary of the task" }
+            task_slug: { type: "string", description: "The task slug" },
+            phase: { type: "string", enum: ["research", "planning", "execution", "documentation"], description: "Phase to validate" }
           },
-          required: ["project", "task_slug"]
+          required: ["project", "task_slug", "phase"]
         }
-      },
+      }
+    ];
+  }
+});
+
+// src/mcp/handlers/tools/session.ts
+async function handleSessionTool(name, args) {
+  if (!args) return null;
+  switch (name) {
+    case "start_session": {
+      const params = args;
+      const result = startSession(params.project, params.task_slug, params.agent, params.phase);
+      return { content: [{ type: "text", text: result.message }], isError: !result.success };
+    }
+    case "end_session": {
+      const params = args;
+      const result = endSession(params.project, params.task_slug);
+      return { content: [{ type: "text", text: result.message }], isError: !result.success };
+    }
+    case "update_agent_todos": {
+      const params = args;
+      const result = updateAgentTodos(params.project, params.task_slug, params.phase, params.agent, params.items);
+      return { content: [{ type: "text", text: result.message }], isError: !result.success };
+    }
+    default:
+      return null;
+  }
+}
+var sessionTools;
+var init_session = __esm({
+  "src/mcp/handlers/tools/session.ts"() {
+    "use strict";
+    init_resources2();
+    sessionTools = [
       {
-        name: "update_task",
-        description: "Update an existing task",
+        name: "start_session",
+        description: "Start an agent session for active task tracking. Call this when beginning work on a task phase.",
         inputSchema: {
           type: "object",
           properties: {
             project: { type: "string", description: "Name of the project" },
             task_slug: { type: "string", description: "The slug of the task" },
-            updates: { type: "object", description: "The fields to update in meta.json", additionalProperties: true }
+            agent: { type: "string", description: "Agent type: research, planning, executor, or documentation" },
+            phase: { type: "string", description: 'Current phase description (e.g., "clarification", "task breakdown")' }
           },
-          required: ["project", "task_slug", "updates"]
+          required: ["project", "task_slug", "agent", "phase"]
         }
       },
       {
-        name: "delete_task",
-        description: "Delete a task from the project",
+        name: "end_session",
+        description: "End an agent session. Call this before emitting completion signal.",
         inputSchema: {
           type: "object",
           properties: {
             project: { type: "string", description: "Name of the project" },
-            task_slug: { type: "string", description: "The slug of the task to delete" }
+            task_slug: { type: "string", description: "The slug of the task" }
           },
           required: ["project", "task_slug"]
         }
       },
       {
-        name: "start_session",
-        description: "Start an agent session for active task tracking. Call this when beginning work on a task phase.",
+        name: "update_agent_todos",
+        description: "Update the agent todo list for a task. Use this to track granular work items during a phase.",
         inputSchema: {
           type: "object",
           properties: {
             project: { type: "string", description: "Name of the project" },
             task_slug: { type: "string", description: "The slug of the task" },
-            agent: { type: "string", description: "Agent type: research, planning, executor, or documentation" },
-            phase: { type: "string", description: 'Current phase description (e.g., "clarification", "task breakdown")' }
+            phase: { type: "string", description: "Current phase" },
+            agent: { type: "string", description: "Agent type" },
+            items: {
+              type: "array",
+              description: "Todo items array",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "string" },
+                  content: { type: "string" },
+                  status: { type: "string", enum: ["pending", "in_progress", "completed"] },
+                  priority: { type: "string", enum: ["high", "medium", "low"] }
+                },
+                required: ["id", "content", "status", "priority"]
+              }
+            }
           },
-          required: ["project", "task_slug", "agent", "phase"]
+          required: ["project", "task_slug", "phase", "agent", "items"]
+        }
+      }
+    ];
+  }
+});
+
+// src/mcp/prompts.ts
+import * as path26 from "path";
+import * as fs24 from "fs";
+function loadBaseProtocol2() {
+  if (baseProtocolCache !== null) {
+    return baseProtocolCache;
+  }
+  const basePath = path26.join(getAgentCorePromptsDir(), "_base.md");
+  if (fs24.existsSync(basePath)) {
+    const content = fs24.readFileSync(basePath, "utf-8");
+    baseProtocolCache = content.replace(/^---[\s\S]*?---\n*/, "");
+    return baseProtocolCache;
+  }
+  baseProtocolCache = "";
+  return "";
+}
+function getAllPrompts() {
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  return prompts.map((p) => {
+    const args = [];
+    if (p.frontmatter["required-args"]) {
+      args.push(...p.frontmatter["required-args"].map((a) => ({
+        name: a.name,
+        description: a.prompt || a.name,
+        required: true
+      })));
+    }
+    if (p.frontmatter["optional-args"]) {
+      args.push(...p.frontmatter["optional-args"].map((a) => ({
+        name: a.name,
+        description: a.prompt || a.name,
+        required: false
+      })));
+    }
+    const filename = p.filePath.split("/").pop() || "";
+    const id = filename.replace(/\.md$/, "");
+    return {
+      id,
+      name: p.frontmatter.name,
+      description: p.frontmatter.description,
+      arguments: args,
+      content: p.content
+    };
+  });
+}
+function getPromptDef(name) {
+  const all = getAllPrompts();
+  const search = name.toLowerCase();
+  return all.find(
+    (p) => p.name === name || p.id === name || p.name.toLowerCase() === search || p.id.toLowerCase() === search
+  );
+}
+function renderPromptWithContext(content, args) {
+  const renderArgs = { ...args };
+  let activeProject = detectActiveProject();
+  if (!activeProject) {
+    projectService.refresh();
+    activeProject = detectActiveProject();
+  }
+  const DEFAULT_RRCE_HOME = getEffectiveGlobalPath();
+  let resolvedRrceData = ".rrce-workflow/";
+  let resolvedRrceHome = DEFAULT_RRCE_HOME;
+  let resolvedWorkspaceRoot = process.cwd();
+  let resolvedWorkspaceName = "current-project";
+  if (activeProject) {
+    resolvedRrceData = activeProject.dataPath;
+    if (!resolvedRrceData.endsWith("/") && !resolvedRrceData.endsWith("\\")) {
+      resolvedRrceData += "/";
+    }
+    resolvedWorkspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
+    resolvedWorkspaceName = activeProject.name;
+    if (activeProject.source === "global") {
+      const workspacesDir = path26.dirname(activeProject.dataPath);
+      resolvedRrceHome = path26.dirname(workspacesDir);
+    }
+  } else {
+    try {
+      const workspaceRoot = detectWorkspaceRoot();
+      const workspaceName = path26.basename(workspaceRoot);
+      const globalWorkspacePath = path26.join(DEFAULT_RRCE_HOME, "workspaces", workspaceName);
+      if (fs24.existsSync(globalWorkspacePath)) {
+        resolvedRrceData = globalWorkspacePath;
+        resolvedWorkspaceRoot = workspaceRoot;
+        resolvedWorkspaceName = workspaceName;
+        if (!resolvedRrceData.endsWith("/") && !resolvedRrceData.endsWith("\\")) {
+          resolvedRrceData += "/";
         }
-      },
+      }
+    } catch (e) {
+    }
+  }
+  if (!renderArgs["RRCE_DATA"]) renderArgs["RRCE_DATA"] = resolvedRrceData;
+  if (!renderArgs["RRCE_HOME"]) renderArgs["RRCE_HOME"] = resolvedRrceHome;
+  if (!renderArgs["WORKSPACE_ROOT"]) renderArgs["WORKSPACE_ROOT"] = resolvedWorkspaceRoot;
+  if (!renderArgs["WORKSPACE_NAME"]) renderArgs["WORKSPACE_NAME"] = resolvedWorkspaceName;
+  const agentContent = renderPrompt(content, renderArgs);
+  const baseProtocol = loadBaseProtocol2();
+  const rendered = baseProtocol ? `${baseProtocol}
+${agentContent}` : agentContent;
+  return {
+    rendered,
+    context: {
+      RRCE_DATA: resolvedRrceData,
+      RRCE_HOME: resolvedRrceHome,
+      WORKSPACE_ROOT: resolvedWorkspaceRoot,
+      WORKSPACE_NAME: resolvedWorkspaceName
+    }
+  };
+}
+function renderPrompt(content, args) {
+  let rendered = content;
+  for (const [key, val] of Object.entries(args)) {
+    rendered = rendered.replace(new RegExp(`{{${key}}}`, "g"), val);
+  }
+  return rendered;
+}
+var baseProtocolCache;
+var init_prompts2 = __esm({
+  "src/mcp/prompts.ts"() {
+    "use strict";
+    init_prompts();
+    init_resources2();
+    init_paths();
+    init_detection_service();
+    baseProtocolCache = null;
+  }
+});
+
+// src/mcp/handlers/tools/agent.ts
+async function handleAgentTool(name, args) {
+  if (!args && name !== "list_agents") return null;
+  switch (name) {
+    case "list_agents": {
+      const prompts = getAllPrompts();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(prompts.map((p) => ({
+            name: p.name,
+            id: p.id,
+            description: p.description,
+            arguments: p.arguments
+          })), null, 2) + "\n\nTip: Retrieve the prompt for an agent using `get_agent_prompt` with its name or ID."
+        }]
+      };
+    }
+    case "get_agent_prompt": {
+      const params = args;
+      const agentName = params.agent;
+      const promptDef = getPromptDef(agentName);
+      if (!promptDef) {
+        const available = getAllPrompts().map((p) => `${p.name} (id: ${p.id})`).join(", ");
+        throw new Error(`Agent not found: ${agentName}. Available agents: ${available}`);
+      }
+      const renderArgs = params.args || {};
+      const stringArgs = {};
+      for (const [key, val] of Object.entries(renderArgs)) {
+        stringArgs[key] = String(val);
+      }
+      const { rendered } = renderPromptWithContext(promptDef.content, stringArgs);
+      const contextPreamble = getContextPreamble();
+      return { content: [{ type: "text", text: contextPreamble + rendered }] };
+    }
+    default:
+      return null;
+  }
+}
+var agentTools;
+var init_agent = __esm({
+  "src/mcp/handlers/tools/agent.ts"() {
+    "use strict";
+    init_resources2();
+    init_prompts2();
+    agentTools = [
       {
-        name: "end_session",
-        description: "End an agent session. Call this before emitting completion signal.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            project: { type: "string", description: "Name of the project" },
-            task_slug: { type: "string", description: "The slug of the task" }
-          },
-          required: ["project", "task_slug"]
-        }
+        name: "list_agents",
+        description: "List available agents (e.g. init, plan) and their arguments. Use this to discover which agent to call.",
+        inputSchema: { type: "object", properties: {} }
       },
       {
-        name: "update_agent_todos",
-        description: "Update the agent todo list for a task. Use this to track granular work items during a phase.",
+        name: "get_agent_prompt",
+        description: 'Get the system prompt for a specific agent. Accepts agent Name (e.g. "RRCE Init") or ID (e.g. "init").',
         inputSchema: {
           type: "object",
           properties: {
-            project: { type: "string", description: "Name of the project" },
-            task_slug: { type: "string", description: "The slug of the task" },
-            phase: { type: "string", description: "Current phase" },
-            agent: { type: "string", description: "Agent type" },
-            items: {
-              type: "array",
-              description: "Todo items array",
-              items: {
-                type: "object",
-                properties: {
-                  id: { type: "string" },
-                  content: { type: "string" },
-                  status: { type: "string", enum: ["pending", "in_progress", "completed"] },
-                  priority: { type: "string", enum: ["high", "medium", "low"] }
-                },
-                required: ["id", "content", "status", "priority"]
-              }
-            }
+            agent: { type: "string", description: "Name of the agent (e.g. init, plan, execute)" },
+            args: { type: "object", description: "Arguments for the agent prompt", additionalProperties: true }
           },
-          required: ["project", "task_slug", "phase", "agent", "items"]
+          required: ["agent"]
         }
       }
     ];
+  }
+});
+
+// src/mcp/handlers/tools.ts
+import "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function registerToolHandlers(server) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = [
+      ...projectTools,
+      ...searchTools,
+      ...taskTools,
+      ...sessionTools,
+      ...agentTools
+    ];
     const projects = getExposedProjects();
     if (projects.length === 0) {
       tools.push({
@@ -4720,221 +5181,17 @@ function registerToolHandlers(server) {
     const { name, arguments: args } = request.params;
     logger.info(`Calling tool: ${name}`, args);
     try {
-      switch (name) {
-        case "resolve_path": {
-          const params = args;
-          const result = resolveProjectPaths(params.project, params.path);
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "search_knowledge": {
-          const params = args;
-          const result = await searchKnowledge(params.query, params.project, {
-            max_tokens: params.max_tokens,
-            min_score: params.min_score
-          });
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "search_code": {
-          const params = args;
-          const result = await searchCode(params.query, params.project, params.limit, {
-            max_tokens: params.max_tokens,
-            min_score: params.min_score
-          });
-          if (result.results.length === 0) {
-            return {
-              content: [{
-                type: "text",
-                text: "No code matches found. The code index may be empty or semantic search is not enabled.\nRun `index_knowledge` first to build the code index."
-              }]
-            };
-          }
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "find_related_files": {
-          const params = args;
-          const result = await findRelatedFiles2(params.file, params.project, {
-            includeImports: params.include_imports,
-            includeImportedBy: params.include_imported_by,
-            depth: params.depth
-          });
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "search_symbols": {
-          const params = args;
-          const result = await searchSymbols2(params.name, params.project, {
-            type: params.type,
-            fuzzy: params.fuzzy,
-            limit: params.limit
-          });
-          if (!result.success) {
-            return { content: [{ type: "text", text: result.message || "Search failed" }], isError: true };
-          }
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "get_file_summary": {
-          const params = args;
-          const result = await getFileSummary(params.file, params.project);
-          if (!result.success) {
-            return { content: [{ type: "text", text: result.message || "Failed to get file summary" }], isError: true };
-          }
-          return { content: [{ type: "text", text: JSON.stringify(result.summary, null, 2) }] };
-        }
-        case "get_context_bundle": {
-          const params = args;
-          const result = await getContextBundle(params.query, params.project, {
-            task_slug: params.task_slug,
-            max_tokens: params.max_tokens,
-            include: params.include
-          });
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "index_knowledge": {
-          const params = args;
-          const result = await indexKnowledge(params.project, params.force);
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "list_projects": {
-          const projects = getExposedProjects();
-          const list = projects.map((p) => ({ name: p.name, source: p.source, path: p.path }));
-          return {
-            content: [{
-              type: "text",
-              text: JSON.stringify(list, null, 2) + "\n\nTip: Use these project names for tools like `get_project_context` or `index_knowledge`."
-            }]
-          };
-        }
-        case "get_project_context": {
-          const context = getProjectContext(args.project);
-          if (!context) {
-            const projects = getExposedProjects().map((p) => p.name).join(", ");
-            const msg = `No project context found for "${args.project}".
-Available projects: ${projects}`;
-            logger.warn(msg);
-            return { content: [{ type: "text", text: msg }], isError: true };
-          }
-          return { content: [{ type: "text", text: context }] };
-        }
-        case "list_agents": {
-          const prompts = getAllPrompts();
-          return {
-            content: [{
-              type: "text",
-              text: JSON.stringify(prompts.map((p) => ({
-                name: p.name,
-                id: p.id,
-                description: p.description,
-                arguments: p.arguments
-              })), null, 2) + "\n\nTip: Retrieve the prompt for an agent using `get_agent_prompt` with its name or ID."
-            }]
-          };
-        }
-        case "get_agent_prompt": {
-          const params = args;
-          const agentName = params.agent;
-          const promptDef = getPromptDef(agentName);
-          if (!promptDef) {
-            const available = getAllPrompts().map((p) => `${p.name} (id: ${p.id})`).join(", ");
-            throw new Error(`Agent not found: ${agentName}. Available agents: ${available}`);
-          }
-          const renderArgs = params.args || {};
-          const stringArgs = {};
-          for (const [key, val] of Object.entries(renderArgs)) {
-            stringArgs[key] = String(val);
-          }
-          const { rendered } = renderPromptWithContext(promptDef.content, stringArgs);
-          const contextPreamble = getContextPreamble();
-          return { content: [{ type: "text", text: contextPreamble + rendered }] };
-        }
-        case "list_tasks": {
-          const params = args;
-          const tasks = getProjectTasks(params.project);
-          return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
-        }
-        case "get_task": {
-          const params = args;
-          const task = getTask(params.project, params.task_slug);
-          if (!task) {
-            return { content: [{ type: "text", text: `Task '${params.task_slug}' not found in project '${params.project}'.` }], isError: true };
-          }
-          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
-        }
-        case "create_task": {
-          const params = args;
-          const taskData = {
-            title: params.title || params.task_slug,
-            summary: params.summary || ""
-          };
-          const task = await createTask(params.project, params.task_slug, taskData);
-          return { content: [{ type: "text", text: `\u2713 Task '${params.task_slug}' created. meta.json saved.
-${JSON.stringify(task, null, 2)}` }] };
-        }
-        case "update_task": {
-          const params = args;
-          const task = await updateTask(params.project, params.task_slug, params.updates);
-          return { content: [{ type: "text", text: `\u2713 Task '${params.task_slug}' updated. meta.json saved.
-${JSON.stringify(task, null, 2)}` }] };
-        }
-        case "delete_task": {
-          const params = args;
-          const success = deleteTask(params.project, params.task_slug);
-          return { content: [{ type: "text", text: success ? `\u2713 Task '${params.task_slug}' deleted.` : `\u2717 Failed to delete '${params.task_slug}'.` }] };
-        }
-        case "start_session": {
-          const params = args;
-          const result = startSession(params.project, params.task_slug, params.agent, params.phase);
-          return { content: [{ type: "text", text: result.message }], isError: !result.success };
-        }
-        case "end_session": {
-          const params = args;
-          const result = endSession(params.project, params.task_slug);
-          return { content: [{ type: "text", text: result.message }], isError: !result.success };
-        }
-        case "update_agent_todos": {
-          const params = args;
-          const result = updateAgentTodos(params.project, params.task_slug, params.phase, params.agent, params.items);
-          return { content: [{ type: "text", text: result.message }], isError: !result.success };
-        }
-        case "prefetch_task_context": {
-          const params = args;
-          const result = await prefetchTaskContext(params.project, params.task_slug, {
-            max_tokens: params.max_tokens
-          });
-          if (!result.success) {
-            return { content: [{ type: "text", text: result.message || "Failed to prefetch task context" }], isError: true };
-          }
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "search_tasks": {
-          const params = args;
-          const results = searchTasks(params.project, {
-            keyword: params.keyword,
-            status: params.status,
-            agent: params.agent,
-            since: params.since,
-            limit: params.limit
-          });
-          return { content: [{ type: "text", text: JSON.stringify({ count: results.length, tasks: results }, null, 2) }] };
-        }
-        case "validate_phase": {
-          const params = args;
-          const result = validatePhase(params.project, params.task_slug, params.phase);
-          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        case "help_setup": {
-          const msg = `
-RRCE MCP Server is running, but no projects are configured/exposed.
-
-To fix this:
-1. Open a terminal.
-2. Run: npx rrce-workflow mcp configure
-3. Select the projects you want to expose to the AI.
-4. Restart the MCP server (or it may pick up changes automatically).
-`;
-          return { content: [{ type: "text", text: msg }] };
-        }
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
+      const projectResult = await handleProjectTool(name, args);
+      if (projectResult) return projectResult;
+      const searchResult = await handleSearchTool(name, args);
+      if (searchResult) return searchResult;
+      const taskResult = await handleTaskTool(name, args);
+      if (taskResult) return taskResult;
+      const sessionResult = await handleSessionTool(name, args);
+      if (sessionResult) return sessionResult;
+      const agentResult = await handleAgentTool(name, args);
+      if (agentResult) return agentResult;
+      throw new Error(`Unknown tool: ${name}`);
     } catch (error) {
       logger.error(`Tool execution failed: ${name}`, error);
       throw error;
@@ -4946,7 +5203,11 @@ var init_tools = __esm({
     "use strict";
     init_logger();
     init_resources2();
-    init_prompts2();
+    init_project();
+    init_search2();
+    init_task();
+    init_session();
+    init_agent();
   }
 });
 
@@ -5172,8 +5433,8 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs33 = await import("fs");
-  const path32 = await import("path");
+  const fs34 = await import("fs");
+  const path33 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -5187,8 +5448,8 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs33.existsSync(resolvedPath)) {
-      fs33.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs34.existsSync(resolvedPath)) {
+      fs34.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
@@ -5196,7 +5457,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:
-${path32.join(resolvedPath, "mcp.yaml")}`,
+${path33.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -5292,105 +5553,6 @@ var init_Header = __esm({
   }
 });
 
-// src/lib/drift-service.ts
-import * as fs23 from "fs";
-import * as path25 from "path";
-import * as crypto2 from "crypto";
-var DriftService;
-var init_drift_service = __esm({
-  "src/lib/drift-service.ts"() {
-    "use strict";
-    DriftService = class {
-      static CHECKSUM_FILENAME = ".rrce-checksums.json";
-      static calculateHash(filePath) {
-        const content = fs23.readFileSync(filePath);
-        return crypto2.createHash("md5").update(content).digest("hex");
-      }
-      static getManifestPath(projectPath) {
-        return path25.join(projectPath, this.CHECKSUM_FILENAME);
-      }
-      static loadManifest(projectPath) {
-        const manifestPath = this.getManifestPath(projectPath);
-        if (!fs23.existsSync(manifestPath)) {
-          return {};
-        }
-        try {
-          return JSON.parse(fs23.readFileSync(manifestPath, "utf8"));
-        } catch (e) {
-          return {};
-        }
-      }
-      static saveManifest(projectPath, manifest) {
-        const manifestPath = this.getManifestPath(projectPath);
-        fs23.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-      }
-      /**
-       * Generates a manifest for the current state of files in the project
-       */
-      static generateManifest(projectPath, files) {
-        const manifest = {};
-        for (const file of files) {
-          const fullPath = path25.join(projectPath, file);
-          if (fs23.existsSync(fullPath)) {
-            const stats = fs23.statSync(fullPath);
-            manifest[file] = {
-              hash: this.calculateHash(fullPath),
-              mtime: stats.mtimeMs
-            };
-          }
-        }
-        return manifest;
-      }
-      /**
-       * Compares current files against the manifest to detect modifications
-       */
-      static detectModifiedFiles(projectPath) {
-        const manifest = this.loadManifest(projectPath);
-        const modifiedFiles = [];
-        for (const [relPath, entry] of Object.entries(manifest)) {
-          const fullPath = path25.join(projectPath, relPath);
-          if (!fs23.existsSync(fullPath)) {
-            continue;
-          }
-          const stats = fs23.statSync(fullPath);
-          if (stats.mtimeMs === entry.mtime) {
-            continue;
-          }
-          const currentHash = this.calculateHash(fullPath);
-          if (currentHash !== entry.hash) {
-            modifiedFiles.push(relPath);
-          }
-        }
-        return modifiedFiles;
-      }
-      /**
-       * Full drift check: version + modifications
-       */
-      static checkDrift(projectPath, currentVersion, runningVersion) {
-        const modifiedFiles = this.detectModifiedFiles(projectPath);
-        let type = "none";
-        let hasDrift = false;
-        if (currentVersion !== runningVersion) {
-          hasDrift = true;
-          type = "version";
-        } else if (modifiedFiles.length > 0) {
-          hasDrift = true;
-          type = "modified";
-        }
-        return {
-          hasDrift,
-          type,
-          modifiedFiles,
-          version: {
-            current: currentVersion || "0.0.0",
-            running: runningVersion
-          }
-        };
-      }
-    };
-  }
-});
-
 // src/mcp/ui/ConfigContext.tsx
 var ConfigContext_exports = {};
 __export(ConfigContext_exports, {
@@ -5399,15 +5561,15 @@ __export(ConfigContext_exports, {
   useConfig: () => useConfig
 });
 import { createContext, useContext, useState, useCallback, useMemo, useEffect } from "react";
-import * as fs24 from "fs";
-import * as path26 from "path";
+import * as fs25 from "fs";
+import * as path27 from "path";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function getPackageVersion() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path26.join(path26.dirname(agentCoreDir), "package.json");
-    if (fs24.existsSync(packageJsonPath)) {
-      return JSON.parse(fs24.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path27.join(path27.dirname(agentCoreDir), "package.json");
+    if (fs25.existsSync(packageJsonPath)) {
+      return JSON.parse(fs25.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -5474,16 +5636,16 @@ var init_ConfigContext = __esm({
 });
 
 // src/mcp/ui/lib/tasks-fs.ts
-import * as fs25 from "fs";
-import * as path27 from "path";
+import * as fs26 from "fs";
+import * as path28 from "path";
 function readSession(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const sessionPath = path27.join(rrceData, "tasks", taskSlug, "session.json");
-  if (!fs25.existsSync(sessionPath)) {
+  const sessionPath = path28.join(rrceData, "tasks", taskSlug, "session.json");
+  if (!fs26.existsSync(sessionPath)) {
     return null;
   }
   try {
-    const raw = fs25.readFileSync(sessionPath, "utf-8");
+    const raw = fs26.readFileSync(sessionPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5496,12 +5658,12 @@ function isSessionStale(session, thresholdMs = SESSION_STALE_THRESHOLD_MS) {
 }
 function readAgentTodos(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const todosPath = path27.join(rrceData, "tasks", taskSlug, "agent-todos.json");
-  if (!fs25.existsSync(todosPath)) {
+  const todosPath = path28.join(rrceData, "tasks", taskSlug, "agent-todos.json");
+  if (!fs26.existsSync(todosPath)) {
     return null;
   }
   try {
-    const raw = fs25.readFileSync(todosPath, "utf-8");
+    const raw = fs26.readFileSync(todosPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5514,8 +5676,8 @@ function detectStorageModeFromConfig(workspaceRoot) {
     if (configPath.startsWith(rrceHome)) {
       return "global";
     }
-    if (fs25.existsSync(configPath)) {
-      const content = fs25.readFileSync(configPath, "utf-8");
+    if (fs26.existsSync(configPath)) {
+      const content = fs26.readFileSync(configPath, "utf-8");
       if (content.includes("mode: workspace")) return "workspace";
       if (content.includes("mode: global")) return "global";
     }
@@ -5525,7 +5687,7 @@ function detectStorageModeFromConfig(workspaceRoot) {
 }
 function getEffectiveGlobalBase() {
   const dummy = resolveDataPath("global", "__rrce_dummy__", "");
-  return path27.dirname(path27.dirname(dummy));
+  return path28.dirname(path28.dirname(dummy));
 }
 function getProjectRRCEData(project) {
   const workspaceRoot = project.sourcePath || project.path;
@@ -5534,19 +5696,19 @@ function getProjectRRCEData(project) {
 }
 function listProjectTasks(project) {
   const rrceData = getProjectRRCEData(project);
-  const tasksPath = path27.join(rrceData, "tasks");
-  if (!fs25.existsSync(tasksPath)) {
+  const tasksPath = path28.join(rrceData, "tasks");
+  if (!fs26.existsSync(tasksPath)) {
     return { projectName: project.name, tasksPath, tasks: [] };
   }
   const tasks = [];
   try {
-    const entries = fs25.readdirSync(tasksPath, { withFileTypes: true });
+    const entries = fs26.readdirSync(tasksPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const metaPath = path27.join(tasksPath, entry.name, "meta.json");
-      if (!fs25.existsSync(metaPath)) continue;
+      const metaPath = path28.join(tasksPath, entry.name, "meta.json");
+      if (!fs26.existsSync(metaPath)) continue;
       try {
-        const raw = fs25.readFileSync(metaPath, "utf-8");
+        const raw = fs26.readFileSync(metaPath, "utf-8");
         const meta = JSON.parse(raw);
         if (!meta.task_slug) meta.task_slug = entry.name;
         tasks.push(meta);
@@ -5565,18 +5727,18 @@ function listProjectTasks(project) {
 }
 function updateTaskStatus(project, taskSlug, status) {
   const rrceData = getProjectRRCEData(project);
-  const metaPath = path27.join(rrceData, "tasks", taskSlug, "meta.json");
-  if (!fs25.existsSync(metaPath)) {
+  const metaPath = path28.join(rrceData, "tasks", taskSlug, "meta.json");
+  if (!fs26.existsSync(metaPath)) {
     return { ok: false, error: `meta.json not found for task '${taskSlug}'` };
   }
   try {
-    const meta = JSON.parse(fs25.readFileSync(metaPath, "utf-8"));
+    const meta = JSON.parse(fs26.readFileSync(metaPath, "utf-8"));
     const next = {
       ...meta,
       status,
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs25.writeFileSync(metaPath, JSON.stringify(next, null, 2));
+    fs26.writeFileSync(metaPath, JSON.stringify(next, null, 2));
     return { ok: true, meta: next };
   } catch (e) {
     return { ok: false, error: String(e) };
@@ -5934,31 +6096,54 @@ 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 fs26 from "fs";
-import * as path28 from "path";
+// src/mcp/ui/components/ProjectViews.tsx
+import "react";
+import { Box as Box4, Text as Text4 } from "ink";
 import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var ProjectsHeader, ProjectsFooter;
+var init_ProjectViews = __esm({
+  "src/mcp/ui/components/ProjectViews.tsx"() {
+    "use strict";
+    ProjectsHeader = ({ autoExpose }) => /* @__PURE__ */ jsxs3(Box4, { paddingX: 1, justifyContent: "space-between", borderBottom: true, children: [
+      /* @__PURE__ */ jsxs3(Box4, { children: [
+        /* @__PURE__ */ jsx5(Text4, { bold: true, color: "cyan", children: "Projects" }),
+        /* @__PURE__ */ jsx5(Text4, { color: "dim", children: " \u2502 " }),
+        /* @__PURE__ */ jsxs3(Text4, { color: autoExpose ? "green" : "red", children: [
+          "Auto-expose: ",
+          autoExpose ? "ON" : "OFF"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx5(Text4, { color: "dim", children: "v0.3.14" })
+    ] });
+    ProjectsFooter = () => /* @__PURE__ */ jsxs3(Box4, { paddingX: 1, justifyContent: "space-between", borderTop: true, children: [
+      /* @__PURE__ */ jsx5(Text4, { color: "dim", children: "Space:Select  Enter:Save  a:Toggle Auto  u:Refresh Drift" }),
+      /* @__PURE__ */ jsx5(Text4, { color: "dim", children: "Use 'rrce-workflow wizard' for advanced config" })
+    ] });
+  }
+});
+
+// src/mcp/ui/lib/projects.ts
+import * as fs27 from "fs";
+import * as path29 from "path";
 function getIndexStats(project) {
   const stats = { knowledgeCount: 0, codeCount: 0, lastIndexed: null };
   try {
     const knowledgePath = project.knowledgePath;
     if (knowledgePath) {
-      const embPath = path28.join(knowledgePath, "embeddings.json");
-      const codeEmbPath = path28.join(knowledgePath, "code-embeddings.json");
-      if (fs26.existsSync(embPath)) {
-        const stat = fs26.statSync(embPath);
+      const embPath = path29.join(knowledgePath, "embeddings.json");
+      const codeEmbPath = path29.join(knowledgePath, "code-embeddings.json");
+      if (fs27.existsSync(embPath)) {
+        const stat = fs27.statSync(embPath);
         stats.lastIndexed = stat.mtime.toISOString();
         try {
-          const data = JSON.parse(fs26.readFileSync(embPath, "utf-8"));
+          const data = JSON.parse(fs27.readFileSync(embPath, "utf-8"));
           stats.knowledgeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
       }
-      if (fs26.existsSync(codeEmbPath)) {
+      if (fs27.existsSync(codeEmbPath)) {
         try {
-          const data = JSON.parse(fs26.readFileSync(codeEmbPath, "utf-8"));
+          const data = JSON.parse(fs27.readFileSync(codeEmbPath, "utf-8"));
           stats.codeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
@@ -5968,6 +6153,16 @@ function getIndexStats(project) {
   }
   return stats;
 }
+var init_projects2 = __esm({
+  "src/mcp/ui/lib/projects.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/ui/ProjectsView.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 var ProjectsView;
 var init_ProjectsView = __esm({
   "src/mcp/ui/ProjectsView.tsx"() {
@@ -5979,6 +6174,8 @@ var init_ProjectsView = __esm({
     init_config_utils();
     init_project_utils();
     init_ui_helpers();
+    init_ProjectViews();
+    init_projects2();
     ProjectsView = ({ config: initialConfig, projects: allProjects, onConfigChange, workspacePath }) => {
       const { driftReports, checkAllDrift } = useConfig();
       const [config, setConfig] = useState3(initialConfig);
@@ -6084,20 +6281,10 @@ ${statsRow}` : label;
         setConfig(newConfig);
         onConfigChange?.();
       };
-      return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
-        /* @__PURE__ */ jsxs3(Box4, { paddingX: 1, justifyContent: "space-between", borderBottom: true, children: [
-          /* @__PURE__ */ jsxs3(Box4, { children: [
-            /* @__PURE__ */ jsx5(Text4, { bold: true, color: "cyan", children: "Projects" }),
-            /* @__PURE__ */ jsx5(Text4, { color: "dim", children: " \u2502 " }),
-            /* @__PURE__ */ jsxs3(Text4, { color: config.defaults.includeNew ? "green" : "red", children: [
-              "Auto-expose: ",
-              config.defaults.includeNew ? "ON" : "OFF"
-            ] })
-          ] }),
-          /* @__PURE__ */ jsx5(Text4, { color: "dim", children: "v0.3.14" })
-        ] }),
-        /* @__PURE__ */ jsx5(Box4, { marginTop: 1, paddingX: 1, children: /* @__PURE__ */ jsx5(Text4, { color: "dim", children: "Manage which projects are exposed to the MCP server." }) }),
-        /* @__PURE__ */ jsx5(Box4, { marginTop: 1, paddingX: 1, flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx5(
+      return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx6(ProjectsHeader, { autoExpose: config.defaults.includeNew }),
+        /* @__PURE__ */ jsx6(Box5, { marginTop: 1, paddingX: 1, children: /* @__PURE__ */ jsx6(Text5, { color: "dim", children: "Manage which projects are exposed to the MCP server." }) }),
+        /* @__PURE__ */ jsx6(Box5, { marginTop: 1, paddingX: 1, flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx6(
           SimpleSelect,
           {
             message: "",
@@ -6112,111 +6299,7 @@ ${statsRow}` : label;
           },
           JSON.stringify(initialSelected) + config.defaults.includeNew + JSON.stringify(indexingStats)
         ) }),
-        /* @__PURE__ */ jsxs3(Box4, { paddingX: 1, justifyContent: "space-between", borderTop: true, children: [
-          /* @__PURE__ */ jsx5(Text4, { color: "dim", children: "Space:Select  Enter:Save  a:Toggle Auto  u:Refresh Drift" }),
-          /* @__PURE__ */ jsx5(Text4, { color: "dim", children: "Use 'rrce-workflow wizard' for advanced config" })
-        ] })
-      ] });
-    };
-  }
-});
-
-// src/mcp/ui/components/TaskRow.tsx
-import "react";
-import { Box as Box5, Text as Text5 } from "ink";
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
-function getActiveAgent(task) {
-  if (!task.agents) return null;
-  for (const [agent, info] of Object.entries(task.agents)) {
-    if (info?.status === "in_progress") {
-      return { agent, status: "in_progress" };
-    }
-  }
-  const agentOrder = ["documentation", "executor", "planning", "research"];
-  for (const agent of agentOrder) {
-    if (task.agents[agent]?.status === "complete") {
-      return { agent, status: "complete" };
-    }
-  }
-  return null;
-}
-var TaskRow;
-var init_TaskRow = __esm({
-  "src/mcp/ui/components/TaskRow.tsx"() {
-    "use strict";
-    init_ui_helpers();
-    init_project_utils();
-    TaskRow = ({
-      row,
-      isSelected,
-      isExpanded,
-      taskCount,
-      hasDrift,
-      isCurrentProject = false,
-      isLastTask = false
-    }) => {
-      if (row.kind === "project") {
-        const projectColor = isSelected ? "cyan" : isCurrentProject ? "yellow" : "white";
-        const isBold = isSelected || isCurrentProject;
-        return /* @__PURE__ */ jsxs4(Box5, { children: [
-          /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8 " : "  " }),
-          /* @__PURE__ */ jsxs4(Text5, { bold: isBold, color: projectColor, children: [
-            getFolderIcon(isExpanded),
-            " ",
-            formatProjectLabel(row.project)
-          ] }),
-          isCurrentProject && /* @__PURE__ */ jsx6(Text5, { color: "yellow", dimColor: true, children: " (current)" }),
-          hasDrift && /* @__PURE__ */ jsx6(Text5, { color: "magenta", children: " \u26A0" }),
-          /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
-            " ",
-            taskCount > 0 ? `[${taskCount}]` : ""
-          ] })
-        ] });
-      }
-      const task = row.task;
-      const taskLabel = task.title || task.task_slug;
-      const status = task.status || "";
-      const isPlaceholder = task.task_slug === "__none__";
-      const branch = getTreeBranch(isLastTask);
-      const activeAgent = getActiveAgent(task);
-      const progress = getChecklistProgress(task.checklist || []);
-      const relativeTime = task.updated_at ? formatRelativeTime(task.updated_at) : "";
-      if (isPlaceholder) {
-        return /* @__PURE__ */ jsxs4(Box5, { children: [
-          /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
-            "  ",
-            branch,
-            " "
-          ] }),
-          /* @__PURE__ */ jsx6(Text5, { color: "dim", italic: true, children: taskLabel })
-        ] });
-      }
-      return /* @__PURE__ */ jsxs4(Box5, { children: [
-        /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8 " : "  " }),
-        /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
-          branch,
-          " "
-        ] }),
-        /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "white", children: "\u{1F4CB} " }),
-        /* @__PURE__ */ jsx6(Box5, { flexGrow: 1, children: /* @__PURE__ */ jsx6(Text5, { bold: isSelected, color: isSelected ? "cyan" : "white", children: taskLabel.length > 25 ? taskLabel.substring(0, 22) + "..." : taskLabel }) }),
-        activeAgent && /* @__PURE__ */ jsxs4(Text5, { children: [
-          /* @__PURE__ */ jsx6(Text5, { color: "dim", children: " " }),
-          /* @__PURE__ */ jsx6(Text5, { children: getPhaseIcon(activeAgent.agent) }),
-          /* @__PURE__ */ jsx6(Text5, { color: activeAgent.status === "in_progress" ? "yellow" : "green", children: getAgentStatusIcon(activeAgent.status) })
-        ] }),
-        progress.total > 0 && /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
-          " ",
-          getProgressBar(progress.percentage, 6),
-          " ",
-          progress.completed,
-          "/",
-          progress.total
-        ] }),
-        relativeTime && relativeTime !== "\u2014" && /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
-          " ",
-          relativeTime
-        ] }),
-        !activeAgent && status && /* @__PURE__ */ jsx6(Text5, { color: getStatusColor(status), children: ` ${getStatusIcon(status)} ${status}` })
+        /* @__PURE__ */ jsx6(ProjectsFooter, {})
       ] });
     };
   }
@@ -6346,10 +6429,184 @@ var init_TaskDetails = __esm({
   }
 });
 
+// src/mcp/ui/components/TaskRow.tsx
+import "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function getActiveAgent(task) {
+  if (!task.agents) return null;
+  for (const [agent, info] of Object.entries(task.agents)) {
+    if (info?.status === "in_progress") {
+      return { agent, status: "in_progress" };
+    }
+  }
+  const agentOrder = ["documentation", "executor", "planning", "research"];
+  for (const agent of agentOrder) {
+    if (task.agents[agent]?.status === "complete") {
+      return { agent, status: "complete" };
+    }
+  }
+  return null;
+}
+var TaskRow;
+var init_TaskRow = __esm({
+  "src/mcp/ui/components/TaskRow.tsx"() {
+    "use strict";
+    init_ui_helpers();
+    init_project_utils();
+    TaskRow = ({
+      row,
+      isSelected,
+      isExpanded,
+      taskCount,
+      hasDrift,
+      isCurrentProject = false,
+      isLastTask = false
+    }) => {
+      if (row.kind === "project") {
+        const projectColor = isSelected ? "cyan" : isCurrentProject ? "yellow" : "white";
+        const isBold = isSelected || isCurrentProject;
+        return /* @__PURE__ */ jsxs6(Box7, { children: [
+          /* @__PURE__ */ jsx8(Text7, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8 " : "  " }),
+          /* @__PURE__ */ jsxs6(Text7, { bold: isBold, color: projectColor, children: [
+            getFolderIcon(isExpanded),
+            " ",
+            formatProjectLabel(row.project)
+          ] }),
+          isCurrentProject && /* @__PURE__ */ jsx8(Text7, { color: "yellow", dimColor: true, children: " (current)" }),
+          hasDrift && /* @__PURE__ */ jsx8(Text7, { color: "magenta", children: " \u26A0" }),
+          /* @__PURE__ */ jsxs6(Text7, { color: "dim", children: [
+            " ",
+            taskCount > 0 ? `[${taskCount}]` : ""
+          ] })
+        ] });
+      }
+      const task = row.task;
+      const taskLabel = task.title || task.task_slug;
+      const status = task.status || "";
+      const isPlaceholder = task.task_slug === "__none__";
+      const branch = getTreeBranch(isLastTask);
+      const activeAgent = getActiveAgent(task);
+      const progress = getChecklistProgress(task.checklist || []);
+      const relativeTime = task.updated_at ? formatRelativeTime(task.updated_at) : "";
+      if (isPlaceholder) {
+        return /* @__PURE__ */ jsxs6(Box7, { children: [
+          /* @__PURE__ */ jsxs6(Text7, { color: "dim", children: [
+            "  ",
+            branch,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx8(Text7, { color: "dim", italic: true, children: taskLabel })
+        ] });
+      }
+      return /* @__PURE__ */ jsxs6(Box7, { children: [
+        /* @__PURE__ */ jsx8(Text7, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8 " : "  " }),
+        /* @__PURE__ */ jsxs6(Text7, { color: "dim", children: [
+          branch,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx8(Text7, { color: isSelected ? "cyan" : "white", children: "\u{1F4CB} " }),
+        /* @__PURE__ */ jsx8(Box7, { flexGrow: 1, children: /* @__PURE__ */ jsx8(Text7, { bold: isSelected, color: isSelected ? "cyan" : "white", children: taskLabel.length > 25 ? taskLabel.substring(0, 22) + "..." : taskLabel }) }),
+        activeAgent && /* @__PURE__ */ jsxs6(Text7, { children: [
+          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: " " }),
+          /* @__PURE__ */ jsx8(Text7, { children: getPhaseIcon(activeAgent.agent) }),
+          /* @__PURE__ */ jsx8(Text7, { color: activeAgent.status === "in_progress" ? "yellow" : "green", children: getAgentStatusIcon(activeAgent.status) })
+        ] }),
+        progress.total > 0 && /* @__PURE__ */ jsxs6(Text7, { color: "dim", children: [
+          " ",
+          getProgressBar(progress.percentage, 6),
+          " ",
+          progress.completed,
+          "/",
+          progress.total
+        ] }),
+        relativeTime && relativeTime !== "\u2014" && /* @__PURE__ */ jsxs6(Text7, { color: "dim", children: [
+          " ",
+          relativeTime
+        ] }),
+        !activeAgent && status && /* @__PURE__ */ jsx8(Text7, { color: getStatusColor(status), children: ` ${getStatusIcon(status)} ${status}` })
+      ] });
+    };
+  }
+});
+
+// src/mcp/ui/components/TaskTree.tsx
+import "react";
+import { Box as Box8, Text as Text8 } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var TaskTree;
+var init_TaskTree = __esm({
+  "src/mcp/ui/components/TaskTree.tsx"() {
+    "use strict";
+    init_project_utils();
+    init_TaskRow();
+    TaskTree = ({
+      flattenedRows,
+      selectedIndex,
+      expanded,
+      taskCache,
+      driftReports
+    }) => {
+      return /* @__PURE__ */ jsx9(Box8, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: "dim", borderRight: true, paddingX: 1, children: flattenedRows.length === 0 ? /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx9(Text8, { color: "dim", children: "No projects detected." }),
+        /* @__PURE__ */ jsx9(Text8, { color: "dim", children: "Run the wizard to set up projects." })
+      ] }) : /* @__PURE__ */ jsx9(Box8, { flexDirection: "column", marginTop: 1, children: flattenedRows.map((row, idx) => {
+        const k = projectKey(row.project);
+        const isCurrentProject = row.kind === "project" ? row.isCurrentProject : false;
+        const isLastTask = row.kind === "task" ? row.isLastTask : false;
+        return /* @__PURE__ */ jsx9(
+          TaskRow,
+          {
+            row,
+            isSelected: idx === selectedIndex,
+            isExpanded: expanded.has(k),
+            taskCount: (taskCache[k] || []).length,
+            hasDrift: !!driftReports[row.project.path]?.hasDrift,
+            isCurrentProject,
+            isLastTask
+          },
+          row.kind === "project" ? `p:${k}` : `t:${k}:${row.task.task_slug}`
+        );
+      }) }) });
+    };
+  }
+});
+
+// src/mcp/ui/components/TaskViews.tsx
+import "react";
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var TasksHeader, TasksFooter;
+var init_TaskViews = __esm({
+  "src/mcp/ui/components/TaskViews.tsx"() {
+    "use strict";
+    TasksHeader = ({ projectCount, taskCount }) => /* @__PURE__ */ jsxs8(Box9, { paddingX: 1, justifyContent: "space-between", borderBottom: true, children: [
+      /* @__PURE__ */ jsxs8(Box9, { children: [
+        /* @__PURE__ */ jsx10(Text9, { bold: true, color: "cyan", children: "\u2699 Tasks" }),
+        /* @__PURE__ */ jsx10(Text9, { color: "dim", children: " \u2502 " }),
+        /* @__PURE__ */ jsxs8(Text9, { children: [
+          projectCount,
+          " projects"
+        ] }),
+        /* @__PURE__ */ jsx10(Text9, { color: "dim", children: " \u2022 " }),
+        /* @__PURE__ */ jsxs8(Text9, { children: [
+          taskCount,
+          " tasks"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx10(Text9, { color: "dim", children: "v0.3.14" })
+    ] });
+    TasksFooter = () => /* @__PURE__ */ jsxs8(Box9, { paddingX: 1, justifyContent: "space-between", borderTop: true, children: [
+      /* @__PURE__ */ jsx10(Text9, { color: "dim", children: "\u2191\u2193:Nav  Enter:Expand  s:Cycle Status  R:Refresh" }),
+      /* @__PURE__ */ jsx10(Text9, { color: "dim", children: "Press 'q' to exit" })
+    ] });
+  }
+});
+
 // src/mcp/ui/TasksView.tsx
 import { useEffect as useEffect4, useMemo as useMemo4, useState as useState4 } from "react";
-import { Box as Box7, Text as Text7, useInput as useInput3 } from "ink";
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Box as Box10, Text as Text10, useInput as useInput3 } from "ink";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
 function nextStatus(current) {
   const idx = STATUS_CYCLE.indexOf(current || "");
   if (idx === -1) return STATUS_CYCLE[0];
@@ -6362,8 +6619,9 @@ var init_TasksView = __esm({
     init_tasks_fs();
     init_ConfigContext();
     init_project_utils();
-    init_TaskRow();
     init_TaskDetails();
+    init_TaskTree();
+    init_TaskViews();
     STATUS_CYCLE = ["pending", "in_progress", "blocked", "complete"];
     TasksView = ({ projects: allProjects, workspacePath }) => {
       const { driftReports } = useConfig();
@@ -6484,55 +6742,26 @@ var init_TasksView = __esm({
       const selectedRow = flattenedRows[selectedIndex];
       const selectedTask = selectedRow?.kind === "task" && selectedRow.task.task_slug !== "__none__" ? selectedRow.task : null;
       const totalTasks = Object.values(taskCache).flat().length;
-      return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
-        /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, justifyContent: "space-between", borderBottom: true, children: [
-          /* @__PURE__ */ jsxs6(Box7, { children: [
-            /* @__PURE__ */ jsx8(Text7, { bold: true, color: "cyan", children: "\u2699 Tasks" }),
-            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: " \u2502 " }),
-            /* @__PURE__ */ jsxs6(Text7, { children: [
-              sortedProjects.length,
-              " projects"
-            ] }),
-            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: " \u2022 " }),
-            /* @__PURE__ */ jsxs6(Text7, { children: [
-              totalTasks,
-              " tasks"
-            ] })
-          ] }),
-          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "v0.3.14" })
-        ] }),
-        errorLine && /* @__PURE__ */ jsx8(Box7, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsxs6(Text7, { color: "red", children: [
+      return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx11(TasksHeader, { projectCount: sortedProjects.length, taskCount: totalTasks }),
+        errorLine && /* @__PURE__ */ jsx11(Box10, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsxs9(Text10, { color: "red", children: [
           "\u26A0 ",
           errorLine
         ] }) }),
-        /* @__PURE__ */ jsxs6(Box7, { flexDirection: "row", flexGrow: 1, children: [
-          /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", width: "50%", borderStyle: "single", borderColor: "dim", borderRight: true, paddingX: 1, children: flattenedRows.length === 0 ? /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
-            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "No projects detected." }),
-            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "Run the wizard to set up projects." })
-          ] }) : /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", marginTop: 1, children: flattenedRows.map((row, idx) => {
-            const k = projectKey(row.project);
-            const isCurrentProject = row.kind === "project" ? row.isCurrentProject : false;
-            const isLastTask = row.kind === "task" ? row.isLastTask : false;
-            return /* @__PURE__ */ jsx8(
-              TaskRow,
-              {
-                row,
-                isSelected: idx === selectedIndex,
-                isExpanded: expanded.has(k),
-                taskCount: (taskCache[k] || []).length,
-                hasDrift: !!driftReports[row.project.path]?.hasDrift,
-                isCurrentProject,
-                isLastTask
-              },
-              row.kind === "project" ? `p:${k}` : `t:${k}:${row.task.task_slug}`
-            );
-          }) }) }),
-          /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", width: "50%", paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx8(TaskDetails, { task: selectedTask }) })
+        /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", flexGrow: 1, children: [
+          /* @__PURE__ */ jsx11(
+            TaskTree,
+            {
+              flattenedRows,
+              selectedIndex,
+              expanded,
+              taskCache,
+              driftReports
+            }
+          ),
+          /* @__PURE__ */ jsx11(Box10, { flexDirection: "column", width: "50%", paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx11(TaskDetails, { task: selectedTask }) })
         ] }),
-        /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, justifyContent: "space-between", borderTop: true, children: [
-          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "\u2191\u2193:Nav  Enter:Expand  s:Cycle Status  R:Refresh" }),
-          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "Press 'q' to exit" })
-        ] })
+        /* @__PURE__ */ jsx11(TasksFooter, {})
       ] });
     };
   }
@@ -6540,8 +6769,8 @@ var init_TasksView = __esm({
 
 // src/mcp/ui/LogViewer.tsx
 import "react";
-import { Box as Box8, Text as Text8 } from "ink";
-import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Box as Box11, Text as Text11 } from "ink";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 var LogViewer;
 var init_LogViewer = __esm({
   "src/mcp/ui/LogViewer.tsx"() {
@@ -6551,16 +6780,16 @@ var init_LogViewer = __esm({
       const emptyLines = Math.max(0, height - visibleLogs.length);
       const padding = Array(emptyLines).fill("");
       const formatLog = (log) => {
-        if (log.includes("[RAG]")) return /* @__PURE__ */ jsx9(Text8, { color: "cyan", children: log });
-        if (log.includes("[ERROR]")) return /* @__PURE__ */ jsx9(Text8, { color: "red", children: log });
-        if (log.includes("[WARN]")) return /* @__PURE__ */ jsx9(Text8, { color: "yellow", children: log });
-        if (log.includes("[INFO]")) return /* @__PURE__ */ jsx9(Text8, { color: "green", children: log });
-        if (log.includes("Success")) return /* @__PURE__ */ jsx9(Text8, { color: "green", children: log });
-        return /* @__PURE__ */ jsx9(Text8, { children: log });
+        if (log.includes("[RAG]")) return /* @__PURE__ */ jsx12(Text11, { color: "cyan", children: log });
+        if (log.includes("[ERROR]")) return /* @__PURE__ */ jsx12(Text11, { color: "red", children: log });
+        if (log.includes("[WARN]")) return /* @__PURE__ */ jsx12(Text11, { color: "yellow", children: log });
+        if (log.includes("[INFO]")) return /* @__PURE__ */ jsx12(Text11, { color: "green", children: log });
+        if (log.includes("Success")) return /* @__PURE__ */ jsx12(Text11, { color: "green", children: log });
+        return /* @__PURE__ */ jsx12(Text11, { children: log });
       };
-      return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "white", paddingX: 1, height: height + 2, flexGrow: 1, children: [
-        padding.map((_, i) => /* @__PURE__ */ jsx9(Text8, { children: " " }, `empty-${i}`)),
-        visibleLogs.map((log, i) => /* @__PURE__ */ jsx9(Box8, { children: formatLog(log) }, `log-${i}`))
+      return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", borderStyle: "round", borderColor: "white", paddingX: 1, height: height + 2, flexGrow: 1, children: [
+        padding.map((_, i) => /* @__PURE__ */ jsx12(Text11, { children: " " }, `empty-${i}`)),
+        visibleLogs.map((log, i) => /* @__PURE__ */ jsx12(Box11, { children: formatLog(log) }, `log-${i}`))
       ] });
     };
   }
@@ -6568,28 +6797,28 @@ var init_LogViewer = __esm({
 
 // src/mcp/ui/StatusBoard.tsx
 import "react";
-import { Box as Box9, Text as Text9 } from "ink";
-import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+import { Box as Box12, Text as Text12 } from "ink";
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 var StatusBoard;
 var init_StatusBoard = __esm({
   "src/mcp/ui/StatusBoard.tsx"() {
     "use strict";
     StatusBoard = ({ exposedLabel, port, pid, running, hasDrift }) => {
-      return /* @__PURE__ */ jsx10(Box9, { borderStyle: "single", borderColor: "white", paddingX: 1, flexGrow: 1, children: /* @__PURE__ */ jsxs8(Text9, { children: [
-        running ? /* @__PURE__ */ jsx10(Text9, { color: "green", children: "\u25CF RUNNING" }) : /* @__PURE__ */ jsx10(Text9, { color: "red", children: "\u25CF STOPPED" }),
+      return /* @__PURE__ */ jsx13(Box12, { borderStyle: "single", borderColor: "white", paddingX: 1, flexGrow: 1, children: /* @__PURE__ */ jsxs11(Text12, { children: [
+        running ? /* @__PURE__ */ jsx13(Text12, { color: "green", children: "\u25CF RUNNING" }) : /* @__PURE__ */ jsx13(Text12, { color: "red", children: "\u25CF STOPPED" }),
         " ",
         "\u2502",
         " \u{1F4CB} ",
-        /* @__PURE__ */ jsx10(Text9, { color: "yellow", children: exposedLabel }),
+        /* @__PURE__ */ jsx13(Text12, { color: "yellow", children: exposedLabel }),
         " ",
         "\u2502",
         " Port: ",
-        /* @__PURE__ */ jsx10(Text9, { color: "green", children: port }),
+        /* @__PURE__ */ jsx13(Text12, { color: "green", children: port }),
         " ",
         "\u2502",
         " PID: ",
-        /* @__PURE__ */ jsx10(Text9, { color: "green", children: pid }),
-        hasDrift && /* @__PURE__ */ jsxs8(Text9, { color: "magenta", bold: true, children: [
+        /* @__PURE__ */ jsx13(Text12, { color: "green", children: pid }),
+        hasDrift && /* @__PURE__ */ jsxs11(Text12, { color: "magenta", bold: true, children: [
           " ",
           "\u2502",
           " \u2B06 UPDATE AVAILABLE"
@@ -6601,8 +6830,8 @@ var init_StatusBoard = __esm({
 
 // src/mcp/ui/components/TabBar.tsx
 import "react";
-import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
-import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Box as Box13, Text as Text13, useInput as useInput4 } from "ink";
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
 var TabBar;
 var init_TabBar = __esm({
   "src/mcp/ui/components/TabBar.tsx"() {
@@ -6632,11 +6861,11 @@ var init_TabBar = __esm({
           if (tab) onChange(tab.id);
         }
       });
-      return /* @__PURE__ */ jsxs9(Box10, { borderStyle: "single", paddingX: 1, borderColor: "gray", children: [
+      return /* @__PURE__ */ jsxs12(Box13, { borderStyle: "single", paddingX: 1, borderColor: "gray", children: [
         tabs.map((tab, index) => {
           const isActive = tab.id === activeTab;
-          return /* @__PURE__ */ jsx11(Box10, { marginRight: 2, children: /* @__PURE__ */ jsx11(
-            Text10,
+          return /* @__PURE__ */ jsx14(Box13, { marginRight: 2, children: /* @__PURE__ */ jsx14(
+            Text13,
             {
               color: isActive ? "cyan" : "white",
               bold: isActive,
@@ -6645,8 +6874,8 @@ var init_TabBar = __esm({
             }
           ) }, tab.id);
         }),
-        /* @__PURE__ */ jsx11(Box10, { flexGrow: 1 }),
-        /* @__PURE__ */ jsx11(Text10, { color: "dim", children: "Use \u25C4/\u25BA arrows to navigate" })
+        /* @__PURE__ */ jsx14(Box13, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx14(Text13, { color: "dim", children: "Use \u25C4/\u25BA arrows to navigate" })
       ] });
     };
   }
@@ -6658,9 +6887,9 @@ __export(App_exports, {
   App: () => App
 });
 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 fs27 from "fs";
-import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Box as Box14, useInput as useInput5, useApp } from "ink";
+import fs28 from "fs";
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
 var App;
 var init_App = __esm({
   "src/mcp/ui/App.tsx"() {
@@ -6732,18 +6961,18 @@ var init_App = __esm({
       useEffect6(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs27.existsSync(logPath)) {
-          const stats = fs27.statSync(logPath);
+        if (fs28.existsSync(logPath)) {
+          const stats = fs28.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs27.existsSync(logPath)) {
-            const stats = fs27.statSync(logPath);
+          if (fs28.existsSync(logPath)) {
+            const stats = fs28.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs27.openSync(logPath, "r");
-              fs27.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs27.closeSync(fd);
+              const fd = fs28.openSync(logPath, "r");
+              fs28.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs28.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -6780,10 +7009,10 @@ var init_App = __esm({
       const handleConfigChange = useCallback3(() => {
         refreshData();
       }, [refreshData]);
-      return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", padding: 0, height: termHeight, children: [
-        /* @__PURE__ */ jsx12(TabBar, { tabs, activeTab, onChange: setActiveTab }),
-        /* @__PURE__ */ jsxs10(Box11, { marginTop: 1, flexGrow: 1, children: [
-          activeTab === "overview" && /* @__PURE__ */ jsx12(
+      return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", padding: 0, height: termHeight, children: [
+        /* @__PURE__ */ jsx15(TabBar, { tabs, activeTab, onChange: setActiveTab }),
+        /* @__PURE__ */ jsxs13(Box14, { marginTop: 1, flexGrow: 1, children: [
+          activeTab === "overview" && /* @__PURE__ */ jsx15(
             Overview,
             {
               serverStatus: serverInfo,
@@ -6795,11 +7024,11 @@ var init_App = __esm({
               logs
             }
           ),
-          activeTab === "logs" && /* @__PURE__ */ jsx12(LogViewer, { logs, height: contentHeight }),
-          activeTab === "tasks" && /* @__PURE__ */ jsx12(TasksView, { projects, workspacePath }),
-          activeTab === "projects" && /* @__PURE__ */ jsx12(ProjectsView, { config, projects, onConfigChange: handleConfigChange, workspacePath })
+          activeTab === "logs" && /* @__PURE__ */ jsx15(LogViewer, { logs, height: contentHeight }),
+          activeTab === "tasks" && /* @__PURE__ */ jsx15(TasksView, { projects, workspacePath }),
+          activeTab === "projects" && /* @__PURE__ */ jsx15(ProjectsView, { config, projects, onConfigChange: handleConfigChange, workspacePath })
         ] }),
-        /* @__PURE__ */ jsx12(Box11, { marginTop: 0, children: /* @__PURE__ */ jsx12(
+        /* @__PURE__ */ jsx15(Box14, { marginTop: 0, children: /* @__PURE__ */ jsx15(
           StatusBoard,
           {
             exposedLabel: `${exposedProjects.length} / ${projects.length} projects`,
@@ -6817,7 +7046,7 @@ var init_App = __esm({
 // src/mcp/commands/start.ts
 import { confirm as confirm3, isCancel as isCancel5, text } from "@clack/prompts";
 async function handleStartServer() {
-  const React13 = await import("react");
+  const React16 = await import("react");
   const { render } = await import("ink");
   const { App: App2 } = await Promise.resolve().then(() => (init_App(), App_exports));
   const { ConfigProvider: ConfigProvider2 } = await Promise.resolve().then(() => (init_ConfigContext(), ConfigContext_exports));
@@ -6860,10 +7089,10 @@ async function handleStartServer() {
   }
   process.stdin.resume();
   const app = render(
-    React13.createElement(
+    React16.createElement(
       ConfigProvider2,
       null,
-      React13.createElement(App2, {
+      React16.createElement(App2, {
         initialPort,
         onExit: () => {
         }
@@ -6968,15 +7197,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 fs28 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path30 from "path";
 import { stringify as stringify2, parse } from "yaml";
 function backupFile(filePath) {
-  if (!fs28.existsSync(filePath)) return null;
+  if (!fs29.existsSync(filePath)) return null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
   const backupPath = `${filePath}.${timestamp}.bak`;
   try {
-    fs28.copyFileSync(filePath, backupPath);
+    fs29.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (e) {
     console.error(`Failed to backup ${filePath}:`, e);
@@ -6986,9 +7215,9 @@ function backupFile(filePath) {
 function getPackageVersion2() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path29.join(path29.dirname(agentCoreDir), "package.json");
-    if (fs28.existsSync(packageJsonPath)) {
-      return JSON.parse(fs28.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path30.join(path30.dirname(agentCoreDir), "package.json");
+    if (fs29.existsSync(packageJsonPath)) {
+      return JSON.parse(fs29.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -7003,9 +7232,9 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
   const configFilePath = getConfigPath(workspacePath);
   let currentSyncedVersion;
-  if (fs28.existsSync(configFilePath)) {
+  if (fs29.existsSync(configFilePath)) {
     try {
-      const content = fs28.readFileSync(configFilePath, "utf-8");
+      const content = fs29.readFileSync(configFilePath, "utf-8");
       const config = parse(content);
       currentSyncedVersion = config.last_synced_version;
     } catch (e) {
@@ -7013,8 +7242,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   }
   const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
   const ideTargets = [];
-  if (fs28.existsSync(configFilePath)) {
-    const configContent = fs28.readFileSync(configFilePath, "utf-8");
+  if (fs29.existsSync(configFilePath)) {
+    const configContent = fs29.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");
@@ -7023,14 +7252,14 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     const dirs = ["templates", "prompts", "docs"];
     const updatedFiles = [];
     for (const dir of dirs) {
-      const srcDir = path29.join(agentCoreDir, dir);
-      if (!fs28.existsSync(srcDir)) continue;
+      const srcDir = path30.join(agentCoreDir, dir);
+      if (!fs29.existsSync(srcDir)) continue;
       const syncFiles = (src, rel) => {
-        const entries = fs28.readdirSync(src, { withFileTypes: true });
+        const entries = fs29.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const entrySrc = path29.join(src, entry.name);
-          const entryRel = path29.join(rel, entry.name);
-          const entryDest = path29.join(dataPath, entryRel);
+          const entrySrc = path30.join(src, entry.name);
+          const entryRel = path30.join(rel, entry.name);
+          const entryDest = path30.join(dataPath, entryRel);
           if (entry.isDirectory()) {
             ensureDir(entryDest);
             syncFiles(entrySrc, entryRel);
@@ -7038,8 +7267,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
             if (driftReport.modifiedFiles.includes(entryRel)) {
               backupFile(entryDest);
             }
-            ensureDir(path29.dirname(entryDest));
-            fs28.copyFileSync(entrySrc, entryDest);
+            ensureDir(path30.dirname(entryDest));
+            fs29.copyFileSync(entrySrc, entryDest);
             updatedFiles.push(entryRel);
           }
         }
@@ -7050,12 +7279,12 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     DriftService.saveManifest(dataPath, manifest);
   }
   const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-  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");
+  ensureDir(path30.join(rrceHome, "templates"));
+  ensureDir(path30.join(rrceHome, "docs"));
+  copyDirRecursive(path30.join(agentCoreDir, "templates"), path30.join(rrceHome, "templates"));
+  copyDirRecursive(path30.join(agentCoreDir, "docs"), path30.join(rrceHome, "docs"));
+  if (fs29.existsSync(configFilePath)) {
+    const configContent = fs29.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -7077,21 +7306,21 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     try {
       const yaml = parse(configContent);
       yaml.last_synced_version = runningVersion;
-      fs28.writeFileSync(configFilePath, stringify2(yaml));
+      fs29.writeFileSync(configFilePath, stringify2(yaml));
     } catch (e) {
       console.error("Failed to update config.yaml version:", e);
     }
   }
-  const mcpPath = path29.join(rrceHome, "mcp.yaml");
-  if (fs28.existsSync(mcpPath)) {
+  const mcpPath = path30.join(rrceHome, "mcp.yaml");
+  if (fs29.existsSync(mcpPath)) {
     try {
-      const content = fs28.readFileSync(mcpPath, "utf-8");
+      const content = fs29.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;
-          fs28.writeFileSync(mcpPath, stringify2(yaml));
+          fs29.writeFileSync(mcpPath, stringify2(yaml));
         }
       }
     } catch (e) {
@@ -7127,9 +7356,9 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     const configFilePath = getConfigPath(workspacePath);
     let currentSyncedVersion;
-    if (fs28.existsSync(configFilePath)) {
+    if (fs29.existsSync(configFilePath)) {
       try {
-        const content = fs28.readFileSync(configFilePath, "utf-8");
+        const content = fs29.readFileSync(configFilePath, "utf-8");
         const config = parse(content);
         currentSyncedVersion = config.last_synced_version;
       } catch (e) {
@@ -7153,8 +7382,8 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
       `  \u2022 docs/ (documentation)`
     ];
     const ideTargets = [];
-    if (fs28.existsSync(configFilePath)) {
-      const configContent = fs28.readFileSync(configFilePath, "utf-8");
+    if (fs29.existsSync(configFilePath)) {
+      const configContent = fs29.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");
@@ -7183,14 +7412,14 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       const dirs = ["templates", "prompts", "docs"];
       const updatedFiles = [];
       for (const dir of dirs) {
-        const srcDir = path29.join(agentCoreDir, dir);
-        if (!fs28.existsSync(srcDir)) continue;
+        const srcDir = path30.join(agentCoreDir, dir);
+        if (!fs29.existsSync(srcDir)) continue;
         const syncFiles = (src, rel) => {
-          const entries = fs28.readdirSync(src, { withFileTypes: true });
+          const entries = fs29.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
-            const entrySrc = path29.join(src, entry.name);
-            const entryRel = path29.join(rel, entry.name);
-            const entryDest = path29.join(dataPath, entryRel);
+            const entrySrc = path30.join(src, entry.name);
+            const entryRel = path30.join(rel, entry.name);
+            const entryDest = path30.join(dataPath, entryRel);
             if (entry.isDirectory()) {
               ensureDir(entryDest);
               syncFiles(entrySrc, entryRel);
@@ -7198,8 +7427,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
               if (driftReport.modifiedFiles.includes(entryRel)) {
                 backupFile(entryDest);
               }
-              ensureDir(path29.dirname(entryDest));
-              fs28.copyFileSync(entrySrc, entryDest);
+              ensureDir(path30.dirname(entryDest));
+              fs29.copyFileSync(entrySrc, entryDest);
               updatedFiles.push(entryRel);
             }
           }
@@ -7210,12 +7439,12 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       DriftService.saveManifest(dataPath, manifest);
     }
     const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-    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");
+    ensureDir(path30.join(rrceHome, "templates"));
+    ensureDir(path30.join(rrceHome, "docs"));
+    copyDirRecursive(path30.join(agentCoreDir, "templates"), path30.join(rrceHome, "templates"));
+    copyDirRecursive(path30.join(agentCoreDir, "docs"), path30.join(rrceHome, "docs"));
+    if (fs29.existsSync(configFilePath)) {
+      const configContent = fs29.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
@@ -7237,21 +7466,21 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       try {
         const yaml = parse(configContent);
         yaml.last_synced_version = runningVersion;
-        fs28.writeFileSync(configFilePath, stringify2(yaml));
+        fs29.writeFileSync(configFilePath, stringify2(yaml));
       } catch (e) {
         console.error("Failed to update config.yaml version:", e);
       }
     }
-    const mcpPath = path29.join(rrceHome, "mcp.yaml");
-    if (fs28.existsSync(mcpPath)) {
+    const mcpPath = path30.join(rrceHome, "mcp.yaml");
+    if (fs29.existsSync(mcpPath)) {
       try {
-        const content = fs28.readFileSync(mcpPath, "utf-8");
+        const content = fs29.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;
-            fs28.writeFileSync(mcpPath, stringify2(yaml));
+            fs29.writeFileSync(mcpPath, stringify2(yaml));
           }
         }
       } catch (e) {
@@ -7286,8 +7515,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path29.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path29.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path30.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path30.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -7310,8 +7539,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 fs32 from "fs";
-import * as path31 from "path";
+import * as fs33 from "fs";
+import * as path32 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/lib/git.ts
@@ -7453,22 +7682,22 @@ async function promptConfirmation() {
 init_paths();
 init_prompts();
 init_utils();
-import * as fs10 from "fs";
-import * as path12 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 import pc4 from "picocolors";
 import { note as note2 } from "@clack/prompts";
 
 // src/commands/wizard/vscode.ts
 init_paths();
 init_detection();
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
-  const workspaceFilePath = path9.join(workspacePath, `${workspaceName}.code-workspace`);
+  const workspaceFilePath = path10.join(workspacePath, `${workspaceName}.code-workspace`);
   let workspace;
-  if (fs8.existsSync(workspaceFilePath)) {
+  if (fs9.existsSync(workspaceFilePath)) {
     try {
-      const content = fs8.readFileSync(workspaceFilePath, "utf-8");
+      const content = fs9.readFileSync(workspaceFilePath, "utf-8");
       workspace = JSON.parse(content);
     } catch {
       workspace = { folders: [], settings: {} };
@@ -7501,7 +7730,7 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
     for (const project of projects) {
       const sourceLabel = project.source === "global" ? "global" : "local";
       const folderPath = project.dataPath;
-      if (fs8.existsSync(folderPath)) {
+      if (fs9.existsSync(folderPath)) {
         referenceFolderPaths.push(folderPath);
         workspace.folders.push({
           path: folderPath,
@@ -7513,8 +7742,8 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
     const projectNames = linkedProjects;
     const rrceHome = customGlobalPath || getRRCEHome();
     for (const projectName of projectNames) {
-      const folderPath = path9.join(rrceHome, "workspaces", projectName);
-      if (fs8.existsSync(folderPath)) {
+      const folderPath = path10.join(rrceHome, "workspaces", projectName);
+      if (fs9.existsSync(folderPath)) {
         referenceFolderPaths.push(folderPath);
         workspace.folders.push({
           path: folderPath,
@@ -7540,23 +7769,23 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
       ...readonlyPatterns
     };
   }
-  fs8.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
+  fs9.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
 
 // src/commands/wizard/setup-actions.ts
 init_install();
 function detectExistingProject(workspacePath, workspaceName, globalPath) {
   const rrceHome = globalPath || getDefaultRRCEHome2();
-  const globalConfigPath = path12.join(rrceHome, "workspaces", workspaceName, "config.yaml");
-  const workspaceConfigPath = path12.join(workspacePath, ".rrce-workflow", "config.yaml");
+  const globalConfigPath = path13.join(rrceHome, "workspaces", workspaceName, "config.yaml");
+  const workspaceConfigPath = path13.join(workspacePath, ".rrce-workflow", "config.yaml");
   const hasOpenCodeAgents = checkForRRCEAgents();
-  if (fs10.existsSync(globalConfigPath)) {
+  if (fs11.existsSync(globalConfigPath)) {
     return {
       isExisting: true,
       currentMode: "global",
       configPath: globalConfigPath
     };
-  } else if (fs10.existsSync(workspaceConfigPath)) {
+  } else if (fs11.existsSync(workspaceConfigPath)) {
     return {
       isExisting: true,
       currentMode: "workspace",
@@ -7576,9 +7805,9 @@ function detectExistingProject(workspacePath, workspaceName, globalPath) {
   };
 }
 function checkForRRCEAgents() {
-  if (!fs10.existsSync(OPENCODE_CONFIG)) return false;
+  if (!fs11.existsSync(OPENCODE_CONFIG)) return false;
   try {
-    const config = JSON.parse(fs10.readFileSync(OPENCODE_CONFIG, "utf8"));
+    const config = JSON.parse(fs11.readFileSync(OPENCODE_CONFIG, "utf8"));
     const agentKeys = Object.keys(config.agent || config.agents || {});
     return agentKeys.some((key) => key.startsWith("rrce_"));
   } catch {
@@ -7588,23 +7817,23 @@ function checkForRRCEAgents() {
 function createDirectoryStructure(dataPaths) {
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path12.join(dataPath, "knowledge"));
-    ensureDir(path12.join(dataPath, "refs"));
-    ensureDir(path12.join(dataPath, "tasks"));
-    ensureDir(path12.join(dataPath, "templates"));
+    ensureDir(path13.join(dataPath, "knowledge"));
+    ensureDir(path13.join(dataPath, "refs"));
+    ensureDir(path13.join(dataPath, "tasks"));
+    ensureDir(path13.join(dataPath, "templates"));
   }
 }
 async function installAgentPrompts(config, workspacePath, dataPaths) {
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path12.join(agentCoreDir, "templates"), "templates", dataPaths);
-  copyDirToAllStoragePaths(path12.join(agentCoreDir, "prompts"), "prompts", dataPaths);
-  copyDirToAllStoragePaths(path12.join(agentCoreDir, "docs"), "docs", dataPaths);
+  copyDirToAllStoragePaths(path13.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path13.join(agentCoreDir, "prompts"), "prompts", dataPaths);
+  copyDirToAllStoragePaths(path13.join(agentCoreDir, "docs"), "docs", dataPaths);
   const rrceHome = config.globalPath || getDefaultRRCEHome2();
-  ensureDir(path12.join(rrceHome, "templates"));
-  ensureDir(path12.join(rrceHome, "docs"));
-  copyDirRecursive(path12.join(agentCoreDir, "templates"), path12.join(rrceHome, "templates"));
-  copyDirRecursive(path12.join(agentCoreDir, "docs"), path12.join(rrceHome, "docs"));
+  ensureDir(path13.join(rrceHome, "templates"));
+  ensureDir(path13.join(rrceHome, "docs"));
+  copyDirRecursive(path13.join(agentCoreDir, "templates"), path13.join(rrceHome, "templates"));
+  copyDirRecursive(path13.join(agentCoreDir, "docs"), path13.join(rrceHome, "docs"));
   const needsIDEPrompts = config.storageMode === "workspace" && (config.tools.includes("copilot") || config.tools.includes("antigravity")) || config.tools.includes("opencode");
   if (needsIDEPrompts) {
     const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
@@ -7633,11 +7862,11 @@ function createWorkspaceConfig(config, workspacePath, workspaceName) {
   let configPath;
   if (config.storageMode === "global") {
     const rrceHome = config.globalPath || getDefaultRRCEHome2();
-    configPath = path12.join(rrceHome, "workspaces", workspaceName, "config.yaml");
+    configPath = path13.join(rrceHome, "workspaces", workspaceName, "config.yaml");
   } else {
-    configPath = path12.join(workspacePath, ".rrce-workflow", "config.yaml");
+    configPath = path13.join(workspacePath, ".rrce-workflow", "config.yaml");
   }
-  ensureDir(path12.dirname(configPath));
+  ensureDir(path13.dirname(configPath));
   let content = `# RRCE-Workflow Configuration
 version: 1
 
@@ -7673,7 +7902,7 @@ linked_projects:
 `;
     });
   }
-  fs10.writeFileSync(configPath, content);
+  fs11.writeFileSync(configPath, content);
 }
 async function registerWithMCP(config, workspacePath, workspaceName) {
   if (!config.exposeToMCP) return;
@@ -7700,8 +7929,8 @@ You can configure MCP later: ${pc4.cyan("npx rrce-workflow mcp")}`,
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path12.join(customGlobalPath || getDefaultRRCEHome2(), "workspaces", workspaceName);
-  const workspacePath = path12.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path13.join(customGlobalPath || getDefaultRRCEHome2(), "workspaces", workspaceName);
+  const workspacePath = path13.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -7988,7 +8217,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 fs29 from "fs";
+import * as fs30 from "fs";
 init_detection();
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
@@ -8027,7 +8256,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs29.readFileSync(configFilePath, "utf-8");
+  let configContent = fs30.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -8054,7 +8283,7 @@ linked_projects:
 `;
     });
   }
-  fs29.writeFileSync(configFilePath, configContent);
+  fs30.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -8090,15 +8319,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 fs30 from "fs";
-import * as path30 from "path";
+import * as fs31 from "fs";
+import * as path31 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path30.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path31.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs30.existsSync(path30.join(localPath, dir))
+    (dir) => fs31.existsSync(path31.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro5(pc11.yellow("No data found in workspace storage to sync."));
@@ -8124,8 +8353,8 @@ Destination: ${pc11.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path30.join(localPath, dir);
-      const destDir = path30.join(globalPath, dir);
+      const srcDir = path31.join(localPath, dir);
+      const destDir = path31.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -8153,7 +8382,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 fs31 from "fs";
+import * as fs32 from "fs";
 init_detection();
 init_config();
 async function runDeleteGlobalProjectFlow(availableProjects) {
@@ -8197,8 +8426,8 @@ Are you sure?`,
     for (const projectName of projectsToDelete) {
       const project = globalProjects.find((p) => p.name === projectName);
       if (!project) continue;
-      if (fs31.existsSync(project.dataPath)) {
-        fs31.rmSync(project.dataPath, { recursive: true, force: true });
+      if (fs32.existsSync(project.dataPath)) {
+        fs32.rmSync(project.dataPath, { recursive: true, force: true });
       }
       const newConfig = removeProjectConfig(mcpConfig, projectName);
       configChanged = true;
@@ -8220,9 +8449,9 @@ init_config();
 function getPackageVersion3() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path31.join(path31.dirname(agentCoreDir), "package.json");
-    if (fs32.existsSync(packageJsonPath)) {
-      return JSON.parse(fs32.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path32.join(path32.dirname(agentCoreDir), "package.json");
+    if (fs33.existsSync(packageJsonPath)) {
+      return JSON.parse(fs33.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -8230,9 +8459,9 @@ function getPackageVersion3() {
 }
 function getLastSyncedVersion(workspacePath, workspaceName) {
   const configFilePath = getConfigPath(workspacePath);
-  if (fs32.existsSync(configFilePath)) {
+  if (fs33.existsSync(configFilePath)) {
     try {
-      const content = fs32.readFileSync(configFilePath, "utf-8");
+      const content = fs33.readFileSync(configFilePath, "utf-8");
       const config = parse2(content);
       if (config.last_synced_version) {
         return config.last_synced_version;
@@ -8241,10 +8470,10 @@ function getLastSyncedVersion(workspacePath, workspaceName) {
     }
   }
   const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
-  const mcpPath = path31.join(rrceHome, "mcp.yaml");
-  if (fs32.existsSync(mcpPath)) {
+  const mcpPath = path32.join(rrceHome, "mcp.yaml");
+  if (fs33.existsSync(mcpPath)) {
     try {
-      const content = fs32.readFileSync(mcpPath, "utf-8");
+      const content = fs33.readFileSync(mcpPath, "utf-8");
       const config = parse2(content);
       const project = config.projects?.find((p) => p.name === workspaceName);
       if (project?.last_synced_version) {
@@ -8314,11 +8543,11 @@ Workspace: ${pc13.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  let isAlreadyConfigured = fs32.existsSync(configFilePath);
+  let isAlreadyConfigured = fs33.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs32.readFileSync(configFilePath, "utf-8");
+      const configContent = fs33.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
@@ -8335,7 +8564,7 @@ Workspace: ${pc13.bold(workspaceName)}`,
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs32.existsSync(localDataPath);
+  const hasLocalData = fs33.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const continueToMenu = await checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode);
     if (!continueToMenu) {