rrce-workflow 0.2.62 → 0.2.64

package/dist/index.js

@@ -24,46 +24,86 @@ var init_git = __esm({
   }
 });
 
-// src/lib/paths.ts
+// src/lib/preferences.ts
 import * as fs from "fs";
 import * as path from "path";
+function getPreferencesPath() {
+  const home = process.env.HOME || "~";
+  return path.join(home, ".rrce-workflow", "preferences.json");
+}
+function loadUserPreferences() {
+  const prefPath = getPreferencesPath();
+  if (!fs.existsSync(prefPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(prefPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveUserPreferences(prefs) {
+  const prefPath = getPreferencesPath();
+  ensureDir(path.dirname(prefPath));
+  const current = loadUserPreferences();
+  const refined = { ...current, ...prefs };
+  fs.writeFileSync(prefPath, JSON.stringify(refined, null, 2));
+}
+var init_preferences = __esm({
+  "src/lib/preferences.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/lib/paths.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function getEffectiveGlobalPath() {
+  const prefs = loadUserPreferences();
+  if (prefs.useCustomGlobalPath && prefs.defaultGlobalPath) {
+    return prefs.defaultGlobalPath;
+  }
+  return RRCE_HOME;
+}
 function detectWorkspaceRoot() {
   if (RRCE_WORKSPACE) {
     return RRCE_WORKSPACE;
   }
   let current = process.cwd();
   while (current !== "/") {
-    if (fs.existsSync(path.join(current, ".git")) || fs.existsSync(path.join(current, ".rrce-workflow", "config.yaml")) || fs.existsSync(path.join(current, ".rrce-workflow.yaml"))) {
+    if (fs2.existsSync(path2.join(current, ".git")) || fs2.existsSync(path2.join(current, ".rrce-workflow", "config.yaml")) || fs2.existsSync(path2.join(current, ".rrce-workflow.yaml"))) {
       return current;
     }
-    current = path.dirname(current);
+    current = path2.dirname(current);
   }
   return process.cwd();
 }
 function getConfigPath(workspaceRoot) {
-  const newPath = path.join(workspaceRoot, ".rrce-workflow", "config.yaml");
-  const legacyPath = path.join(workspaceRoot, ".rrce-workflow.yaml");
-  if (fs.existsSync(newPath)) {
+  const newPath = path2.join(workspaceRoot, ".rrce-workflow", "config.yaml");
+  const legacyPath = path2.join(workspaceRoot, ".rrce-workflow.yaml");
+  if (fs2.existsSync(newPath)) {
     return newPath;
   }
-  if (fs.existsSync(legacyPath)) {
+  if (fs2.existsSync(legacyPath)) {
     return legacyPath;
   }
   try {
-    const rrceHome = getDefaultRRCEHome();
-    const mcpConfigPath = path.join(rrceHome, "mcp.yaml");
-    if (fs.existsSync(mcpConfigPath)) {
-      const mcpContent = fs.readFileSync(mcpConfigPath, "utf-8");
+    const rrceHome = getDefaultRRCEHome2();
+    const mcpConfigPath = path2.join(rrceHome, "mcp.yaml");
+    if (fs2.existsSync(mcpConfigPath)) {
+      const mcpContent = fs2.readFileSync(mcpConfigPath, "utf-8");
       const lines = mcpContent.split("\n");
       let currentName = "";
       for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
+        const line = lines[i]?.trim();
+        if (!line) continue;
         if (line.startsWith("- name:")) {
           currentName = line.replace("- name:", "").trim();
         } else if (line.startsWith("path:")) {
           const p = line.replace("path:", "").trim();
           if (p === workspaceRoot || p === `"${workspaceRoot}"` || p === `'${workspaceRoot}'`) {
-            return path.join(rrceHome, "workspaces", currentName, "config.yaml");
+            return path2.join(rrceHome, "workspaces", currentName, "config.yaml");
           }
         }
       }
@@ -73,42 +113,42 @@ function getConfigPath(workspaceRoot) {
   return newPath;
 }
 function getWorkspaceName(workspaceRoot) {
-  return path.basename(workspaceRoot);
+  return path2.basename(workspaceRoot);
 }
 function getRRCEHome() {
   return RRCE_HOME;
 }
 function getLocalWorkspacePath(workspaceRoot) {
-  return path.join(workspaceRoot, ".rrce-workflow");
+  return path2.join(workspaceRoot, ".rrce-workflow");
 }
 function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
+  if (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
   }
 }
 function getAgentPromptPath(workspaceRoot, tool) {
   if (tool === "copilot") {
-    return path.join(workspaceRoot, ".github", "agents");
+    return path2.join(workspaceRoot, ".github", "agents");
   } else {
-    return path.join(workspaceRoot, ".agent", "workflows");
+    return path2.join(workspaceRoot, ".agent", "workflows");
   }
 }
 function copyToAllStoragePaths(sourceFile, relativePath, dataPaths) {
-  const content = fs.readFileSync(sourceFile);
+  const content = fs2.readFileSync(sourceFile);
   for (const dataPath of dataPaths) {
-    const targetPath = path.join(dataPath, relativePath);
-    ensureDir(path.dirname(targetPath));
-    fs.writeFileSync(targetPath, content);
+    const targetPath = path2.join(dataPath, relativePath);
+    ensureDir(path2.dirname(targetPath));
+    fs2.writeFileSync(targetPath, content);
   }
 }
 function copyDirToAllStoragePaths(sourceDir, relativeDir, dataPaths) {
-  if (!fs.existsSync(sourceDir)) {
+  if (!fs2.existsSync(sourceDir)) {
     return;
   }
-  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  const entries = fs2.readdirSync(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = path.join(sourceDir, entry.name);
-    const relativePath = path.join(relativeDir, entry.name);
+    const sourcePath = path2.join(sourceDir, entry.name);
+    const relativePath = path2.join(relativeDir, entry.name);
     if (entry.isDirectory()) {
       copyDirToAllStoragePaths(sourcePath, relativePath, dataPaths);
     } else {
@@ -119,38 +159,38 @@ function copyDirToAllStoragePaths(sourceDir, relativeDir, dataPaths) {
 function syncMetadataToAll(agentCorePath, dataPaths) {
   const metadataDirs = ["knowledge", "refs", "tasks"];
   for (const dir of metadataDirs) {
-    const sourceDir = path.join(agentCorePath, dir);
+    const sourceDir = path2.join(agentCorePath, dir);
     copyDirToAllStoragePaths(sourceDir, dir, dataPaths);
   }
 }
 function checkWriteAccess(dirPath) {
-  const testFile = path.join(dirPath, ".rrce-write-test");
+  const testFile = path2.join(dirPath, ".rrce-write-test");
   try {
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
+    if (!fs2.existsSync(dirPath)) {
+      fs2.mkdirSync(dirPath, { recursive: true });
     }
-    fs.writeFileSync(testFile, "write-test");
-    fs.unlinkSync(testFile);
+    fs2.writeFileSync(testFile, "write-test");
+    fs2.unlinkSync(testFile);
     return true;
   } catch {
     try {
-      if (fs.existsSync(testFile)) {
-        fs.unlinkSync(testFile);
+      if (fs2.existsSync(testFile)) {
+        fs2.unlinkSync(testFile);
       }
     } catch {
     }
     return false;
   }
 }
-function getDefaultRRCEHome() {
-  return process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
+function getDefaultRRCEHome2() {
+  return process.env.RRCE_HOME || path2.join(process.env.HOME || "~", ".rrce-workflow");
 }
 function getEffectiveRRCEHome(workspaceRoot) {
   if (workspaceRoot) {
     const configPath = getConfigPath(workspaceRoot);
-    if (fs.existsSync(configPath)) {
+    if (fs2.existsSync(configPath)) {
       try {
-        const content = fs.readFileSync(configPath, "utf-8");
+        const content = fs2.readFileSync(configPath, "utf-8");
         const globalPathMatch = content.match(/globalPath:\s*["']?([^"'\n]+)["']?/);
         if (globalPathMatch?.[1]) {
           return globalPathMatch[1].trim();
@@ -159,24 +199,34 @@ function getEffectiveRRCEHome(workspaceRoot) {
       }
     }
   }
-  return getDefaultRRCEHome();
+  return getDefaultRRCEHome2();
 }
 var RRCE_HOME, RRCE_WORKSPACE;
 var init_paths = __esm({
   "src/lib/paths.ts"() {
     "use strict";
-    RRCE_HOME = process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
+    init_preferences();
+    RRCE_HOME = process.env.RRCE_HOME || path2.join(process.env.HOME || "~", ".rrce-workflow");
     RRCE_WORKSPACE = process.env.RRCE_WORKSPACE;
   }
 });
 
 // src/lib/detection.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 function scanForProjects(options = {}) {
-  const { excludeWorkspace, workspacePath } = options;
+  const { excludeWorkspace, workspacePath, knownPaths } = options;
   const projects = [];
   const seenPaths = /* @__PURE__ */ new Set();
+  if (knownPaths && knownPaths.length > 0) {
+    const explicitProjects = scanKnownPaths(knownPaths, excludeWorkspace);
+    for (const project of explicitProjects) {
+      if (!seenPaths.has(project.dataPath)) {
+        seenPaths.add(project.dataPath);
+        projects.push(project);
+      }
+    }
+  }
   const globalProjects = scanGlobalStorage(excludeWorkspace);
   for (const project of globalProjects) {
     if (!seenPaths.has(project.dataPath)) {
@@ -193,33 +243,67 @@ function scanForProjects(options = {}) {
   }
   return projects;
 }
+function scanKnownPaths(paths, excludeWorkspace) {
+  const projects = [];
+  for (const p of paths) {
+    try {
+      if (!fs3.existsSync(p)) continue;
+      const localConfigPath = path3.join(p, ".rrce-workflow", "config.yaml");
+      if (fs3.existsSync(localConfigPath)) {
+        const config = parseWorkspaceConfig(localConfigPath);
+        if (config?.name === excludeWorkspace) continue;
+        const fullPath = path3.join(p, ".rrce-workflow");
+        const knowledgePath = path3.join(fullPath, "knowledge");
+        const refsPath = path3.join(fullPath, "refs");
+        const tasksPath = path3.join(fullPath, "tasks");
+        projects.push({
+          name: config?.name || path3.basename(p),
+          path: p,
+          dataPath: fullPath,
+          source: "local",
+          storageMode: config?.storageMode,
+          knowledgePath: fs3.existsSync(knowledgePath) ? knowledgePath : void 0,
+          refsPath: fs3.existsSync(refsPath) ? refsPath : void 0,
+          tasksPath: fs3.existsSync(tasksPath) ? tasksPath : void 0,
+          semanticSearchEnabled: config?.semanticSearchEnabled
+        });
+        continue;
+      }
+    } catch {
+    }
+  }
+  return projects;
+}
 function scanGlobalStorage(excludeWorkspace) {
-  const rrceHome = getDefaultRRCEHome();
-  const workspacesDir = path2.join(rrceHome, "workspaces");
+  const rrceHome = getEffectiveGlobalPath();
+  const workspacesDir = path3.join(rrceHome, "workspaces");
   const projects = [];
-  if (!fs2.existsSync(workspacesDir)) {
+  if (!fs3.existsSync(workspacesDir)) {
     return projects;
   }
   try {
-    const entries = fs2.readdirSync(workspacesDir, { withFileTypes: true });
+    const entries = fs3.readdirSync(workspacesDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === excludeWorkspace) continue;
-      const projectDataPath = path2.join(workspacesDir, entry.name);
-      const knowledgePath = path2.join(projectDataPath, "knowledge");
-      const refsPath = path2.join(projectDataPath, "refs");
-      const tasksPath = path2.join(projectDataPath, "tasks");
+      const projectDataPath = path3.join(workspacesDir, entry.name);
+      const knowledgePath = path3.join(projectDataPath, "knowledge");
+      const refsPath = path3.join(projectDataPath, "refs");
+      const tasksPath = path3.join(projectDataPath, "tasks");
+      const configPath = path3.join(projectDataPath, "config.yaml");
+      const config = parseWorkspaceConfig(configPath);
       projects.push({
-        name: entry.name,
+        name: config?.name || entry.name,
         path: projectDataPath,
-        // For global projects, path is the data path
+        // Still use dataPath as defaults, BUT...
+        sourcePath: config?.sourcePath,
+        // ...expose sourcePath if available
         dataPath: projectDataPath,
         source: "global",
-        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
-        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
-        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0,
-        // Global projects store config at the root of their data path
-        semanticSearchEnabled: parseWorkspaceConfig(path2.join(projectDataPath, "config.yaml"))?.semanticSearchEnabled
+        knowledgePath: fs3.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs3.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs3.existsSync(tasksPath) ? tasksPath : void 0,
+        semanticSearchEnabled: config?.semanticSearchEnabled
       });
     }
   } catch {
@@ -234,29 +318,29 @@ function scanHomeDirectory(excludePath) {
   function scanDir(dirPath, depth) {
     if (depth > maxDepth) return;
     try {
-      const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+      const entries = fs3.readdirSync(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const fullPath = path2.join(dirPath, entry.name);
+        const fullPath = path3.join(dirPath, entry.name);
         if (excludePath && fullPath === excludePath) continue;
         if (entry.name === ".rrce-workflow") {
-          const configPath = path2.join(fullPath, "config.yaml");
-          if (fs2.existsSync(configPath)) {
+          const configPath = path3.join(fullPath, "config.yaml");
+          if (fs3.existsSync(configPath)) {
             const projectPath = dirPath;
-            const projectName = path2.basename(projectPath);
+            const projectName = path3.basename(projectPath);
             const config = parseWorkspaceConfig(configPath);
-            const knowledgePath = path2.join(fullPath, "knowledge");
-            const refsPath = path2.join(fullPath, "refs");
-            const tasksPath = path2.join(fullPath, "tasks");
+            const knowledgePath = path3.join(fullPath, "knowledge");
+            const refsPath = path3.join(fullPath, "refs");
+            const tasksPath = path3.join(fullPath, "tasks");
             projects.push({
               name: config?.name || projectName,
               path: projectPath,
               dataPath: fullPath,
               source: "local",
               storageMode: config?.storageMode,
-              knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
-              refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
-              tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0,
+              knowledgePath: fs3.existsSync(knowledgePath) ? knowledgePath : void 0,
+              refsPath: fs3.existsSync(refsPath) ? refsPath : void 0,
+              tasksPath: fs3.existsSync(tasksPath) ? tasksPath : void 0,
               semanticSearchEnabled: config?.semanticSearchEnabled
             });
           }
@@ -274,8 +358,9 @@ function scanHomeDirectory(excludePath) {
 }
 function parseWorkspaceConfig(configPath) {
   try {
-    const content = fs2.readFileSync(configPath, "utf-8");
+    const content = fs3.readFileSync(configPath, "utf-8");
     const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
+    const sourcePathMatch = content.match(/sourcePath:\s*["']?([^"'\n]+)["']?/);
     const modeMatch = content.match(/mode:\s*(global|workspace)/);
     const linkedProjects = [];
     const linkedMatch = content.match(/linked_projects:\s*\n((?:\s+-\s+[^\n]+\n?)+)/);
@@ -291,7 +376,8 @@ function parseWorkspaceConfig(configPath) {
     const semanticSearchMatch = content.match(/semantic_search:\s*\n\s*enabled:\s*(true|false)/);
     const semanticSearchEnabled = semanticSearchMatch ? semanticSearchMatch[1] === "true" : false;
     return {
-      name: nameMatch?.[1]?.trim() || path2.basename(path2.dirname(path2.dirname(configPath))),
+      name: nameMatch?.[1]?.trim() || path3.basename(path3.dirname(path3.dirname(configPath))),
+      sourcePath: sourcePathMatch?.[1]?.trim(),
       storageMode: modeMatch?.[1] || "global",
       linkedProjects: linkedProjects.length > 0 ? linkedProjects : void 0,
       semanticSearchEnabled
@@ -396,8 +482,8 @@ var init_detection_service = __esm({
 });
 
 // src/lib/autocomplete-prompt.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import * as readline from "readline";
 import pc from "picocolors";
 function directoryPrompt(opts) {
@@ -456,19 +542,19 @@ function completeDirectory(line) {
       prefix = "";
       basePath = expanded;
     } else {
-      dirToScan = path3.dirname(expanded);
-      prefix = path3.basename(expanded).toLowerCase();
+      dirToScan = path4.dirname(expanded);
+      prefix = path4.basename(expanded).toLowerCase();
       basePath = dirToScan === "/" ? "/" : dirToScan + "/";
     }
-    if (!fs3.existsSync(dirToScan)) {
+    if (!fs4.existsSync(dirToScan)) {
       return [[], line];
     }
-    const entries = fs3.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
+    const entries = fs4.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
       if (!entry.isDirectory()) return false;
       if (entry.name.startsWith(".") && !prefix.startsWith(".")) return false;
       return prefix === "" || entry.name.toLowerCase().startsWith(prefix);
     }).map((entry) => {
-      const fullPath = path3.join(dirToScan, entry.name);
+      const fullPath = path4.join(dirToScan, entry.name);
       const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
       return displayPath + "/";
     }).sort();
@@ -507,38 +593,6 @@ var init_autocomplete_prompt = __esm({
   }
 });
 
-// src/lib/preferences.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-function getPreferencesPath() {
-  const home = process.env.HOME || "~";
-  return path4.join(home, ".rrce-workflow", "preferences.json");
-}
-function loadUserPreferences() {
-  const prefPath = getPreferencesPath();
-  if (!fs4.existsSync(prefPath)) {
-    return {};
-  }
-  try {
-    return JSON.parse(fs4.readFileSync(prefPath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveUserPreferences(prefs) {
-  const prefPath = getPreferencesPath();
-  ensureDir(path4.dirname(prefPath));
-  const current = loadUserPreferences();
-  const refined = { ...current, ...prefs };
-  fs4.writeFileSync(prefPath, JSON.stringify(refined, null, 2));
-}
-var init_preferences = __esm({
-  "src/lib/preferences.ts"() {
-    "use strict";
-    init_paths();
-  }
-});
-
 // src/lib/tui-utils.ts
 var tui_utils_exports = {};
 __export(tui_utils_exports, {
@@ -549,7 +603,7 @@ import pc2 from "picocolors";
 import * as path5 from "path";
 async function resolveGlobalPath() {
   const prefs = loadUserPreferences();
-  const defaultPath = prefs.defaultGlobalPath || getDefaultRRCEHome();
+  const defaultPath = prefs.defaultGlobalPath || getDefaultRRCEHome2();
   const isDefaultWritable = checkWriteAccess(defaultPath);
   const options = [
     {
@@ -585,7 +639,7 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path5.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const suggestedPath = path5.join(process.env.HOME || "~", ".rrce-workflow");
   const customPath = await directoryPrompt({
     message: "Enter custom global path (Tab to autocomplete):",
     defaultValue: suggestedPath,
@@ -606,7 +660,7 @@ Please choose a custom path instead.`,
   if (!expandedPath.endsWith(".rrce-workflow")) {
     expandedPath = path5.join(expandedPath, ".rrce-workflow");
   }
-  saveUserPreferences({ defaultGlobalPath: expandedPath });
+  saveUserPreferences({ defaultGlobalPath: expandedPath, useCustomGlobalPath: true });
   return expandedPath;
 }
 var init_tui_utils = __esm({
@@ -1129,7 +1183,7 @@ function getProjectPermissions(config, name, projectPath) {
   return project?.permissions ?? config.defaults.permissions;
 }
 function cleanStaleProjects(config) {
-  const rrceHome = getEffectiveRRCEHome();
+  const rrceHome = getEffectiveGlobalPath();
   const globalWorkspacesDir = path9.join(rrceHome, "workspaces");
   const validProjects = [];
   const removed = [];
@@ -1197,7 +1251,7 @@ function installAgentPrompts(config, workspacePath, dataPaths) {
 function createWorkspaceConfig(config, workspacePath, workspaceName) {
   let configPath;
   if (config.storageMode === "global") {
-    const rrceHome = config.globalPath || getDefaultRRCEHome();
+    const rrceHome = config.globalPath || getDefaultRRCEHome2();
     configPath = path10.join(rrceHome, "workspaces", workspaceName, "config.yaml");
   } else {
     configPath = path10.join(workspacePath, ".rrce-workflow", "config.yaml");
@@ -1208,7 +1262,7 @@ version: 1
 
 storage:
   mode: ${config.storageMode}`;
-  if (config.globalPath && config.globalPath !== getDefaultRRCEHome()) {
+  if (config.globalPath && config.globalPath !== getDefaultRRCEHome2()) {
     content += `
   globalPath: "${config.globalPath}"`;
   }
@@ -1216,6 +1270,7 @@ storage:
 
 project:
   name: "${workspaceName}"
+  sourcePath: "${workspacePath}"
 
 tools:
   copilot: ${config.storageMode === "workspace" && config.tools.includes("copilot")}
@@ -1243,25 +1298,14 @@ async function registerWithMCP(config, workspacePath, workspaceName) {
   try {
     const { loadMCPConfig: loadMCPConfig3, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
     const mcpConfig = loadMCPConfig3();
-    if (config.storageMode === "workspace") {
-      setProjectConfig2(
-        mcpConfig,
-        workspaceName,
-        true,
-        void 0,
-        void 0,
-        config.enableRAG ? { enabled: true } : void 0
-      );
-    } else {
-      setProjectConfig2(
-        mcpConfig,
-        workspaceName,
-        true,
-        void 0,
-        workspacePath,
-        config.enableRAG ? { enabled: true } : void 0
-      );
-    }
+    setProjectConfig2(
+      mcpConfig,
+      workspaceName,
+      true,
+      void 0,
+      workspacePath,
+      config.enableRAG ? { enabled: true } : void 0
+    );
     saveMCPConfig2(mcpConfig);
   } catch (e) {
     note2(
@@ -1274,7 +1318,7 @@ You can configure MCP later: ${pc4.cyan("npx rrce-workflow mcp")}`,
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path10.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const globalPath = path10.join(customGlobalPath || getDefaultRRCEHome2(), "workspaces", workspaceName);
   const workspacePath = path10.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
@@ -1658,7 +1702,8 @@ import * as fs13 from "fs";
 import * as path14 from "path";
 function getExposedProjects() {
   const config = loadMCPConfig();
-  const allProjects = projectService.scan();
+  const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
+  const allProjects = projectService.scan({ knownPaths });
   const globalProjects = allProjects.filter((project) => isProjectExposed(config, project.name, project.dataPath));
   const activeProject = detectActiveProject(globalProjects);
   let linkedProjects = [];
@@ -1710,7 +1755,8 @@ function detectActiveProject(knownProjects) {
   let scanList = knownProjects;
   if (!scanList) {
     const config = loadMCPConfig();
-    const all = projectService.scan();
+    const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
+    const all = projectService.scan({ knownPaths });
     scanList = all.filter((project) => isProjectExposed(config, project.name, project.dataPath));
   }
   return findClosestProject(scanList);
@@ -1833,11 +1879,12 @@ async function indexKnowledge(projectName, force = false) {
   }
   const projConfig = config.projects.find(
     (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
-  );
-  if (!projConfig?.semanticSearch?.enabled) {
+  ) || (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 };
   }
-  const scanRoot = project.path || project.dataPath;
+  const scanRoot = project.sourcePath || project.path || project.dataPath;
   if (!fs13.existsSync(scanRoot)) {
     return { success: false, message: "Project root not found", filesIndexed: 0, filesSkipped: 0 };
   }
@@ -1882,7 +1929,8 @@ async function indexKnowledge(projectName, force = false) {
   const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor"];
   try {
     const indexPath = path14.join(project.knowledgePath || path14.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
-    const rag = new RAGService(indexPath, projConfig.semanticSearch.model);
+    const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
+    const rag = new RAGService(indexPath, model);
     let indexed = 0;
     let skipped = 0;
     const scanDir = async (dir) => {
@@ -2277,6 +2325,7 @@ import {
   ListPromptsRequestSchema,
   GetPromptRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
+import * as path15 from "path";
 function registerPromptHandlers(server) {
   server.setRequestHandler(ListPromptsRequestSchema, async () => {
     logger.debug("Listing prompts");
@@ -2311,8 +2360,35 @@ function registerPromptHandlers(server) {
       for (const [key, val] of Object.entries(providedArgs)) {
         renderArgs[key] = String(val);
       }
+      const activeProject = detectActiveProject();
+      const DEFAULT_RRCE_HOME = getEffectiveGlobalPath();
+      let resolvedRrceData = ".rrce-workflow/";
+      let resolvedRrceHome = DEFAULT_RRCE_HOME;
+      let resolvedWorkspaceRoot = process.cwd();
+      let resolvedWorkspaceName = "current-project";
+      if (activeProject) {
+        resolvedRrceData = activeProject.dataPath + "/";
+        resolvedWorkspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
+        resolvedWorkspaceName = activeProject.name;
+        if (activeProject.source === "global") {
+          const workspacesDir = path15.dirname(activeProject.dataPath);
+          resolvedRrceHome = path15.dirname(workspacesDir);
+        }
+      }
+      if (!renderArgs["RRCE_DATA"]) renderArgs["RRCE_DATA"] = resolvedRrceData;
+      if (!renderArgs["RRCE_HOME"]) renderArgs["RRCE_HOME"] = resolvedRrceHome;
+      if (!renderArgs["WORKSPACE_ROOT"]) renderArgs["WORKSPACE_ROOT"] = resolvedWorkspaceRoot;
+      if (!renderArgs["WORKSPACE_NAME"]) renderArgs["WORKSPACE_NAME"] = resolvedWorkspaceName;
       const content = renderPrompt(promptDef.content, renderArgs);
-      const contextPreamble = getContextPreamble();
+      let contextPreamble = getContextPreamble();
+      contextPreamble += `
+### System Resolved Paths (OVERRIDE)
+The system has pre-resolved the configuration for this project. Use these values instead of manual resolution:
+- **RRCE_DATA**: \`${resolvedRrceData}\` (Stores knowledge, tasks, refs)
+- **WORKSPACE_ROOT**: \`${resolvedWorkspaceRoot}\` (Source code location)
+- **RRCE_HOME**: \`${resolvedRrceHome}\`
+- **Current Project**: ${resolvedWorkspaceName}
+`;
       return {
         messages: [
           {
@@ -2336,6 +2412,7 @@ var init_prompts3 = __esm({
     init_logger();
     init_resources();
     init_prompts2();
+    init_paths();
   }
 });
 
@@ -2418,7 +2495,7 @@ var init_server = __esm({
 
 // src/mcp/install.ts
 import * as fs14 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 import * as os from "os";
 function checkInstallStatus(workspacePath) {
   return {
@@ -2456,7 +2533,7 @@ function checkVSCodeGlobalConfig() {
   }
 }
 function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path15.join(workspacePath, ".vscode", "mcp.json");
+  const configPath = path16.join(workspacePath, ".vscode", "mcp.json");
   if (!fs14.existsSync(configPath)) return false;
   try {
     const content = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
@@ -2484,7 +2561,7 @@ function installToConfig(target, workspacePath) {
   }
 }
 function installToAntigravity() {
-  const dir = path15.dirname(ANTIGRAVITY_CONFIG);
+  const dir = path16.dirname(ANTIGRAVITY_CONFIG);
   if (!fs14.existsSync(dir)) {
     fs14.mkdirSync(dir, { recursive: true });
   }
@@ -2508,7 +2585,7 @@ function installToAntigravity() {
   }
 }
 function installToClaude() {
-  const dir = path15.dirname(CLAUDE_CONFIG);
+  const dir = path16.dirname(CLAUDE_CONFIG);
   if (!fs14.existsSync(dir)) {
     fs14.mkdirSync(dir, { recursive: true });
   }
@@ -2532,7 +2609,7 @@ function installToClaude() {
   }
 }
 function installToVSCodeGlobal() {
-  const dir = path15.dirname(VSCODE_GLOBAL_CONFIG);
+  const dir = path16.dirname(VSCODE_GLOBAL_CONFIG);
   if (!fs14.existsSync(dir)) {
     fs14.mkdirSync(dir, { recursive: true });
   }
@@ -2556,8 +2633,8 @@ function installToVSCodeGlobal() {
   }
 }
 function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path15.join(workspacePath, ".vscode");
-  const configPath = path15.join(vscodeDir, "mcp.json");
+  const vscodeDir = path16.join(workspacePath, ".vscode");
+  const configPath = path16.join(vscodeDir, "mcp.json");
   if (!fs14.existsSync(vscodeDir)) {
     fs14.mkdirSync(vscodeDir, { recursive: true });
   }
@@ -2598,9 +2675,9 @@ var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path15.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path15.join(os.homedir(), ".config/claude/claude_desktop_config.json");
-    VSCODE_GLOBAL_CONFIG = path15.join(os.homedir(), ".config/Code/User/settings.json");
+    ANTIGRAVITY_CONFIG = path16.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path16.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path16.join(os.homedir(), ".config/Code/User/settings.json");
   }
 });
 
@@ -2611,7 +2688,8 @@ async function handleConfigure() {
   const s = spinner();
   s.start("Scanning for projects...");
   const config = loadMCPConfig();
-  const projects = scanForProjects();
+  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 });
   s.stop("Projects found");
   if (projects.length === 0) {
@@ -2686,7 +2764,7 @@ Hidden projects: ${projects.length - exposedCount}`,
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
   const fs21 = await import("fs");
-  const path19 = await import("path");
+  const path20 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -2709,7 +2787,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:
-${path19.join(resolvedPath, "mcp.yaml")}`,
+${path20.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -4065,14 +4143,14 @@ var init_link_flow = __esm({
 import { confirm as confirm7, spinner as spinner5, note as note10, outro as outro4, cancel as cancel5, isCancel as isCancel9 } from "@clack/prompts";
 import pc12 from "picocolors";
 import * as fs17 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path16.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path17.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs17.existsSync(path16.join(localPath, dir))
+    (dir) => fs17.existsSync(path17.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro4(pc12.yellow("No data found in workspace storage to sync."));
@@ -4098,8 +4176,8 @@ Destination: ${pc12.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path16.join(localPath, dir);
-      const destDir = path16.join(globalPath, dir);
+      const srcDir = path17.join(localPath, dir);
+      const destDir = path17.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -4132,7 +4210,7 @@ var init_sync_flow = __esm({
 import { confirm as confirm8, spinner as spinner6, note as note11, outro as outro5, cancel as cancel6, isCancel as isCancel10 } from "@clack/prompts";
 import pc13 from "picocolors";
 import * as fs18 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner6();
   s.start("Checking for updates");
@@ -4162,7 +4240,7 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path17.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path18.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
     if (fs18.existsSync(configFilePath)) {
@@ -4195,8 +4273,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path17.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path17.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path18.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path18.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -4428,9 +4506,9 @@ init_wizard();
 init_prompts();
 import { intro as intro3, select as select6, note as note14, cancel as cancel9, isCancel as isCancel13, outro as outro8 } from "@clack/prompts";
 import pc16 from "picocolors";
-import * as path18 from "path";
+import * as path19 from "path";
 async function runSelector() {
-  const workspaceName = path18.basename(process.cwd());
+  const workspaceName = path19.basename(process.cwd());
   intro3(pc16.cyan(pc16.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {

package/package.json

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