rrce-workflow 0.3.30 → 0.3.32

package/README.md

@@ -11,8 +11,10 @@ RRCE-Workflow transforms your AI coding assistant (GitHub Copilot, OpenCode, Cla
 - **Global Knowledge Base**: Centralized context management across all your projects (`~/.rrce-workflow/`).
 - **MCP Hub**: A Model Context Protocol server exposing tools, resources, and prompts to any MCP-compatible client.
 - **Semantic Search (RAG)**: Local, privacy-first vector indexing powered by `@xenova/transformers` for deep codebase understanding.
-- **Structured Agent Pipelines**: 5 specialized agents (Init, Design, Develop, Docs, Sync, Doctor) for end-to-end development workflows.
-- **Task Management**: Built-in CRUD operations for tracking high-level tasks via MCP tools.
+- **4-Phase Workflow**: Init → Design (research+planning merged) → Develop → Document for streamlined development.
+- **Slash Commands**: In-context execution (`/rrce_*`) with ~60% token efficiency over subagent delegation.
+- **Task Management**: Built-in CRUD operations for tracking high-level tasks via MCP tools, including knowledge extraction and cleanup.
+- **Agent Session Tracking**: Real-time task progress visualization in MCP TUI with OpenCode Todo sidebar sync.
 
 ---
 
@@ -71,14 +73,19 @@ RRCE-Workflow uses the [Model Context Protocol](https://modelcontextprotocol.io/
 | `search_knowledge` | Semantic search across project knowledge bases |
 | `search_code` | Semantic search across code files (snippets + line numbers + context) |
 | `find_related_files` | Find imports/imported-by relationships for a file |
-| `index_knowledge` | Start (or query) the semantic indexing job for a project |
-| `list_agents` | List available RRCE agents and their arguments |
-| `get_agent_prompt` | Get the system prompt for a specific agent (with context injection) |
-| `list_tasks` | List all tasks for a project |
-| `get_task` | Get details of a task |
-| `create_task` | Create a task |
-| `update_task` | Update a task (`meta.json`) |
+| `index_knowledge` | Start (or query) the semantic indexing job for a project. Supports `force` (re-hash) and `clean` (wipe/rebuild) parameters |
+| `list_tasks` | List all tasks for a project (supports filtering by status, keyword, date) |
+| `get_task` | Get details of a task (including phase status, checklist, metadata) |
+| `create_task` | Create a new task in the project |
+| `update_task` | Update task metadata (`meta.json`) |
 | `delete_task` | Delete a task |
+| `search_tasks` | Search tasks by keyword, status, agent phase, or date |
+| `validate_phase` | Check if a task phase has all prerequisites complete |
+| `cleanup_task` | Extract valuable knowledge from tasks and delete artifacts. Supports single, bulk, or --all mode |
+| `start_session` | Start an agent session for active task tracking (TUI visibility) |
+| `end_session` | End an agent session before completion signal |
+| `update_agent_todos` | Update agent todo list for granular work tracking (TUI display) |
+| `get_agent_prompt` | Get the system prompt for a specific agent or slash command |
 
 ### Connecting Your IDE
 
@@ -103,14 +110,15 @@ RRCE-Workflow integrates with OpenCode both as an MCP server and by providing a
     ```
 
 2.  **Install Agents**: Run `npx rrce-workflow` and select **OpenCode** as a tool. This generates:
-    - **Primary Agent (`rrce`)**: Orchestrates the complete workflow lifecycle (tab-switchable)
-    - **Subagents** (`@rrce_*`): Specialized agents for each phase (expert mode)
+    - **Primary Agent (`rrce`)**: Phase Coordinator orchestrating the complete workflow (tab-switchable)
+    - **Subagents** (`@rrce_*`): Specialized agents for isolated execution (expert mode)
     - **Auto-configuration**: Hides OpenCode's native plan agent to avoid confusion
 
 3.  **Usage**:
     - Press `Tab` to cycle to the RRCE agent for structured workflows
+    - Use slash commands (`/rrce_init`, `/rrce_design`, `/rrce_develop`) for in-context execution (60% more efficient)
+    - Direct subagent access via `@rrce_init`, `@rrce_design`, etc. for isolated execution
     - Build agent can automatically delegate to RRCE for complex tasks
-    - Direct subagent access via `@rrce_init`, `@rrce_research`, etc.
 
 See [OpenCode Guide](docs/opencode-guide.md) for detailed usage instructions.
 
@@ -179,45 +187,65 @@ Stores everything in a `.rrce-workflow` folder inside your project root.
 
 ---
 
-## The Agent Pipeline
+## 4-Phase Workflow
 
-RRCE provides two ways to work with agents, depending on your workflow needs:
+RRCE uses a streamlined 4-phase pipeline for end-to-end development:
 
-### Primary Orchestrator (Recommended for OpenCode)
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  1. Init     →  2. Design     →  3. Develop    →  4. Document  │
+│  /rrce_init     /rrce_design     /rrce_develop    /rrce_docs   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+| Phase | Slash Command | Purpose | Prerequisite |
+|-------|---------------|---------|--------------|
+| **Init** | `/rrce_init` | Project setup, context extraction, semantic indexing | None |
+| **Design** | `/rrce_design task-slug "request"` | Research + Planning (merged for efficiency) | Init complete |
+| **Develop** | `/rrce_develop task-slug` | Code implementation based on approved plan | Design complete |
+| **Document** | `/rrce_docs task-slug` | Generate/update documentation | Develop complete |
 
-The **RRCE Orchestrator** is a primary agent that manages the complete workflow lifecycle:
+### Slash Commands (In-Context Execution)
 
-- **Access**: Press `Tab` in OpenCode to cycle to the RRCE agent
-- **Purpose**: Automatically coordinate research → planning → execution → documentation
-- **Delegation**: Build agent can delegate to RRCE for complex tasks
-- **Benefits**: Results flow back to calling agents, preventing hallucination
+The primary interaction model is **in-context slash commands** (`/rrce_*`), which achieve a **60% token reduction** compared to subagent delegation.
 
-### Specialized Subagents
+| Command | Arguments | Purpose |
+|---------|-----------|---------|
+| `/rrce_init` | `[project-name]` | Initialize project context and semantic index |
+| `/rrce_design` | `task-slug "request"` | Research and plan in single session |
+| `/rrce_develop` | `task-slug` | Execute code implementation |
+| `/rrce_docs` | `doc-type [task-slug]` | Generate documentation |
+| `/rrce_cleanup` | `task-slug` \| `--all` | Extract knowledge and delete tasks |
+| `/rrce_sync` | `[scope]` | Sync knowledge base with codebase |
+| `/rrce_doctor` | `[focus-area]` | Analyze codebase health |
 
-For expert control, invoke subagents directly via your AI assistant or MCP tools:
+### Subagents (Isolated Execution)
+
+For fully autonomous, non-interactive execution, use subagents via `@mentions`:
 
 | Agent | Invoke With | Purpose | Key Arguments |
 |-------|-------------|---------|---------------|
-| **Init** | `@rrce_init` | Analyze codebase, establish project context and semantic index | `PROJECT_NAME` (optional) |
-| **Research** | `@rrce_research_discussion` | Interactive requirements clarification through dialogue | `TASK_SLUG`, `REQUEST` |
-| **Planning** | `@rrce_planning_discussion` | Transform research into actionable execution plan | `TASK_SLUG` |
-| **Executor** | `@rrce_executor` | Implement the plan - the ONLY agent authorized to modify code | `TASK_SLUG`, `BRANCH` |
-| **Docs** | `@rrce_documentation` | Generate project documentation (API, architecture, changelog) | `DOC_TYPE`, `TASK_SLUG` |
+| **Init** | `@rrce_init` | Analyze codebase, establish project context | `PROJECT_NAME` (optional) |
+| **Design** | `@rrce_design` | Research + planning for isolated execution | `TASK_SLUG`, `REQUEST` |
+| **Develop** | `@rrce_develop` | Implement the plan - ONLY agent authorized to modify code | `TASK_SLUG` |
+| **Docs** | `@rrce_docs` | Generate project documentation | `DOC_TYPE`, `TASK_SLUG` |
 | **Sync** | `@rrce_sync` | Reconcile knowledge base with current codebase state | `SCOPE` (optional) |
-| **Doctor** | `@rrce_doctor` | Analyze codebase health, identify issues, recommend improvements | `PROJECT_NAME`, `FOCUS_AREA` |
+| **Doctor** | `@rrce_doctor` | Analyze codebase health, recommend improvements | `PROJECT_NAME`, `FOCUS_AREA` |
+
+### OpenCode Integration
 
-### Workflow Comparison
+OpenCode provides specialized UX optimizations:
 
-| Approach | When to Use | Example |
-|----------|-------------|---------|
-| **Orchestrator** | Complex features, want automatic flow | Switch to RRCE agent: "Add user authentication" → Auto-orchestrates all phases |
-| **Subagents** | Expert control, specific phase needed | `@rrce_executor TASK_SLUG=user-auth` → Direct execution |
-| **Build Delegation** | Want build's help but need structure | Stay in build: "Implement caching" → Build delegates to RRCE |
+- **Tool Name Stabilization**: Standard tools (`read`, `write`) use no `rrce_` prefix, aligning with native IDE capabilities
+- **Checklist Sync**: Agents automatically push their task checklist to the OpenCode Todo sidebar
+- **Hybrid Delegation**: Orchestrator uses a mix of `@mention` text and interactive confirmation suggestions
 
 ### Recommended Workflow
-1.  **`@rrce_init`** (or orchestrator): "Analyze this codebase." → Creates `project-context.md` and semantic index.
-2.  **RRCE Orchestrator**: "I need to add user auth." → Runs research, planning, execution phases automatically.
-3.  **`@rrce_sync`**: "Update knowledge." → Refreshes context for the next task.
+1.  **`/rrce_init`**: "Analyze this codebase." → Creates `project-context.md` and semantic index
+2.  **`/rrce_design my-feature "Add user authentication"`**: Research + planning in one session
+3.  **`/rrce_develop my-feature`**: Execute the implementation
+4.  **`/rrce_docs my-feature`**: Generate/update documentation
+5.  **`/rrce_cleanup my-feature`**: (Optional) Extract insights and delete task artifacts
 
 ---
 
@@ -226,23 +254,59 @@ For expert control, invoke subagents directly via your AI assistant or MCP tools
 RRCE-Workflow includes a local, embedding-based search engine powered by `@xenova/transformers`.
 
 -   **Privacy First**: All embeddings are calculated locally. No code leaves your machine.
--   **Full Codebase Indexing**: The `index_knowledge` tool scans your entire source tree (respecting skip lists like `node_modules`, `.git`).
+-   **Full Codebase Indexing**: The `index_knowledge` tool scans your entire source tree (respecting `.gitignore` rules).
+-   **Background Jobs**: Non-blocking indexing with progress tracking via the MCP Dashboard.
+-   **Automatic Cleanup**: DriftService detects and removes embeddings for deleted files during reindexing.
+-   **Dual Index**: Separate indices for knowledge (`embeddings.json`) and code (`code-embeddings.json`).
 -   **Smart Fallback**: If RAG fails or isn't enabled, `search_knowledge` performs line-by-line text matching.
 -   **Model**: Uses `Xenova/all-MiniLM-L6-v2` by default (configurable per-project).
 
+### Reindexing Guidance
+
+| Scenario | Tool Argument | Rationale |
+|----------|---------------|-----------|
+| Routine updates | `{ "project": "name" }` | Incremental (fastest). Only updates changed files |
+| Major refactors | `{ "project": "name", "force": true }` | Forces re-calculation of hashes for all files without wiping |
+| Corrupt index / Stale vectors | `{ "project": "name", "clean": true }` | Wipes index files and rebuilds from scratch. Resolves vector drift |
+
 RAG is enabled by default in Express Setup. You can toggle it per-project in the MCP Dashboard or via `config.yaml`.
 
 ---
 
-## 🛠 AI Agent Effectiveness & Code Health
+## MCP Dashboard (TUI)
+
+The **MCP Dashboard** provides a cockpit-style interface for managing your RRCE workflow:
 
-We've optimized the codebase to be **highly navigatable for AI coding agents**:
+### Tabs Overview
+1. **Overview (System Cockpit)**: Dashboard snapshot of server health, recent activity, and active task tracking
+2. **Logs**: Real-time tailing of the MCP hub server logs
+3. **Tasks**: Priority view for task management with current project auto-pinned and expanded
+4. **Projects**: Configuration hub for project exposure with real-time indexing progress (indented row)
+
+### Key Features
+- **Unified Cockpit Aesthetic**: White borders, high-density information display
+- **Active Task Tracking**: Real-time progress visualization with phase indicators
+- **Session Management**: Agent todo list display showing granular work items
+- **Project Prioritization**: Current workspace automatically pinned and expanded in Tasks tab
+- **Background Indexing**: Non-blocking indexing with progress reporting in Projects tab
+
+## 🛠 AI Agent Effectiveness & Code Health
 
-### Codebase Optimization (v0.3.13)
-- **Deduplication**: Consolidated install/uninstall logic and project sorting.
-- **Function Extraction**: Split monolithic functions (like `index_knowledge`) into manageable helpers.
-- **Improved Type Safety**: Replaced `any` types with structured interfaces (`TaskMeta`, `AgentInfo`).
-- **AI Agent Guide**: Added [AI Agent Architecture Guide](docs/AI_AGENT_GUIDE.md) to help coding assistants navigate the project.
+The codebase has been optimized for **highly navigatable AI coding agents**:
+
+### Codebase Optimizations
+- **Modular Architecture**: Domain-specific tool handlers split into separate files (`tools/project.ts`, `tools/task.ts`, etc.)
+- **Component Refactoring**: TUI views split into modular sub-components (<200 LOC per file)
+- **Type Safety**: Strict typing with `TaskMeta`, `AgentInfo`, and `DetectedProject` interfaces (no `any` types)
+- **Efficiency**: ~65% token reduction via prompt condensation, session reuse, and hybrid research
+- **Testing**: 207 tests passing across 18 test files using Vitest
+
+### AI Agent Guide (AGENTS.md)
+All AI coding agents MUST consult `AGENTS.md` for technical ground truth, including:
+- Build/test commands (dev mode: `npm run dev`, test: `npm test`)
+- Naming conventions (kebab-case files, camelCase functions, PascalCase classes)
+- Implementation patterns (`WorkflowError` error handling, SSOT principles)
+- MCP & RAG patterns (background jobs, semantic search)
 
 ---
 

package/dist/index.js

@@ -1365,15 +1365,90 @@ var init_config_utils = __esm({
   }
 });
 
+// src/mcp/config-service.ts
+import { EventEmitter } from "events";
+function onConfigChange(listener) {
+  configEmitter.on("change", listener);
+}
+function offConfigChange(listener) {
+  configEmitter.off("change", listener);
+}
+var configEmitter, MCPConfigService, configService;
+var init_config_service = __esm({
+  "src/mcp/config-service.ts"() {
+    "use strict";
+    init_config();
+    configEmitter = new EventEmitter();
+    MCPConfigService = class {
+      cache = null;
+      cacheTime = 0;
+      TTL = 5e3;
+      // 5 seconds cache TTL
+      /**
+       * Load config with caching
+       * Returns cached version if still valid, otherwise reads from disk
+       */
+      load() {
+        const now = Date.now();
+        if (this.cache && now - this.cacheTime < this.TTL) {
+          return this.cache;
+        }
+        this.cache = loadMCPConfig();
+        this.cacheTime = now;
+        return this.cache;
+      }
+      /**
+       * Save config, update cache, and emit change event
+       */
+      save(config) {
+        const oldConfig = this.cache;
+        saveMCPConfig(config);
+        this.cache = config;
+        this.cacheTime = Date.now();
+        configEmitter.emit("change", oldConfig || loadMCPConfig(), config);
+      }
+      /**
+       * Invalidate cache, forcing next load to read from disk
+       */
+      invalidate() {
+        this.cache = null;
+      }
+      /**
+       * Check if cache is currently valid
+       */
+      isCacheValid() {
+        return this.cache !== null && Date.now() - this.cacheTime < this.TTL;
+      }
+      /**
+       * Get current cache age in milliseconds
+       */
+      getCacheAge() {
+        return this.cache ? Date.now() - this.cacheTime : Infinity;
+      }
+      /**
+       * Get the config file path
+       */
+      getConfigPath() {
+        return getMCPConfigPath();
+      }
+    };
+    configService = new MCPConfigService();
+  }
+});
+
 // src/mcp/config.ts
 var config_exports = {};
 __export(config_exports, {
   cleanStaleProjects: () => cleanStaleProjects,
+  configEmitter: () => configEmitter,
+  configService: () => configService,
   ensureMCPGlobalPath: () => ensureMCPGlobalPath,
   getMCPConfigPath: () => getMCPConfigPath,
   getProjectPermissions: () => getProjectPermissions,
   isProjectExposed: () => isProjectExposed,
   loadMCPConfig: () => loadMCPConfig,
+  offConfigChange: () => offConfigChange,
+  onConfigChange: () => onConfigChange,
   removeProjectConfig: () => removeProjectConfig,
   saveMCPConfig: () => saveMCPConfig,
   setProjectConfig: () => setProjectConfig
@@ -1560,6 +1635,8 @@ var init_config = __esm({
     init_paths();
     init_types();
     init_config_utils();
+    init_config_service();
+    init_config_service();
   }
 });
 
@@ -1815,7 +1892,7 @@ var init_utils2 = __esm({
 import * as fs15 from "fs";
 import * as path17 from "path";
 function resolveProjectPaths(project, pathInput) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   let workspaceRoot = pathInput;
   let workspaceName = project;
   if (!workspaceRoot && project) {
@@ -1886,7 +1963,7 @@ var init_paths2 = __esm({
 import * as fs16 from "fs";
 import * as path18 from "path";
 function getExposedProjects() {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const knownProjects = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
   const allProjects = projectService.scan({ knownProjects });
   const activeProject = detectActiveProject(allProjects);
@@ -1933,7 +2010,7 @@ function getExposedProjects() {
 function detectActiveProject(knownProjects) {
   let scanList = knownProjects;
   if (!scanList) {
-    const config = loadMCPConfig();
+    const config = configService.load();
     const knownProjectsMap = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
     const all = projectService.scan({ knownProjects: knownProjectsMap });
     scanList = all.filter((project) => isProjectExposed(config, project.name, project.sourcePath || project.path));
@@ -1941,7 +2018,7 @@ function detectActiveProject(knownProjects) {
   return findClosestProject(scanList);
 }
 function getProjectContext(projectName) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = projectService.scan();
   const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
   if (!project) {
@@ -1980,7 +2057,7 @@ import * as path19 from "path";
 import * as os3 from "os";
 import * as crypto from "crypto";
 function getProjectTasks(projectName) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = projectService.scan();
   const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
   if (!project) {
@@ -2014,7 +2091,7 @@ function getProjectTasks(projectName) {
   return tasks;
 }
 function getTask(projectName, taskSlug) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   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;
@@ -2028,7 +2105,7 @@ function getTask(projectName, taskSlug) {
   }
 }
 async function createTask(projectName, taskSlug, taskData) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = projectService.scan();
   const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
   if (!project || !project.tasksPath) {
@@ -2083,7 +2160,7 @@ async function updateTask(projectName, taskSlug, taskData) {
     workspace: meta.workspace
     // Protect workspace metadata
   };
-  const config = loadMCPConfig();
+  const config = configService.load();
   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;
@@ -2092,7 +2169,7 @@ async function updateTask(projectName, taskSlug, taskData) {
   return updatedMeta;
 }
 function deleteTask(projectName, taskSlug) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   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;
@@ -3279,7 +3356,7 @@ var init_search_utils = __esm({
 import * as fs20 from "fs";
 import * as path22 from "path";
 async function searchCode(query, projectFilter, limit = 10, options) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = getExposedProjects();
   const results = [];
   for (const project of projects) {
@@ -3352,7 +3429,7 @@ async function searchCode(query, projectFilter, limit = 10, options) {
   };
 }
 async function searchKnowledge(query, projectFilter, options) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = getExposedProjects();
   const results = [];
   const queryLower = query.toLowerCase();
@@ -3439,7 +3516,7 @@ async function searchKnowledge(query, projectFilter, options) {
   };
 }
 async function findRelatedFiles2(filePath, projectName, options = {}) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = getExposedProjects();
   const project = projects.find((p) => p.name === projectName);
   if (!project) {
@@ -3495,7 +3572,7 @@ async function findRelatedFiles2(filePath, projectName, options = {}) {
   }
 }
 async function searchSymbols2(name, projectName, options = {}) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = getExposedProjects();
   const project = projects.find((p) => p.name === projectName);
   if (!project) {
@@ -3573,7 +3650,7 @@ async function searchSymbols2(name, projectName, options = {}) {
   }
 }
 async function getFileSummary(filePath, projectName) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = getExposedProjects();
   const project = projects.find((p) => p.name === projectName);
   if (!project) {
@@ -3761,7 +3838,7 @@ var init_drift_service = __esm({
 import * as fs22 from "fs";
 import * as path24 from "path";
 async function indexKnowledge(projectName, force = false, clean = false) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = getExposedProjects();
   const project = projects.find((p2) => p2.name === projectName || p2.path && p2.path === projectName);
   if (!project) {
@@ -4262,7 +4339,7 @@ var init_validation = __esm({
 import * as fs23 from "fs";
 import * as path26 from "path";
 function startSession(projectName, taskSlug, agent, phase) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = projectService.scan();
   const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
   if (!project || !project.tasksPath) {
@@ -4284,7 +4361,7 @@ function startSession(projectName, taskSlug, agent, phase) {
   return { success: true, message: `Session started for ${agent} agent on task '${taskSlug}' (phase: ${phase})` };
 }
 function endSession(projectName, taskSlug) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = projectService.scan();
   const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
   if (!project || !project.tasksPath) {
@@ -4298,7 +4375,7 @@ function endSession(projectName, taskSlug) {
   return { success: true, message: `Session ended for task '${taskSlug}'.` };
 }
 function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = projectService.scan();
   const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
   if (!project || !project.tasksPath) {
@@ -4370,7 +4447,7 @@ function registerResourceHandlers(server) {
       mimeType: "application/json"
     });
     for (const project of projects) {
-      const config = loadMCPConfig();
+      const config = configService.load();
       const permissions = getProjectPermissions(config, project.name, project.dataPath);
       if (permissions.knowledge) {
         resources.push({
@@ -4438,7 +4515,7 @@ var init_resources3 = __esm({
 // src/mcp/handlers/tools/project.ts
 async function handleProjectTool(name, args) {
   if (!args) {
-    if (name === "list_projects" || name === "help_setup") {
+    if (name === "list_projects" || name === "help_setup" || name === "reload_config") {
     } else {
       return null;
     }
@@ -4487,6 +4564,19 @@ To fix this:
 `;
       return { content: [{ type: "text", text: msg }] };
     }
+    case "reload_config": {
+      configService.invalidate();
+      const newConfig = configService.load();
+      const exposedProjects = getExposedProjects().map((p) => p.name);
+      const msg = `Config reloaded successfully.
+- Cache invalidated
+- Config file: ${configService.getConfigPath()}
+- Exposed projects: ${exposedProjects.join(", ") || "none"}
+- Total projects in config: ${newConfig.projects.length}
+`;
+      logger.info("Config reloaded via reload_config tool", { exposedProjects });
+      return { content: [{ type: "text", text: msg }] };
+    }
     default:
       return null;
   }
@@ -4497,6 +4587,7 @@ var init_project = __esm({
     "use strict";
     init_resources2();
     init_logger();
+    init_config_service();
     projectTools = [
       {
         name: "resolve_path",
@@ -4535,6 +4626,11 @@ var init_project = __esm({
           },
           required: ["project"]
         }
+      },
+      {
+        name: "reload_config",
+        description: "Reload MCP configuration from disk. Use this after manually editing mcp.yaml or when changes are not reflecting automatically.",
+        inputSchema: { type: "object", properties: {} }
       }
     ];
   }
@@ -5218,7 +5314,7 @@ async function cleanupSingleTask(projectName, taskSlug, projectDataPath) {
   }
 }
 function getProjectDataPath(projectName) {
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = projectService.scan();
   const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
   if (!project || !project.dataPath) {
@@ -5456,6 +5552,7 @@ var init_prompts3 = __esm({
 // src/mcp/server.ts
 import { Server as Server4 } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as fs26 from "fs";
 async function startMCPServer(options = {}) {
   try {
     logger.info("Starting MCP Server...");
@@ -5465,9 +5562,8 @@ async function startMCPServer(options = {}) {
     });
     process.on("unhandledRejection", (reason) => {
       logger.error("Unhandled Rejection", reason);
-      console.error("Unhandled Rejection:", reason);
     });
-    const config = loadMCPConfig();
+    const config = configService.load();
     mcpServer = new Server4(
       { name: "rrce-mcp-hub", version: "1.0.0" },
       { capabilities: { resources: {}, tools: {}, prompts: {} } }
@@ -5478,6 +5574,21 @@ async function startMCPServer(options = {}) {
     registerResourceHandlers(mcpServer);
     registerToolHandlers(mcpServer);
     registerPromptHandlers(mcpServer);
+    const configPath = configService.getConfigPath();
+    if (!options.interactive) {
+      try {
+        if (fs26.existsSync(configPath)) {
+          configWatcher = fs26.watch(configPath, () => {
+            configService.invalidate();
+            const exposed2 = getExposedProjects().map((p) => p.name).join(", ");
+            logger.info("Config file changed, refreshed exposed projects", { exposedProjects: exposed2 });
+          });
+          logger.info("Watching config file for changes", { configPath });
+        }
+      } catch (err) {
+        logger.warn("Failed to watch config file", { error: String(err) });
+      }
+    }
     if (!options.interactive) {
       const transport = new StdioServerTransport();
       await mcpServer.connect(transport);
@@ -5498,6 +5609,10 @@ async function startMCPServer(options = {}) {
   }
 }
 function stopMCPServer() {
+  if (configWatcher) {
+    configWatcher.close();
+    configWatcher = null;
+  }
   if (mcpServer) {
     logger.info("Stopping MCP Server...");
     mcpServer.close();
@@ -5509,18 +5624,19 @@ function stopMCPServer() {
 function getMCPServerStatus() {
   return { ...serverState };
 }
-var serverState, mcpServer;
+var serverState, mcpServer, configWatcher;
 var init_server = __esm({
   "src/mcp/server.ts"() {
     "use strict";
     init_logger();
-    init_config();
+    init_config_service();
     init_resources2();
     init_resources3();
     init_tools();
     init_prompts3();
     serverState = { running: false };
     mcpServer = null;
+    configWatcher = null;
   }
 });
 
@@ -5530,7 +5646,7 @@ import pc5 from "picocolors";
 async function handleConfigure() {
   const s = spinner();
   s.start("Scanning for projects...");
-  const config = loadMCPConfig();
+  const config = configService.load();
   const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
   const projects = scanForProjects({ knownPaths });
   logger.info("Configure: Loaded config", { projects: config.projects, defaultMode: config.defaults.includeNew });
@@ -5606,7 +5722,7 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs35 = await import("fs");
+  const fs36 = await import("fs");
   const path35 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
@@ -5621,10 +5737,10 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs35.existsSync(resolvedPath)) {
-      fs35.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs36.existsSync(resolvedPath)) {
+      fs36.mkdirSync(resolvedPath, { recursive: true });
     }
-    const config = loadMCPConfig();
+    const config = configService.load();
     saveMCPConfig(config);
     note3(
       `${pc5.green("\u2713")} Global path configured: ${pc5.cyan(resolvedPath)}
@@ -5734,15 +5850,15 @@ __export(ConfigContext_exports, {
   useConfig: () => useConfig
 });
 import { createContext, useContext, useState, useCallback, useMemo, useEffect } from "react";
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import * as path29 from "path";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function getPackageVersion() {
   try {
     const agentCoreDir = getAgentCoreDir();
     const packageJsonPath = path29.join(path29.dirname(agentCoreDir), "package.json");
-    if (fs26.existsSync(packageJsonPath)) {
-      return JSON.parse(fs26.readFileSync(packageJsonPath, "utf8")).version;
+    if (fs27.existsSync(packageJsonPath)) {
+      return JSON.parse(fs27.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -5809,16 +5925,16 @@ var init_ConfigContext = __esm({
 });
 
 // src/mcp/ui/lib/tasks-fs.ts
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import * as path30 from "path";
 function readSession(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
   const sessionPath = path30.join(rrceData, "tasks", taskSlug, "session.json");
-  if (!fs27.existsSync(sessionPath)) {
+  if (!fs28.existsSync(sessionPath)) {
     return null;
   }
   try {
-    const raw = fs27.readFileSync(sessionPath, "utf-8");
+    const raw = fs28.readFileSync(sessionPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5832,11 +5948,11 @@ function isSessionStale(session, thresholdMs = SESSION_STALE_THRESHOLD_MS) {
 function readAgentTodos(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
   const todosPath = path30.join(rrceData, "tasks", taskSlug, "agent-todos.json");
-  if (!fs27.existsSync(todosPath)) {
+  if (!fs28.existsSync(todosPath)) {
     return null;
   }
   try {
-    const raw = fs27.readFileSync(todosPath, "utf-8");
+    const raw = fs28.readFileSync(todosPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5849,8 +5965,8 @@ function detectStorageModeFromConfig(workspaceRoot) {
     if (configPath.startsWith(rrceHome)) {
       return "global";
     }
-    if (fs27.existsSync(configPath)) {
-      const content = fs27.readFileSync(configPath, "utf-8");
+    if (fs28.existsSync(configPath)) {
+      const content = fs28.readFileSync(configPath, "utf-8");
       if (content.includes("mode: workspace")) return "workspace";
       if (content.includes("mode: global")) return "global";
     }
@@ -5870,18 +5986,18 @@ function getProjectRRCEData(project) {
 function listProjectTasks(project) {
   const rrceData = getProjectRRCEData(project);
   const tasksPath = path30.join(rrceData, "tasks");
-  if (!fs27.existsSync(tasksPath)) {
+  if (!fs28.existsSync(tasksPath)) {
     return { projectName: project.name, tasksPath, tasks: [] };
   }
   const tasks = [];
   try {
-    const entries = fs27.readdirSync(tasksPath, { withFileTypes: true });
+    const entries = fs28.readdirSync(tasksPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const metaPath = path30.join(tasksPath, entry.name, "meta.json");
-      if (!fs27.existsSync(metaPath)) continue;
+      if (!fs28.existsSync(metaPath)) continue;
       try {
-        const raw = fs27.readFileSync(metaPath, "utf-8");
+        const raw = fs28.readFileSync(metaPath, "utf-8");
         const meta = JSON.parse(raw);
         if (!meta.task_slug) meta.task_slug = entry.name;
         tasks.push(meta);
@@ -5901,17 +6017,17 @@ function listProjectTasks(project) {
 function updateTaskStatus(project, taskSlug, status) {
   const rrceData = getProjectRRCEData(project);
   const metaPath = path30.join(rrceData, "tasks", taskSlug, "meta.json");
-  if (!fs27.existsSync(metaPath)) {
+  if (!fs28.existsSync(metaPath)) {
     return { ok: false, error: `meta.json not found for task '${taskSlug}'` };
   }
   try {
-    const meta = JSON.parse(fs27.readFileSync(metaPath, "utf-8"));
+    const meta = JSON.parse(fs28.readFileSync(metaPath, "utf-8"));
     const next = {
       ...meta,
       status,
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs27.writeFileSync(metaPath, JSON.stringify(next, null, 2));
+    fs28.writeFileSync(metaPath, JSON.stringify(next, null, 2));
     return { ok: true, meta: next };
   } catch (e) {
     return { ok: false, error: String(e) };
@@ -6296,7 +6412,7 @@ var init_ProjectViews = __esm({
 });
 
 // src/mcp/ui/lib/projects.ts
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 import * as path31 from "path";
 function getIndexStats(project) {
   const stats = { knowledgeCount: 0, codeCount: 0, lastIndexed: null };
@@ -6305,18 +6421,18 @@ function getIndexStats(project) {
     if (knowledgePath) {
       const embPath = path31.join(knowledgePath, "embeddings.json");
       const codeEmbPath = path31.join(knowledgePath, "code-embeddings.json");
-      if (fs28.existsSync(embPath)) {
-        const stat = fs28.statSync(embPath);
+      if (fs29.existsSync(embPath)) {
+        const stat = fs29.statSync(embPath);
         stats.lastIndexed = stat.mtime.toISOString();
         try {
-          const data = JSON.parse(fs28.readFileSync(embPath, "utf-8"));
+          const data = JSON.parse(fs29.readFileSync(embPath, "utf-8"));
           stats.knowledgeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
       }
-      if (fs28.existsSync(codeEmbPath)) {
+      if (fs29.existsSync(codeEmbPath)) {
         try {
-          const data = JSON.parse(fs28.readFileSync(codeEmbPath, "utf-8"));
+          const data = JSON.parse(fs29.readFileSync(codeEmbPath, "utf-8"));
           stats.codeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
@@ -6349,7 +6465,7 @@ var init_ProjectsView = __esm({
     init_ui_helpers();
     init_ProjectViews();
     init_projects2();
-    ProjectsView = ({ config: initialConfig, projects: allProjects, onConfigChange, workspacePath }) => {
+    ProjectsView = ({ config: initialConfig, projects: allProjects, onConfigChange: onConfigChange2, workspacePath }) => {
       const { driftReports, checkAllDrift } = useConfig();
       const [config, setConfig] = useState3(initialConfig);
       const [indexingStats, setIndexingStats] = useState3({});
@@ -6386,7 +6502,7 @@ var init_ProjectsView = __esm({
           };
           saveMCPConfig(newConfig);
           setConfig(newConfig);
-          onConfigChange?.();
+          onConfigChange2?.();
         }
       });
       const projectItems = useMemo3(() => {
@@ -6452,7 +6568,7 @@ ${statsRow}` : label;
         });
         saveMCPConfig(newConfig);
         setConfig(newConfig);
-        onConfigChange?.();
+        onConfigChange2?.();
       };
       return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
         /* @__PURE__ */ jsx6(ProjectsHeader, { autoExpose: config.defaults.includeNew }),
@@ -7061,7 +7177,7 @@ __export(App_exports, {
 });
 import { useState as useState5, useEffect as useEffect6, useMemo as useMemo5, useCallback as useCallback3 } from "react";
 import { Box as Box14, useInput as useInput5, useApp } from "ink";
-import fs29 from "fs";
+import fs30 from "fs";
 import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
 var App;
 var init_App = __esm({
@@ -7134,18 +7250,18 @@ var init_App = __esm({
       useEffect6(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs29.existsSync(logPath)) {
-          const stats = fs29.statSync(logPath);
+        if (fs30.existsSync(logPath)) {
+          const stats = fs30.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs29.existsSync(logPath)) {
-            const stats = fs29.statSync(logPath);
+          if (fs30.existsSync(logPath)) {
+            const stats = fs30.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs29.openSync(logPath, "r");
-              fs29.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs29.closeSync(fd);
+              const fd = fs30.openSync(logPath, "r");
+              fs30.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs30.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -7223,7 +7339,7 @@ async function handleStartServer() {
   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));
-  const config = loadMCPConfig();
+  const config = configService.load();
   const projects = scanForProjects();
   const exposedProjects = projects.filter((p) => {
     const cfg = config.projects.find(
@@ -7370,15 +7486,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 fs30 from "fs";
+import * as fs31 from "fs";
 import * as path32 from "path";
 import { stringify as stringify2, parse } from "yaml";
 function backupFile(filePath) {
-  if (!fs30.existsSync(filePath)) return null;
+  if (!fs31.existsSync(filePath)) return null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
   const backupPath = `${filePath}.${timestamp}.bak`;
   try {
-    fs30.copyFileSync(filePath, backupPath);
+    fs31.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (e) {
     console.error(`Failed to backup ${filePath}:`, e);
@@ -7389,8 +7505,8 @@ function getPackageVersion2() {
   try {
     const agentCoreDir = getAgentCoreDir();
     const packageJsonPath = path32.join(path32.dirname(agentCoreDir), "package.json");
-    if (fs30.existsSync(packageJsonPath)) {
-      return JSON.parse(fs30.readFileSync(packageJsonPath, "utf8")).version;
+    if (fs31.existsSync(packageJsonPath)) {
+      return JSON.parse(fs31.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -7405,9 +7521,9 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
   const configFilePath = getConfigPath(workspacePath);
   let currentSyncedVersion;
-  if (fs30.existsSync(configFilePath)) {
+  if (fs31.existsSync(configFilePath)) {
     try {
-      const content = fs30.readFileSync(configFilePath, "utf-8");
+      const content = fs31.readFileSync(configFilePath, "utf-8");
       const config = parse(content);
       currentSyncedVersion = config.last_synced_version;
     } catch (e) {
@@ -7415,8 +7531,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   }
   const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
   const ideTargets = [];
-  if (fs30.existsSync(configFilePath)) {
-    const configContent = fs30.readFileSync(configFilePath, "utf-8");
+  if (fs31.existsSync(configFilePath)) {
+    const configContent = fs31.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");
@@ -7426,9 +7542,9 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     const updatedFiles = [];
     for (const dir of dirs) {
       const srcDir = path32.join(agentCoreDir, dir);
-      if (!fs30.existsSync(srcDir)) continue;
+      if (!fs31.existsSync(srcDir)) continue;
       const syncFiles = (src, rel) => {
-        const entries = fs30.readdirSync(src, { withFileTypes: true });
+        const entries = fs31.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
           const entrySrc = path32.join(src, entry.name);
           const entryRel = path32.join(rel, entry.name);
@@ -7441,7 +7557,7 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
               backupFile(entryDest);
             }
             ensureDir(path32.dirname(entryDest));
-            fs30.copyFileSync(entrySrc, entryDest);
+            fs31.copyFileSync(entrySrc, entryDest);
             updatedFiles.push(entryRel);
           }
         }
@@ -7456,8 +7572,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   ensureDir(path32.join(rrceHome, "docs"));
   copyDirRecursive(path32.join(agentCoreDir, "templates"), path32.join(rrceHome, "templates"));
   copyDirRecursive(path32.join(agentCoreDir, "docs"), path32.join(rrceHome, "docs"));
-  if (fs30.existsSync(configFilePath)) {
-    const configContent = fs30.readFileSync(configFilePath, "utf-8");
+  if (fs31.existsSync(configFilePath)) {
+    const configContent = fs31.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -7479,21 +7595,21 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     try {
       const yaml = parse(configContent);
       yaml.last_synced_version = runningVersion;
-      fs30.writeFileSync(configFilePath, stringify2(yaml));
+      fs31.writeFileSync(configFilePath, stringify2(yaml));
     } catch (e) {
       console.error("Failed to update config.yaml version:", e);
     }
   }
   const mcpPath = path32.join(rrceHome, "mcp.yaml");
-  if (fs30.existsSync(mcpPath)) {
+  if (fs31.existsSync(mcpPath)) {
     try {
-      const content = fs30.readFileSync(mcpPath, "utf-8");
+      const content = fs31.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;
-          fs30.writeFileSync(mcpPath, stringify2(yaml));
+          fs31.writeFileSync(mcpPath, stringify2(yaml));
         }
       }
     } catch (e) {
@@ -7529,9 +7645,9 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     const configFilePath = getConfigPath(workspacePath);
     let currentSyncedVersion;
-    if (fs30.existsSync(configFilePath)) {
+    if (fs31.existsSync(configFilePath)) {
       try {
-        const content = fs30.readFileSync(configFilePath, "utf-8");
+        const content = fs31.readFileSync(configFilePath, "utf-8");
         const config = parse(content);
         currentSyncedVersion = config.last_synced_version;
       } catch (e) {
@@ -7555,8 +7671,8 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
       `  \u2022 docs/ (documentation)`
     ];
     const ideTargets = [];
-    if (fs30.existsSync(configFilePath)) {
-      const configContent = fs30.readFileSync(configFilePath, "utf-8");
+    if (fs31.existsSync(configFilePath)) {
+      const configContent = fs31.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");
@@ -7586,9 +7702,9 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       const updatedFiles = [];
       for (const dir of dirs) {
         const srcDir = path32.join(agentCoreDir, dir);
-        if (!fs30.existsSync(srcDir)) continue;
+        if (!fs31.existsSync(srcDir)) continue;
         const syncFiles = (src, rel) => {
-          const entries = fs30.readdirSync(src, { withFileTypes: true });
+          const entries = fs31.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
             const entrySrc = path32.join(src, entry.name);
             const entryRel = path32.join(rel, entry.name);
@@ -7601,7 +7717,7 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
                 backupFile(entryDest);
               }
               ensureDir(path32.dirname(entryDest));
-              fs30.copyFileSync(entrySrc, entryDest);
+              fs31.copyFileSync(entrySrc, entryDest);
               updatedFiles.push(entryRel);
             }
           }
@@ -7616,8 +7732,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     ensureDir(path32.join(rrceHome, "docs"));
     copyDirRecursive(path32.join(agentCoreDir, "templates"), path32.join(rrceHome, "templates"));
     copyDirRecursive(path32.join(agentCoreDir, "docs"), path32.join(rrceHome, "docs"));
-    if (fs30.existsSync(configFilePath)) {
-      const configContent = fs30.readFileSync(configFilePath, "utf-8");
+    if (fs31.existsSync(configFilePath)) {
+      const configContent = fs31.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
@@ -7639,21 +7755,21 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       try {
         const yaml = parse(configContent);
         yaml.last_synced_version = runningVersion;
-        fs30.writeFileSync(configFilePath, stringify2(yaml));
+        fs31.writeFileSync(configFilePath, stringify2(yaml));
       } catch (e) {
         console.error("Failed to update config.yaml version:", e);
       }
     }
     const mcpPath = path32.join(rrceHome, "mcp.yaml");
-    if (fs30.existsSync(mcpPath)) {
+    if (fs31.existsSync(mcpPath)) {
       try {
-        const content = fs30.readFileSync(mcpPath, "utf-8");
+        const content = fs31.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;
-            fs30.writeFileSync(mcpPath, stringify2(yaml));
+            fs31.writeFileSync(mcpPath, stringify2(yaml));
           }
         }
       } catch (e) {
@@ -7712,7 +7828,7 @@ 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 fs34 from "fs";
+import * as fs35 from "fs";
 import * as path34 from "path";
 import { parse as parse2 } from "yaml";
 
@@ -8390,7 +8506,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 fs31 from "fs";
+import * as fs32 from "fs";
 init_detection();
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
@@ -8429,7 +8545,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs31.readFileSync(configFilePath, "utf-8");
+  let configContent = fs32.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -8456,7 +8572,7 @@ linked_projects:
 `;
     });
   }
-  fs31.writeFileSync(configFilePath, configContent);
+  fs32.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -8492,7 +8608,7 @@ 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 fs32 from "fs";
+import * as fs33 from "fs";
 import * as path33 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
@@ -8500,7 +8616,7 @@ async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const globalPath = path33.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs32.existsSync(path33.join(localPath, dir))
+    (dir) => fs33.existsSync(path33.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro5(pc11.yellow("No data found in workspace storage to sync."));
@@ -8555,7 +8671,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 fs33 from "fs";
+import * as fs34 from "fs";
 init_detection();
 init_config();
 async function runDeleteGlobalProjectFlow(availableProjects) {
@@ -8594,13 +8710,13 @@ Are you sure?`,
   const s = spinner6();
   s.start("Deleting projects...");
   try {
-    const mcpConfig = loadMCPConfig();
+    const mcpConfig = configService.load();
     let configChanged = false;
     for (const projectName of projectsToDelete) {
       const project = globalProjects.find((p) => p.name === projectName);
       if (!project) continue;
-      if (fs33.existsSync(project.dataPath)) {
-        fs33.rmSync(project.dataPath, { recursive: true, force: true });
+      if (fs34.existsSync(project.dataPath)) {
+        fs34.rmSync(project.dataPath, { recursive: true, force: true });
       }
       const newConfig = removeProjectConfig(mcpConfig, projectName);
       configChanged = true;
@@ -8623,8 +8739,8 @@ function getPackageVersion3() {
   try {
     const agentCoreDir = getAgentCoreDir();
     const packageJsonPath = path34.join(path34.dirname(agentCoreDir), "package.json");
-    if (fs34.existsSync(packageJsonPath)) {
-      return JSON.parse(fs34.readFileSync(packageJsonPath, "utf8")).version;
+    if (fs35.existsSync(packageJsonPath)) {
+      return JSON.parse(fs35.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -8632,9 +8748,9 @@ function getPackageVersion3() {
 }
 function getLastSyncedVersion(workspacePath, workspaceName) {
   const configFilePath = getConfigPath(workspacePath);
-  if (fs34.existsSync(configFilePath)) {
+  if (fs35.existsSync(configFilePath)) {
     try {
-      const content = fs34.readFileSync(configFilePath, "utf-8");
+      const content = fs35.readFileSync(configFilePath, "utf-8");
       const config = parse2(content);
       if (config.last_synced_version) {
         return config.last_synced_version;
@@ -8644,9 +8760,9 @@ function getLastSyncedVersion(workspacePath, workspaceName) {
   }
   const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
   const mcpPath = path34.join(rrceHome, "mcp.yaml");
-  if (fs34.existsSync(mcpPath)) {
+  if (fs35.existsSync(mcpPath)) {
     try {
-      const content = fs34.readFileSync(mcpPath, "utf-8");
+      const content = fs35.readFileSync(mcpPath, "utf-8");
       const config = parse2(content);
       const project = config.projects?.find((p) => p.name === workspaceName);
       if (project?.last_synced_version) {
@@ -8697,7 +8813,7 @@ async function runWizard() {
   const workspaceName = getWorkspaceName(workspacePath);
   const gitUser = getGitUser();
   try {
-    const mcpConfig = loadMCPConfig();
+    const mcpConfig = configService.load();
     const { config: cleanConfig, removed } = cleanStaleProjects(mcpConfig);
     if (removed.length > 0) {
       saveMCPConfig(cleanConfig);
@@ -8716,18 +8832,18 @@ Workspace: ${pc13.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  let isAlreadyConfigured = fs34.existsSync(configFilePath);
+  let isAlreadyConfigured = fs35.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs34.readFileSync(configFilePath, "utf-8");
+      const configContent = fs35.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   } else {
     try {
-      const mcpConfig = loadMCPConfig();
+      const mcpConfig = configService.load();
       const mcpProject = mcpConfig.projects.find((p) => p.path === workspacePath);
       if (mcpProject) {
         isAlreadyConfigured = true;
@@ -8737,7 +8853,7 @@ Workspace: ${pc13.bold(workspaceName)}`,
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs34.existsSync(localDataPath);
+  const hasLocalData = fs35.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const continueToMenu = await checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode);
     if (!continueToMenu) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rrce-workflow",
-  "version": "0.3.30",
+  "version": "0.3.32",
   "description": "RRCE-Workflow TUI - Agentic code workflow generator for AI-assisted development",
   "author": "RRCE Team",
   "license": "MIT",