rrce-workflow 0.2.92 → 0.2.94

package/dist/index.js

@@ -1562,6 +1562,33 @@ var init_rag = __esm({
           logger.error(`[RAG] Failed to save index to ${this.indexPath}`, error);
         }
       }
+      /**
+       * Save index to a temp file and atomically replace
+       */
+      saveIndexAtomic() {
+        if (!this.index) return;
+        const dir = path15.dirname(this.indexPath);
+        if (!fs13.existsSync(dir)) {
+          fs13.mkdirSync(dir, { recursive: true });
+        }
+        const tmpPath = `${this.indexPath}.tmp`;
+        fs13.writeFileSync(tmpPath, JSON.stringify(this.index, null, 2));
+        fs13.renameSync(tmpPath, this.indexPath);
+      }
+      /**
+       * Save index only if enough time passed since last save
+       */
+      maybeSaveIndex(force = false) {
+        if (!this.index) return;
+        const now = Date.now();
+        const intervalMs = 1e3;
+        const last = this.index.metadata?.lastSaveAt;
+        if (force || last === void 0 || now - last >= intervalMs) {
+          this.index.metadata = { ...this.index.metadata ?? {}, lastSaveAt: now };
+          this.saveIndexAtomic();
+          logger.info(`[RAG] Saved index (atomic) to ${this.indexPath} with ${this.index.chunks.length} chunks.`);
+        }
+      }
       /**
        * Generate embedding for text
        */
@@ -1612,7 +1639,7 @@ var init_rag = __esm({
           mtime: mtime ?? Date.now(),
           chunkCount: chunks.length
         };
-        this.saveIndex();
+        this.maybeSaveIndex();
         return true;
       }
       /**
@@ -1628,7 +1655,7 @@ var init_rag = __esm({
         }
         if (this.index.chunks.length !== initialCount) {
           logger.info(`[RAG] Removed file ${filePath} from index (${initialCount - this.index.chunks.length} chunks removed)`);
-          this.saveIndex();
+          this.maybeSaveIndex(true);
         }
       }
       /**
@@ -1651,7 +1678,7 @@ var init_rag = __esm({
         this.loadIndex();
         if (!this.index) return;
         this.index.lastFullIndex = Date.now();
-        this.saveIndex();
+        this.maybeSaveIndex(true);
       }
       /**
        * Search the index
@@ -1681,9 +1708,11 @@ var init_rag = __esm({
         let normA = 0;
         let normB = 0;
         for (let i = 0; i < a.length; i++) {
-          dotProduct += a[i] * b[i];
-          normA += a[i] * a[i];
-          normB += b[i] * b[i];
+          const av = a[i] ?? 0;
+          const bv = b[i] ?? 0;
+          dotProduct += av * bv;
+          normA += av * av;
+          normB += bv * bv;
         }
         return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
       }
@@ -1716,6 +1745,83 @@ var init_rag = __esm({
   }
 });
 
+// src/mcp/services/indexing-jobs.ts
+var IndexingJobManager, indexingJobs;
+var init_indexing_jobs = __esm({
+  "src/mcp/services/indexing-jobs.ts"() {
+    "use strict";
+    init_logger();
+    IndexingJobManager = class {
+      jobs = /* @__PURE__ */ new Map();
+      getProgress(project) {
+        const existing = this.jobs.get(project);
+        if (existing) return { ...existing.progress };
+        return {
+          project,
+          state: "idle",
+          itemsDone: 0,
+          itemsTotal: void 0
+        };
+      }
+      update(project, patch) {
+        const existing = this.jobs.get(project);
+        const next = {
+          ...existing?.progress ?? this.getProgress(project),
+          ...patch,
+          project
+        };
+        this.jobs.set(project, { ...existing ?? { progress: next }, progress: next });
+      }
+      isRunning(project) {
+        return this.getProgress(project).state === "running";
+      }
+      startOrStatus(project, runner) {
+        const current = this.jobs.get(project);
+        if (current?.progress.state === "running" && current.promise) {
+          return {
+            status: "already_running",
+            state: "running",
+            progress: { ...current.progress }
+          };
+        }
+        const startedAt = Date.now();
+        const initial = {
+          project,
+          state: "running",
+          startedAt,
+          itemsDone: 0,
+          itemsTotal: void 0,
+          currentItem: void 0,
+          lastError: void 0
+        };
+        const job = { progress: initial };
+        this.jobs.set(project, job);
+        job.promise = (async () => {
+          try {
+            await runner();
+            this.update(project, { state: "complete", completedAt: Date.now(), currentItem: void 0 });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`[RAG] Indexing job failed for '${project}'`, err);
+            this.update(project, {
+              state: "failed",
+              completedAt: Date.now(),
+              currentItem: void 0,
+              lastError: msg
+            });
+          }
+        })();
+        return {
+          status: "started",
+          state: "running",
+          progress: { ...this.getProgress(project) }
+        };
+      }
+    };
+    indexingJobs = new IndexingJobManager();
+  }
+});
+
 // src/mcp/resources.ts
 import * as fs14 from "fs";
 import * as path16 from "path";
@@ -1887,6 +1993,8 @@ async function searchKnowledge(query, projectFilter) {
     if (projectFilter && project.name !== projectFilter) continue;
     const permissions = getProjectPermissions(config, project.name, project.sourcePath || project.path);
     if (!permissions.knowledge || !project.knowledgePath) continue;
+    const indexingInProgress = indexingJobs.isRunning(project.name);
+    const advisoryMessage = indexingInProgress ? "Indexing in progress; results may be stale/incomplete." : void 0;
     const projConfig = config.projects.find(
       (p) => p.path && normalizeProjectPath(p.path) === normalizeProjectPath(project.sourcePath || project.path) || !p.path && p.name === project.name
     );
@@ -1903,7 +2011,9 @@ async function searchKnowledge(query, projectFilter) {
             file: path16.relative(project.knowledgePath, r.filePath),
             matches: [r.content],
             // The chunk content is the match
-            score: r.score
+            score: r.score,
+            indexingInProgress: indexingInProgress || void 0,
+            advisoryMessage
           });
         }
         continue;
@@ -1928,8 +2038,10 @@ async function searchKnowledge(query, projectFilter) {
           results.push({
             project: project.name,
             file,
-            matches: matches.slice(0, 5)
+            matches: matches.slice(0, 5),
             // Limit to 5 matches per file
+            indexingInProgress: indexingInProgress || void 0,
+            advisoryMessage
           });
         }
       }
@@ -1941,20 +2053,44 @@ async function searchKnowledge(query, projectFilter) {
 async function indexKnowledge(projectName, force = false) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
-  const project = projects.find((p) => p.name === projectName || p.path && p.path === projectName);
+  const project = projects.find((p2) => p2.name === projectName || p2.path && p2.path === projectName);
   if (!project) {
-    return { success: false, message: `Project '${projectName}' not found`, filesIndexed: 0, filesSkipped: 0 };
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: `Project '${projectName}' not found`,
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
   }
   const projConfig = config.projects.find(
-    (p) => p.path && normalizeProjectPath(p.path) === normalizeProjectPath(project.sourcePath || project.path) || !p.path && p.name === project.name
+    (p2) => p2.path && normalizeProjectPath(p2.path) === normalizeProjectPath(project.sourcePath || project.path) || !p2.path && p2.name === project.name
   ) || (project.source === "global" ? { semanticSearch: { enabled: true, model: "Xenova/all-MiniLM-L6-v2" } } : void 0);
   const isEnabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled;
   if (!isEnabled) {
-    return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0, filesSkipped: 0 };
+    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 (!fs14.existsSync(scanRoot)) {
-    return { success: false, message: "Project root not found", filesIndexed: 0, filesSkipped: 0 };
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: "Project root not found",
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
   }
   const INDEXABLE_EXTENSIONS = [
     ".ts",
@@ -1995,18 +2131,37 @@ async function indexKnowledge(projectName, force = false) {
     ".less"
   ];
   const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor"];
-  try {
+  const runIndexing = async () => {
     const indexPath = path16.join(project.knowledgePath || path16.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
     const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
     const rag = new RAGService(indexPath, model);
     let indexed = 0;
     let skipped = 0;
+    let itemsTotal = 0;
+    let itemsDone = 0;
+    const shouldSkipDir = (dirName) => SKIP_DIRS.includes(dirName) || dirName.startsWith(".");
+    const preCount = (dir) => {
+      const entries = fs14.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path16.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (shouldSkipDir(entry.name)) continue;
+          preCount(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path16.extname(entry.name).toLowerCase();
+          if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
+          itemsTotal++;
+        }
+      }
+    };
+    preCount(scanRoot);
+    indexingJobs.update(project.name, { itemsTotal });
     const scanDir = async (dir) => {
       const entries = fs14.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path16.join(dir, entry.name);
         if (entry.isDirectory()) {
-          if (SKIP_DIRS.includes(entry.name) || entry.name.startsWith(".")) {
+          if (shouldSkipDir(entry.name)) {
             continue;
           }
           await scanDir(fullPath);
@@ -2016,6 +2171,7 @@ async function indexKnowledge(projectName, force = false) {
             continue;
           }
           try {
+            indexingJobs.update(project.name, { currentItem: fullPath, itemsDone });
             const stat = fs14.statSync(fullPath);
             const mtime = force ? void 0 : stat.mtimeMs;
             const content = fs14.readFileSync(fullPath, "utf-8");
@@ -2026,6 +2182,12 @@ async function indexKnowledge(projectName, force = false) {
               skipped++;
             }
           } catch (err) {
+          } finally {
+            itemsDone++;
+            indexingJobs.update(project.name, { itemsDone });
+            if (itemsDone % 10 === 0) {
+              await new Promise((resolve2) => setImmediate(resolve2));
+            }
           }
         }
       }
@@ -2033,15 +2195,28 @@ async function indexKnowledge(projectName, force = false) {
     await scanDir(scanRoot);
     rag.markFullIndex();
     const stats = rag.getStats();
-    return {
-      success: true,
-      message: `Indexed ${indexed} files, skipped ${skipped} unchanged. Total: ${stats.totalChunks} chunks from ${stats.totalFiles} files.`,
-      filesIndexed: indexed,
-      filesSkipped: skipped
-    };
-  } catch (error) {
-    return { success: false, message: `Indexing failed: ${error}`, filesIndexed: 0, filesSkipped: 0 };
-  }
+    const message = `Indexed ${indexed} files, skipped ${skipped} unchanged. Total: ${stats.totalChunks} chunks from ${stats.totalFiles} files.`;
+    logger.info(`[RAG] ${project.name}: ${message}`);
+    indexingJobs.update(project.name, { currentItem: void 0 });
+  };
+  const startResult = indexingJobs.startOrStatus(project.name, runIndexing);
+  const p = startResult.progress;
+  return {
+    state: startResult.state,
+    status: startResult.status,
+    success: startResult.status === "started" || startResult.status === "already_running",
+    message: startResult.status === "started" ? `Indexing started in background for '${project.name}'.` : `Indexing already running for '${project.name}'.`,
+    filesIndexed: 0,
+    filesSkipped: 0,
+    progress: {
+      itemsDone: p.itemsDone,
+      itemsTotal: p.itemsTotal,
+      currentItem: p.currentItem,
+      startedAt: p.startedAt,
+      completedAt: p.completedAt,
+      lastError: p.lastError
+    }
+  };
 }
 function getContextPreamble() {
   const projects = getExposedProjects();
@@ -2189,6 +2364,7 @@ var init_resources = __esm({
     init_detection();
     init_detection_service();
     init_rag();
+    init_indexing_jobs();
     init_paths();
   }
 });
@@ -2905,8 +3081,8 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs22 = await import("fs");
-  const path20 = await import("path");
+  const fs23 = await import("fs");
+  const path21 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -2920,8 +3096,8 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs22.existsSync(resolvedPath)) {
-      fs22.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs23.existsSync(resolvedPath)) {
+      fs23.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
@@ -2929,7 +3105,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:
-${path20.join(resolvedPath, "mcp.yaml")}`,
+${path21.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -3169,46 +3345,234 @@ var init_SimpleSelect = __esm({
   }
 });
 
+// src/mcp/ui/lib/tasks-fs.ts
+import * as fs16 from "fs";
+import * as path18 from "path";
+function detectStorageModeFromConfig(workspaceRoot) {
+  const configPath = getConfigPath(workspaceRoot);
+  try {
+    const rrceHome = getEffectiveGlobalBase();
+    if (configPath.startsWith(rrceHome)) {
+      return "global";
+    }
+    if (fs16.existsSync(configPath)) {
+      const content = fs16.readFileSync(configPath, "utf-8");
+      if (content.includes("mode: workspace")) return "workspace";
+      if (content.includes("mode: global")) return "global";
+    }
+  } catch {
+  }
+  return "global";
+}
+function getEffectiveGlobalBase() {
+  const dummy = resolveDataPath("global", "__rrce_dummy__", "");
+  return path18.dirname(path18.dirname(dummy));
+}
+function getProjectRRCEData(project) {
+  const workspaceRoot = project.sourcePath || project.path;
+  const mode = detectStorageModeFromConfig(workspaceRoot);
+  return resolveDataPath(mode, project.name, workspaceRoot);
+}
+function listProjectTasks(project) {
+  const rrceData = getProjectRRCEData(project);
+  const tasksPath = path18.join(rrceData, "tasks");
+  if (!fs16.existsSync(tasksPath)) {
+    return { projectName: project.name, tasksPath, tasks: [] };
+  }
+  const tasks = [];
+  try {
+    const entries = fs16.readdirSync(tasksPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const metaPath = path18.join(tasksPath, entry.name, "meta.json");
+      if (!fs16.existsSync(metaPath)) continue;
+      try {
+        const raw = fs16.readFileSync(metaPath, "utf-8");
+        const meta = JSON.parse(raw);
+        if (!meta.task_slug) meta.task_slug = entry.name;
+        tasks.push(meta);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  tasks.sort((a, b) => {
+    const aTime = Date.parse(a.updated_at || a.created_at || "") || 0;
+    const bTime = Date.parse(b.updated_at || b.created_at || "") || 0;
+    if (aTime !== bTime) return bTime - aTime;
+    return String(a.task_slug).localeCompare(String(b.task_slug));
+  });
+  return { projectName: project.name, tasksPath, tasks };
+}
+function updateTaskStatus(project, taskSlug, status) {
+  const rrceData = getProjectRRCEData(project);
+  const metaPath = path18.join(rrceData, "tasks", taskSlug, "meta.json");
+  if (!fs16.existsSync(metaPath)) {
+    return { ok: false, error: `meta.json not found for task '${taskSlug}'` };
+  }
+  try {
+    const meta = JSON.parse(fs16.readFileSync(metaPath, "utf-8"));
+    const next = {
+      ...meta,
+      status,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs16.writeFileSync(metaPath, JSON.stringify(next, null, 2));
+    return { ok: true, meta: next };
+  } catch (e) {
+    return { ok: false, error: String(e) };
+  }
+}
+var init_tasks_fs = __esm({
+  "src/mcp/ui/lib/tasks-fs.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
 // src/mcp/ui/ProjectsView.tsx
-import { useState as useState2 } from "react";
+import { useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
 import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
 import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-var ProjectsView;
+function nextStatus(current) {
+  const idx = STATUS_CYCLE.indexOf(current || "");
+  if (idx === -1) return STATUS_CYCLE[0];
+  return STATUS_CYCLE[(idx + 1) % STATUS_CYCLE.length];
+}
+function projectKey(p) {
+  return p.sourcePath ?? p.path;
+}
+function formatProjectLabel(p) {
+  const root = p.sourcePath ?? p.path;
+  return `${p.name} (${p.source})${root ? ` - ${root}` : ""}`;
+}
+var STATUS_CYCLE, ProjectsView;
 var init_ProjectsView = __esm({
   "src/mcp/ui/ProjectsView.tsx"() {
     "use strict";
     init_SimpleSelect();
     init_config();
+    init_tasks_fs();
+    STATUS_CYCLE = ["pending", "in_progress", "blocked", "complete"];
     ProjectsView = ({ config: initialConfig, projects: allProjects, onConfigChange }) => {
       const [config, setConfig] = useState2(initialConfig);
-      useInput2((input) => {
-        if (input === "a") {
-          const newConfig = {
-            ...config,
-            defaults: {
-              ...config.defaults,
-              includeNew: !config.defaults.includeNew
+      const [mode, setMode] = useState2("expose");
+      const [expanded, setExpanded] = useState2(() => /* @__PURE__ */ new Set());
+      const [selectedIndex, setSelectedIndex] = useState2(0);
+      const [taskCache, setTaskCache] = useState2({});
+      const [errorLine, setErrorLine] = useState2(null);
+      const sortedProjects = useMemo2(() => {
+        return [...allProjects].sort((a, b) => {
+          const byName = a.name.localeCompare(b.name);
+          if (byName !== 0) return byName;
+          return projectKey(a).localeCompare(projectKey(b));
+        });
+      }, [allProjects]);
+      const refreshTasksForProject = (project) => {
+        const res = listProjectTasks(project);
+        setTaskCache((prev) => ({ ...prev, [projectKey(project)]: res.tasks }));
+      };
+      const refreshAllTasks = () => {
+        const next = {};
+        for (const p of sortedProjects) {
+          next[projectKey(p)] = listProjectTasks(p).tasks;
+        }
+        setTaskCache(next);
+      };
+      useInput2((input, key) => {
+        if (input === "t") {
+          setErrorLine(null);
+          setMode((prev) => prev === "expose" ? "tasks" : "expose");
+          return;
+        }
+        if (mode === "expose") {
+          if (input === "a") {
+            const newConfig = {
+              ...config,
+              defaults: {
+                ...config.defaults,
+                includeNew: !config.defaults.includeNew
+              }
+            };
+            saveMCPConfig(newConfig);
+            setConfig(newConfig);
+            onConfigChange?.();
+          }
+          return;
+        }
+        if (mode === "tasks") {
+          if (input === "R") {
+            setErrorLine(null);
+            refreshAllTasks();
+            return;
+          }
+          if (key.upArrow) {
+            setSelectedIndex((prev) => prev > 0 ? prev - 1 : Math.max(0, flattenedRows.length - 1));
+            return;
+          }
+          if (key.downArrow) {
+            setSelectedIndex((prev) => prev < flattenedRows.length - 1 ? prev + 1 : 0);
+            return;
+          }
+          if (key.return) {
+            const row = flattenedRows[selectedIndex];
+            if (row?.kind === "project") {
+              const k = projectKey(row.project);
+              const next = new Set(expanded);
+              if (next.has(k)) {
+                next.delete(k);
+              } else {
+                next.add(k);
+                refreshTasksForProject(row.project);
+              }
+              setExpanded(next);
             }
-          };
-          saveMCPConfig(newConfig);
-          setConfig(newConfig);
-          if (onConfigChange) onConfigChange();
+            return;
+          }
+          if (input === "s") {
+            const row = flattenedRows[selectedIndex];
+            if (row?.kind === "task") {
+              setErrorLine(null);
+              const desired = nextStatus(row.task.status);
+              const result = updateTaskStatus(row.project, row.task.task_slug, desired);
+              if (!result.ok) {
+                setErrorLine(`Failed to update status: ${result.error}`);
+                return;
+              }
+              setTaskCache((prev) => {
+                const k = projectKey(row.project);
+                const tasks = prev[k] || [];
+                const updated = tasks.map((t) => t.task_slug === row.task.task_slug ? result.meta : t);
+                return { ...prev, [k]: updated };
+              });
+            }
+            return;
+          }
         }
       });
-      const projectItems = allProjects.map((p) => {
-        const projectConfig = config.projects.find(
-          (c) => c.path && c.path === p.path || p.source === "global" && c.name === p.name || !c.path && c.name === p.name
-        );
-        const isExposed = projectConfig ? projectConfig.expose : config.defaults.includeNew;
-        return {
-          label: p.name + ` (${p.source})` + (p.path ? ` - ${p.path}` : ""),
-          value: p.path,
-          // Standardized ID: Use root path
-          key: p.path,
-          exposed: isExposed
-        };
-      });
-      const initialSelected = projectItems.filter((p) => p.exposed).map((p) => p.value);
+      useEffect2(() => {
+        setSelectedIndex((prev) => {
+          if (flattenedRows.length === 0) return 0;
+          return Math.min(prev, flattenedRows.length - 1);
+        });
+      }, [mode, allProjects, expanded, taskCache]);
+      const projectItems = useMemo2(() => {
+        return allProjects.map((p) => {
+          const projectConfig = config.projects.find(
+            (c) => c.path && c.path === p.path || p.source === "global" && c.name === p.name || !c.path && c.name === p.name
+          );
+          const isExposed = projectConfig ? projectConfig.expose : config.defaults.includeNew;
+          return {
+            label: formatProjectLabel(p),
+            value: p.path,
+            key: p.path,
+            exposed: isExposed
+          };
+        });
+      }, [allProjects, config]);
+      const initialSelected = useMemo2(() => {
+        return projectItems.filter((p) => p.exposed).map((p) => p.value);
+      }, [projectItems]);
       const handleSubmit = (selectedIds) => {
         let newConfig = { ...config };
         projectItems.forEach((item) => {
@@ -3228,33 +3592,135 @@ var init_ProjectsView = __esm({
         });
         saveMCPConfig(newConfig);
         setConfig(newConfig);
-        if (onConfigChange) onConfigChange();
+        onConfigChange?.();
       };
+      const flattenedRows = useMemo2(() => {
+        const rows = [];
+        for (const p of sortedProjects) {
+          rows.push({ kind: "project", project: p });
+          const k = projectKey(p);
+          if (!expanded.has(k)) continue;
+          const tasks = taskCache[k] || [];
+          for (const t of tasks) {
+            rows.push({ kind: "task", project: p, task: t });
+          }
+          if ((taskCache[k] || []).length === 0) {
+            rows.push({ kind: "task", project: p, task: { task_slug: "__none__", title: "(no tasks)", status: "" } });
+          }
+        }
+        return rows;
+      }, [sortedProjects, expanded, taskCache]);
+      const selectedRow = flattenedRows[selectedIndex];
+      const selectedTask = selectedRow?.kind === "task" && selectedRow.task.task_slug !== "__none__" ? selectedRow.task : null;
+      if (mode === "expose") {
+        return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan", flexGrow: 1, children: [
+          /* @__PURE__ */ jsxs3(Box4, { justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: " Projects (Expose Mode) " }),
+            /* @__PURE__ */ jsxs3(Box4, { children: [
+              /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Auto-expose new: " }),
+              /* @__PURE__ */ jsx4(Text4, { color: config.defaults.includeNew ? "green" : "red", children: config.defaults.includeNew ? "ON" : "OFF" }),
+              /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " (Press 'a' to toggle)" })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx4(Text4, { color: "dim", children: " Space toggles, Enter saves. Press 't' to switch to Tasks Mode." }),
+          /* @__PURE__ */ jsx4(Box4, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx4(
+            SimpleSelect,
+            {
+              message: "",
+              items: projectItems,
+              isMulti: true,
+              initialSelected,
+              onSelect: () => {
+              },
+              onSubmit: handleSubmit,
+              onCancel: () => {
+              }
+            },
+            JSON.stringify(initialSelected) + config.defaults.includeNew
+          ) })
+        ] });
+      }
       return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan", flexGrow: 1, children: [
         /* @__PURE__ */ jsxs3(Box4, { justifyContent: "space-between", children: [
-          /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: " Exposed Projects " }),
-          /* @__PURE__ */ jsxs3(Box4, { children: [
-            /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Auto-expose new: " }),
-            /* @__PURE__ */ jsx4(Text4, { color: config.defaults.includeNew ? "green" : "red", children: config.defaults.includeNew ? "ON" : "OFF" }),
-            /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " (Press 'a' to toggle)" })
-          ] })
+          /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: " Projects (Tasks Mode) " }),
+          /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "t:Expose  Enter:Expand  s:Status  R:Refresh" })
         ] }),
-        /* @__PURE__ */ jsx4(Text4, { color: "dim", children: " Select projects to expose via the MCP server. Use Space to toggle, Enter to save." }),
-        /* @__PURE__ */ jsx4(Box4, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx4(
-          SimpleSelect,
-          {
-            message: "",
-            items: projectItems,
-            isMulti: true,
-            initialSelected,
-            onSelect: () => {
-            },
-            onSubmit: handleSubmit,
-            onCancel: () => {
-            }
-          },
-          JSON.stringify(initialSelected) + config.defaults.includeNew
-        ) })
+        errorLine && /* @__PURE__ */ jsx4(Box4, { marginTop: 0, children: /* @__PURE__ */ jsx4(Text4, { color: "red", children: errorLine }) }),
+        /* @__PURE__ */ jsxs3(Box4, { marginTop: 1, flexDirection: "row", flexGrow: 1, children: [
+          /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: "55%", children: [
+            flattenedRows.length === 0 ? /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "No projects detected." }) : flattenedRows.map((row, idx) => {
+              const isSel = idx === selectedIndex;
+              if (row.kind === "project") {
+                const k = projectKey(row.project);
+                const isOpen = expanded.has(k);
+                const count = (taskCache[k] || []).length;
+                return /* @__PURE__ */ jsxs3(Box4, { children: [
+                  /* @__PURE__ */ jsx4(Text4, { color: isSel ? "cyan" : "white", children: isSel ? "> " : "  " }),
+                  /* @__PURE__ */ jsxs3(Text4, { color: isSel ? "cyan" : "white", children: [
+                    isOpen ? "\u25BE " : "\u25B8 ",
+                    formatProjectLabel(row.project)
+                  ] }),
+                  /* @__PURE__ */ jsxs3(Text4, { color: "dim", children: [
+                    " ",
+                    count > 0 ? ` (tasks: ${count})` : ""
+                  ] })
+                ] }, `p:${k}`);
+              }
+              const taskLabel = row.task.title || row.task.task_slug;
+              const status = row.task.status || "";
+              return /* @__PURE__ */ jsxs3(Box4, { children: [
+                /* @__PURE__ */ jsx4(Text4, { color: isSel ? "cyan" : "white", children: isSel ? "> " : "  " }),
+                /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "    - " }),
+                /* @__PURE__ */ jsx4(Text4, { color: isSel ? "cyan" : "white", children: taskLabel }),
+                row.task.task_slug !== "__none__" && /* @__PURE__ */ jsx4(Text4, { color: status === "complete" ? "green" : status === "blocked" ? "red" : "yellow", children: `  [${status}]` })
+              ] }, `t:${projectKey(row.project)}:${row.task.task_slug}`);
+            }),
+            /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "\u25B2/\u25BC navigate \u2022 Enter expand/collapse \u2022 s cycle status \u2022 R refresh \u2022 t expose mode" }) })
+          ] }),
+          /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", width: "45%", paddingLeft: 2, children: !selectedTask ? /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "Select a task to view details." }) : /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: selectedTask.title || selectedTask.task_slug }),
+            selectedTask.summary && /* @__PURE__ */ jsx4(Text4, { children: selectedTask.summary }),
+            /* @__PURE__ */ jsxs3(Box4, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs3(Text4, { children: [
+                /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "Status: " }),
+                /* @__PURE__ */ jsx4(Text4, { children: selectedTask.status || "unknown" })
+              ] }),
+              /* @__PURE__ */ jsxs3(Text4, { children: [
+                /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "Updated: " }),
+                /* @__PURE__ */ jsx4(Text4, { children: selectedTask.updated_at || "\u2014" })
+              ] }),
+              /* @__PURE__ */ jsxs3(Text4, { children: [
+                /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "Tags: " }),
+                /* @__PURE__ */ jsx4(Text4, { children: (selectedTask.tags || []).join(", ") || "\u2014" })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs3(Box4, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Checklist" }),
+              (selectedTask.checklist || []).length === 0 ? /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "\u2014" }) : (selectedTask.checklist || []).slice(0, 12).map((c, i) => /* @__PURE__ */ jsxs3(Text4, { children: [
+                /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "- " }),
+                c.label || c.id || "item",
+                " ",
+                /* @__PURE__ */ jsxs3(Text4, { color: "dim", children: [
+                  "[",
+                  c.status || "pending",
+                  "]"
+                ] })
+              ] }, c.id || i))
+            ] }),
+            /* @__PURE__ */ jsxs3(Box4, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Agents" }),
+              !selectedTask.agents ? /* @__PURE__ */ jsx4(Text4, { color: "dim", children: "\u2014" }) : Object.entries(selectedTask.agents).map(([agent, info]) => /* @__PURE__ */ jsxs3(Text4, { children: [
+                /* @__PURE__ */ jsxs3(Text4, { color: "dim", children: [
+                  "- ",
+                  agent,
+                  ": "
+                ] }),
+                info?.status || "\u2014",
+                info?.artifact ? ` (${info.artifact})` : ""
+              ] }, agent))
+            ] })
+          ] }) })
+        ] })
       ] });
     };
   }
@@ -3433,20 +3899,21 @@ var init_StatusBoard = __esm({
 });
 
 // src/mcp/ui/IndexingStatus.tsx
-import { useState as useState4, useEffect as useEffect3 } from "react";
+import { useState as useState4, useEffect as useEffect4 } from "react";
 import { Box as Box9, Text as Text9 } from "ink";
 import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
 var IndexingStatus;
 var init_IndexingStatus = __esm({
   "src/mcp/ui/IndexingStatus.tsx"() {
     "use strict";
+    init_indexing_jobs();
     init_rag();
     init_resources();
     init_config_utils();
     IndexingStatus = ({ projects, config }) => {
       const [stats, setStats] = useState4([]);
       const [loading, setLoading] = useState4(true);
-      useEffect3(() => {
+      useEffect4(() => {
         const fetchStats = async () => {
           const newStats = [];
           for (const project of projects) {
@@ -3456,9 +3923,14 @@ var init_IndexingStatus = __esm({
             }
             const enabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled || false;
             if (!enabled) {
+              const prog = indexingJobs.getProgress(project.name);
               newStats.push({
                 projectName: project.name,
                 enabled: false,
+                state: prog.state,
+                itemsDone: prog.itemsDone,
+                itemsTotal: prog.itemsTotal,
+                currentItem: prog.currentItem,
                 totalFiles: 0,
                 totalChunks: 0
               });
@@ -3468,17 +3940,27 @@ var init_IndexingStatus = __esm({
               const indexPath = getRAGIndexPath(project);
               const rag = new RAGService(indexPath, "dummy");
               const s = rag.getStats();
+              const prog = indexingJobs.getProgress(project.name);
               newStats.push({
                 projectName: project.name,
                 enabled: true,
+                state: prog.state,
+                itemsDone: prog.itemsDone,
+                itemsTotal: prog.itemsTotal,
+                currentItem: prog.currentItem,
                 totalFiles: s.totalFiles,
                 totalChunks: s.totalChunks,
                 lastFullIndex: s.lastFullIndex
               });
             } catch (e) {
+              const prog = indexingJobs.getProgress(project.name);
               newStats.push({
                 projectName: project.name,
                 enabled: true,
+                state: prog.state,
+                itemsDone: prog.itemsDone,
+                itemsTotal: prog.itemsTotal,
+                currentItem: prog.currentItem,
                 totalFiles: 0,
                 totalChunks: 0,
                 error: String(e)
@@ -3501,13 +3983,16 @@ var init_IndexingStatus = __esm({
           /* @__PURE__ */ jsxs8(Box9, { children: [
             /* @__PURE__ */ jsx9(Box9, { width: 25, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Project" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Status" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "State" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 18, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Progress" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Indexed Files" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Total Chunks" }) }),
             /* @__PURE__ */ jsx9(Box9, { children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Last Index" }) })
           ] }),
           stats.length === 0 ? /* @__PURE__ */ jsx9(Text9, { color: "dim", children: "No exposed projects found." }) : stats.map((s) => /* @__PURE__ */ jsxs8(Box9, { marginTop: 0, children: [
             /* @__PURE__ */ jsx9(Box9, { width: 25, children: /* @__PURE__ */ jsx9(Text9, { color: "white", children: s.projectName }) }),
-            /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { color: s.enabled ? "green" : "dim", children: s.enabled ? "Enabled" : "Disabled" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { color: s.state === "running" ? "yellow" : s.state === "failed" ? "red" : s.enabled ? "green" : "dim", children: s.enabled ? s.state : "disabled" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 18, children: /* @__PURE__ */ jsx9(Text9, { children: s.state === "running" ? `${s.itemsDone}/${s.itemsTotal ?? "?"}` : "-" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { children: s.enabled ? s.totalFiles : "-" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { children: s.enabled ? s.totalChunks : "-" }) }),
             /* @__PURE__ */ jsx9(Box9, { children: /* @__PURE__ */ jsx9(Text9, { children: s.lastFullIndex ? new Date(s.lastFullIndex).toLocaleTimeString() : "-" }) })
@@ -3573,9 +4058,9 @@ var App_exports = {};
 __export(App_exports, {
   App: () => App
 });
-import { useState as useState5, useEffect as useEffect4, useMemo as useMemo2, useCallback } from "react";
+import { useState as useState5, useEffect as useEffect5, useMemo as useMemo3, useCallback } from "react";
 import { Box as Box11, useInput as useInput4, useApp } from "ink";
-import fs16 from "fs";
+import fs17 from "fs";
 import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 var App;
 var init_App = __esm({
@@ -3611,17 +4096,17 @@ var init_App = __esm({
         setConfig(loadMCPConfig());
         setProjects(scanForProjects());
       }, []);
-      const exposedProjects = useMemo2(
+      const exposedProjects = useMemo3(
         () => projects.filter((p) => isProjectExposed(config, p.name, p.path)),
         [projects, config]
       );
-      const isRAGEnabled = useMemo2(() => {
+      const isRAGEnabled = useMemo3(() => {
         return exposedProjects.some((p) => {
           const cfg = findProjectConfig(config, { name: p.name, path: p.path });
           return cfg?.semanticSearch?.enabled || p.semanticSearchEnabled;
         });
       }, [exposedProjects, config]);
-      const tabs = useMemo2(() => {
+      const tabs = useMemo3(() => {
         const baseTabs = [
           { id: "overview", label: "Overview" },
           { id: "logs", label: "Logs" },
@@ -3641,7 +4126,7 @@ var init_App = __esm({
         installStatus.vscodeGlobal,
         installStatus.vscodeWorkspace
       ].filter(Boolean).length;
-      useEffect4(() => {
+      useEffect5(() => {
         const start = async () => {
           const status = getMCPServerStatus();
           if (!status.running) {
@@ -3657,21 +4142,21 @@ var init_App = __esm({
         };
         start();
       }, []);
-      useEffect4(() => {
+      useEffect5(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs16.existsSync(logPath)) {
-          const stats = fs16.statSync(logPath);
+        if (fs17.existsSync(logPath)) {
+          const stats = fs17.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs16.existsSync(logPath)) {
-            const stats = fs16.statSync(logPath);
+          if (fs17.existsSync(logPath)) {
+            const stats = fs17.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs16.openSync(logPath, "r");
-              fs16.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs16.closeSync(fd);
+              const fd = fs17.openSync(logPath, "r");
+              fs17.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs17.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -3882,7 +4367,7 @@ var init_mcp = __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 } from "@clack/prompts";
 import pc13 from "picocolors";
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 
 // src/lib/git.ts
 import { execSync } from "child_process";
@@ -4556,7 +5041,7 @@ async function handlePostSetup(config, workspacePath, workspaceName, linkedProje
 init_paths();
 import { multiselect as multiselect4, spinner as spinner3, note as note7, outro as outro3, cancel as cancel3, isCancel as isCancel8, confirm as confirm6 } from "@clack/prompts";
 import pc9 from "picocolors";
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 init_detection();
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
@@ -4595,7 +5080,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner3();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs17.readFileSync(configFilePath, "utf-8");
+  let configContent = fs18.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -4622,7 +5107,7 @@ linked_projects:
 `;
     });
   }
-  fs17.writeFileSync(configFilePath, configContent);
+  fs18.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -4657,15 +5142,15 @@ linked_projects:
 init_paths();
 import { confirm as confirm7, spinner as spinner4, note as note8, outro as outro4, cancel as cancel4, isCancel as isCancel9 } from "@clack/prompts";
 import pc10 from "picocolors";
-import * as fs18 from "fs";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as path19 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path18.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path19.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs18.existsSync(path18.join(localPath, dir))
+    (dir) => fs19.existsSync(path19.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro4(pc10.yellow("No data found in workspace storage to sync."));
@@ -4691,8 +5176,8 @@ Destination: ${pc10.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path18.join(localPath, dir);
-      const destDir = path18.join(globalPath, dir);
+      const srcDir = path19.join(localPath, dir);
+      const destDir = path19.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -4719,8 +5204,8 @@ init_paths();
 init_prompts();
 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 fs19 from "fs";
-import * as path19 from "path";
+import * as fs20 from "fs";
+import * as path20 from "path";
 import { stringify as stringify3 } from "yaml";
 init_install();
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
@@ -4740,8 +5225,8 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     ];
     const configFilePath = getConfigPath(workspacePath);
     const ideTargets = [];
-    if (fs19.existsSync(configFilePath)) {
-      const configContent = fs19.readFileSync(configFilePath, "utf-8");
+    if (fs20.existsSync(configFilePath)) {
+      const configContent = fs20.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");
@@ -4767,17 +5252,17 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path19.join(agentCoreDir, "templates"), "templates", [dataPath]);
-      copyDirToAllStoragePaths(path19.join(agentCoreDir, "prompts"), "prompts", [dataPath]);
-      copyDirToAllStoragePaths(path19.join(agentCoreDir, "docs"), "docs", [dataPath]);
+      copyDirToAllStoragePaths(path20.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path20.join(agentCoreDir, "prompts"), "prompts", [dataPath]);
+      copyDirToAllStoragePaths(path20.join(agentCoreDir, "docs"), "docs", [dataPath]);
     }
     const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-    ensureDir(path19.join(rrceHome, "templates"));
-    ensureDir(path19.join(rrceHome, "docs"));
-    copyDirRecursive(path19.join(agentCoreDir, "templates"), path19.join(rrceHome, "templates"));
-    copyDirRecursive(path19.join(agentCoreDir, "docs"), path19.join(rrceHome, "docs"));
-    if (fs19.existsSync(configFilePath)) {
-      const configContent = fs19.readFileSync(configFilePath, "utf-8");
+    ensureDir(path20.join(rrceHome, "templates"));
+    ensureDir(path20.join(rrceHome, "docs"));
+    copyDirRecursive(path20.join(agentCoreDir, "templates"), path20.join(rrceHome, "templates"));
+    copyDirRecursive(path20.join(agentCoreDir, "docs"), path20.join(rrceHome, "docs"));
+    if (fs20.existsSync(configFilePath)) {
+      const configContent = fs20.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
@@ -4824,14 +5309,14 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
 function updateOpenCodeAgents(prompts, mode, primaryDataPath) {
   if (mode === "global") {
     try {
-      const promptsDir = path19.join(path19.dirname(OPENCODE_CONFIG), "prompts");
+      const promptsDir = path20.join(path20.dirname(OPENCODE_CONFIG), "prompts");
       ensureDir(promptsDir);
       let opencodeConfig = { $schema: "https://opencode.ai/config.json" };
-      if (fs19.existsSync(OPENCODE_CONFIG)) {
-        opencodeConfig = JSON.parse(fs19.readFileSync(OPENCODE_CONFIG, "utf-8"));
+      if (fs20.existsSync(OPENCODE_CONFIG)) {
+        opencodeConfig = JSON.parse(fs20.readFileSync(OPENCODE_CONFIG, "utf-8"));
       }
       if (!opencodeConfig.agent) opencodeConfig.agent = {};
-      const currentAgentNames = prompts.map((p) => path19.basename(p.filePath, ".md"));
+      const currentAgentNames = prompts.map((p) => path20.basename(p.filePath, ".md"));
       const existingAgentNames = Object.keys(opencodeConfig.agent);
       const rrceAgentPrefixes = ["init", "research", "planning", "executor", "doctor", "documentation", "sync"];
       for (const existingName of existingAgentNames) {
@@ -4839,30 +5324,30 @@ function updateOpenCodeAgents(prompts, mode, primaryDataPath) {
         const stillExists = currentAgentNames.includes(existingName);
         if (isRrceAgent && !stillExists) {
           delete opencodeConfig.agent[existingName];
-          const oldPromptFile = path19.join(promptsDir, `rrce-${existingName}.md`);
-          if (fs19.existsSync(oldPromptFile)) {
-            fs19.unlinkSync(oldPromptFile);
+          const oldPromptFile = path20.join(promptsDir, `rrce-${existingName}.md`);
+          if (fs20.existsSync(oldPromptFile)) {
+            fs20.unlinkSync(oldPromptFile);
           }
         }
       }
       for (const prompt of prompts) {
-        const baseName = path19.basename(prompt.filePath, ".md");
+        const baseName = path20.basename(prompt.filePath, ".md");
         const promptFileName = `rrce-${baseName}.md`;
-        const promptFilePath = path19.join(promptsDir, promptFileName);
-        fs19.writeFileSync(promptFilePath, prompt.content);
+        const promptFilePath = path20.join(promptsDir, promptFileName);
+        fs20.writeFileSync(promptFilePath, prompt.content);
         const agentConfig = convertToOpenCodeAgent(prompt, true, `./prompts/${promptFileName}`);
         opencodeConfig.agent[baseName] = agentConfig;
       }
-      fs19.writeFileSync(OPENCODE_CONFIG, JSON.stringify(opencodeConfig, null, 2) + "\n");
+      fs20.writeFileSync(OPENCODE_CONFIG, JSON.stringify(opencodeConfig, null, 2) + "\n");
     } catch (e) {
       console.error("Failed to update global OpenCode config with agents:", e);
     }
   } else {
-    const opencodeBaseDir = path19.join(primaryDataPath, ".opencode", "agent");
+    const opencodeBaseDir = path20.join(primaryDataPath, ".opencode", "agent");
     ensureDir(opencodeBaseDir);
     clearDirectory(opencodeBaseDir);
     for (const prompt of prompts) {
-      const baseName = path19.basename(prompt.filePath, ".md");
+      const baseName = path20.basename(prompt.filePath, ".md");
       const agentConfig = convertToOpenCodeAgent(prompt);
       const content = `---
 ${stringify3({
@@ -4871,22 +5356,22 @@ ${stringify3({
         tools: agentConfig.tools
       })}---
 ${agentConfig.prompt}`;
-      fs19.writeFileSync(path19.join(opencodeBaseDir, `${baseName}.md`), content);
+      fs20.writeFileSync(path20.join(opencodeBaseDir, `${baseName}.md`), content);
     }
   }
 }
 function clearDirectory(dirPath) {
-  if (!fs19.existsSync(dirPath)) return;
-  const entries = fs19.readdirSync(dirPath, { withFileTypes: true });
+  if (!fs20.existsSync(dirPath)) return;
+  const entries = fs20.readdirSync(dirPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile()) {
-      fs19.unlinkSync(path19.join(dirPath, entry.name));
+      fs20.unlinkSync(path20.join(dirPath, entry.name));
     }
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path19.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path19.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path20.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path20.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -4900,7 +5385,7 @@ function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot,
 // 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 fs20 from "fs";
+import * as fs21 from "fs";
 init_detection();
 init_config();
 async function runDeleteGlobalProjectFlow(availableProjects) {
@@ -4944,8 +5429,8 @@ Are you sure?`,
     for (const projectName of projectsToDelete) {
       const project = globalProjects.find((p) => p.name === projectName);
       if (!project) continue;
-      if (fs20.existsSync(project.dataPath)) {
-        fs20.rmSync(project.dataPath, { recursive: true, force: true });
+      if (fs21.existsSync(project.dataPath)) {
+        fs21.rmSync(project.dataPath, { recursive: true, force: true });
       }
       const newConfig = removeProjectConfig(mcpConfig, projectName);
       configChanged = true;
@@ -4991,11 +5476,11 @@ Workspace: ${pc13.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  let isAlreadyConfigured = fs21.existsSync(configFilePath);
+  let isAlreadyConfigured = fs22.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs21.readFileSync(configFilePath, "utf-8");
+      const configContent = fs22.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
@@ -5012,7 +5497,7 @@ Workspace: ${pc13.bold(workspaceName)}`,
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs21.existsSync(localDataPath);
+  const hasLocalData = fs22.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     menuOptions.push({

package/package.json

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