rrce-workflow 0.2.43 → 0.2.44

package/agent-core/prompts/executor.md

@@ -50,6 +50,7 @@ Do not proceed with execution until all prerequisites are satisfied.
 Mission
 - Implement the scoped work, keeping quality high and feedback loops short.
 - Update stakeholders on progress and record verifications so outcomes are auditable.
+- Use the `search_knowledge` tool (if available) to find internal API usage examples or coding patterns.
 
 Non-Negotiables
 1. Read `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/meta.json` and the latest plan before touching code.

package/agent-core/prompts/init.md

@@ -162,6 +162,10 @@ Workflow Steps
 7. Save to `{{RRCE_DATA}}/knowledge/project-context.md`.
 8. Update `{{RRCE_DATA}}/workspace.json` with project metadata.
 9. Log changes made (new sections, updated sections, removed outdated info).
+10. **Semantic Indexing**: If the `index_knowledge` tool is available, run it:
+    - Tool: `index_knowledge`
+    - Args: `{ project: "{{WORKSPACE_NAME}}" }`
+    - This ensures the new context is immediately searchable.
 
 Deliverable
 - File: `{{RRCE_DATA}}/knowledge/project-context.md`

package/agent-core/prompts/planning_orchestrator.md

@@ -42,6 +42,7 @@ Do not proceed with planning until both prerequisites are satisfied.
 Mission
 - Convert the Research brief into a concrete, prioritized plan that the Executor can follow with minimal ambiguity.
 - Maintain cohesive project knowledge within the RRCE cache, ensuring future agents inherit accurate context.
+- Use the `search_knowledge` tool (if available) to validate architectural alignment and find relevant prior art.
 
 Non-Negotiables
 1. Review `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/meta.json`, the research artifact, and relevant entries under `{{RRCE_DATA}}/knowledge` before planning.

package/agent-core/prompts/sync.md

@@ -66,6 +66,9 @@ Workflow
    - Remove outdated sections or entire files once you verify the information no longer applies.
 4. Ensure cross-references (links to tasks, commits, or other knowledge files) point to current resources.
 5. Summarize any unresolved questions or future sync needs at the bottom of the modified file(s) under a `Checklist` heading.
+6. **Semantic Indexing**: If any knowledge files were modified or created, and the `index_knowledge` tool is available, run it to keep the search index current:
+   - Tool: `index_knowledge`
+   - Args: `{ project: "{{WORKSPACE_NAME}}" }`
 
 Deliverable
 - Updated `{{RRCE_DATA}}/knowledge/*` files that accurately reflect the present project state, each carrying the latest `Updated:` marker and lean checklist.

package/dist/index.js

@@ -877,6 +877,7 @@ function parseMCPConfig(content) {
   let currentSection = null;
   let currentProject = null;
   let inPermissions = false;
+  let inSemanticSearch = false;
   for (const line of lines) {
     const trimmed = line.trim();
     if (trimmed.startsWith("#") || trimmed === "") continue;
@@ -884,18 +885,21 @@ function parseMCPConfig(content) {
       currentSection = "server";
       currentProject = null;
       inPermissions = false;
+      inSemanticSearch = false;
       continue;
     }
     if (line.match(/^defaults:/)) {
       currentSection = "defaults";
       currentProject = null;
       inPermissions = false;
+      inSemanticSearch = false;
       continue;
     }
     if (line.match(/^projects:/)) {
       currentSection = "projects";
       currentProject = null;
       inPermissions = false;
+      inSemanticSearch = false;
       continue;
     }
     if (currentSection === "server") {
@@ -955,6 +959,20 @@ function parseMCPConfig(content) {
           const refsMatch = trimmed.match(/^refs:\s*(true|false)/);
           if (refsMatch) currentProject.permissions.refs = refsMatch[1] === "true";
         }
+        if (trimmed === "semanticSearch:") {
+          inSemanticSearch = true;
+          inPermissions = false;
+          if (!currentProject.semanticSearch) {
+            currentProject.semanticSearch = { enabled: false };
+          }
+          continue;
+        }
+        if (inSemanticSearch && currentProject.semanticSearch) {
+          const enabledMatch = trimmed.match(/^enabled:\s*(true|false)/);
+          if (enabledMatch) currentProject.semanticSearch.enabled = enabledMatch[1] === "true";
+          const modelMatch = trimmed.match(/^model:\s*["']?([^"'\n]+)["']?/);
+          if (modelMatch) currentProject.semanticSearch.model = modelMatch[1].trim();
+        }
       }
     }
   }
@@ -991,7 +1009,17 @@ projects:
 `;
       }
       content += `    expose: ${project.expose}
-    permissions:
+`;
+      if (project.semanticSearch) {
+        content += `    semanticSearch:
+      enabled: ${project.semanticSearch.enabled}
+`;
+        if (project.semanticSearch.model) {
+          content += `      model: "${project.semanticSearch.model}"
+`;
+        }
+      }
+      content += `    permissions:
       knowledge: ${project.permissions.knowledge}
       tasks: ${project.permissions.tasks}
       refs: ${project.permissions.refs}
@@ -1000,7 +1028,7 @@ projects:
   }
   return content;
 }
-function setProjectConfig(config, name, expose, permissions, projectPath) {
+function setProjectConfig(config, name, expose, permissions, projectPath, semanticSearch) {
   let existing = config.projects.find((p) => {
     if (projectPath && p.path) {
       return p.path === projectPath;
@@ -1021,12 +1049,16 @@ function setProjectConfig(config, name, expose, permissions, projectPath) {
     if (permissions) {
       existing.permissions = { ...existing.permissions, ...permissions };
     }
+    if (semanticSearch) {
+      existing.semanticSearch = semanticSearch;
+    }
   } else {
     config.projects.push({
       name,
       path: projectPath,
       expose,
-      permissions: permissions ? { ...DEFAULT_PERMISSIONS, ...permissions } : { ...DEFAULT_PERMISSIONS }
+      permissions: permissions ? { ...DEFAULT_PERMISSIONS, ...permissions } : { ...DEFAULT_PERMISSIONS },
+      semanticSearch
     });
   }
   return config;
@@ -1128,9 +1160,199 @@ ${JSON.stringify(data, null, 2)}`;
   }
 });
 
-// src/mcp/resources.ts
+// src/mcp/services/rag.ts
+import { pipeline } from "@xenova/transformers";
 import * as fs9 from "fs";
 import * as path10 from "path";
+var INDEX_VERSION, DEFAULT_MODEL, RAGService;
+var init_rag = __esm({
+  "src/mcp/services/rag.ts"() {
+    "use strict";
+    init_logger();
+    INDEX_VERSION = "1.0.0";
+    DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+    RAGService = class {
+      pipe = null;
+      modelName;
+      indexPath;
+      index = null;
+      lastAccess = 0;
+      constructor(indexPath, modelName = DEFAULT_MODEL) {
+        this.indexPath = indexPath;
+        this.modelName = modelName;
+      }
+      /**
+       * Lazy load the model
+       */
+      async getPipeline() {
+        if (!this.pipe) {
+          logger.info(`RAG: Initializing model ${this.modelName}...`);
+          try {
+            this.pipe = await pipeline("feature-extraction", this.modelName);
+            logger.info(`RAG: Model ${this.modelName} initialized successfully.`);
+          } catch (error) {
+            logger.error(`RAG: Failed to initialize model ${this.modelName}`, error);
+            throw error;
+          }
+        }
+        this.lastAccess = Date.now();
+        return this.pipe;
+      }
+      /**
+       * Load index from disk
+       */
+      loadIndex() {
+        if (this.index) return;
+        if (fs9.existsSync(this.indexPath)) {
+          try {
+            const data = fs9.readFileSync(this.indexPath, "utf-8");
+            this.index = JSON.parse(data);
+            logger.info(`RAG: Loaded index from ${this.indexPath} with ${this.index?.chunks.length} chunks.`);
+          } catch (error) {
+            logger.error(`RAG: Failed to load index from ${this.indexPath}`, error);
+            this.index = {
+              version: INDEX_VERSION,
+              baseModel: this.modelName,
+              chunks: []
+            };
+          }
+        } else {
+          this.index = {
+            version: INDEX_VERSION,
+            baseModel: this.modelName,
+            chunks: []
+          };
+          logger.info(`RAG: Created new empty index at ${this.indexPath}`);
+        }
+      }
+      /**
+       * Save index to disk
+       */
+      saveIndex() {
+        if (!this.index) return;
+        try {
+          const dir = path10.dirname(this.indexPath);
+          if (!fs9.existsSync(dir)) {
+            fs9.mkdirSync(dir, { recursive: true });
+          }
+          fs9.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+          logger.info(`RAG: Saved index to ${this.indexPath} with ${this.index.chunks.length} chunks.`);
+        } catch (error) {
+          logger.error(`RAG: Failed to save index to ${this.indexPath}`, error);
+        }
+      }
+      /**
+       * Generate embedding for text
+       */
+      async generateEmbedding(text3) {
+        const pipe = await this.getPipeline();
+        try {
+          const output = await pipe(text3, { pooling: "mean", normalize: true });
+          return Array.from(output.data);
+        } catch (error) {
+          logger.error("RAG: Error generating embedding", error);
+          throw error;
+        }
+      }
+      /**
+       * Index a file
+       */
+      async indexFile(filePath, content) {
+        this.loadIndex();
+        if (!this.index) throw new Error("Index not initialized");
+        logger.info(`RAG: Indexing file ${filePath}`);
+        this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
+        const chunks = this.chunkContent(content);
+        for (const chunkText of chunks) {
+          const embedding = await this.generateEmbedding(chunkText);
+          this.index.chunks.push({
+            id: `${filePath}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            filePath,
+            content: chunkText,
+            embedding
+          });
+        }
+        this.saveIndex();
+      }
+      /**
+       * Remove a file from index
+       */
+      async removeFile(filePath) {
+        this.loadIndex();
+        if (!this.index) return;
+        const initialCount = this.index.chunks.length;
+        this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
+        if (this.index.chunks.length !== initialCount) {
+          logger.info(`RAG: Removed file ${filePath} from index (${initialCount - this.index.chunks.length} chunks removed)`);
+          this.saveIndex();
+        }
+      }
+      /**
+       * Search the index
+       */
+      async search(query, limit = 5) {
+        this.loadIndex();
+        if (!this.index || this.index.chunks.length === 0) {
+          logger.warn("RAG: Search called on empty index");
+          return [];
+        }
+        logger.info(`RAG: Searching for "${query}" (limit: ${limit})`);
+        const queryEmbedding = await this.generateEmbedding(query);
+        const results = this.index.chunks.map((chunk) => {
+          const score = this.cosineSimilarity(queryEmbedding, chunk.embedding);
+          return { ...chunk, score };
+        });
+        results.sort((a, b) => b.score - a.score);
+        const topResults = results.slice(0, limit);
+        logger.info(`RAG: Search returned ${topResults.length} matches. Top score: ${topResults[0]?.score.toFixed(4)}`);
+        return topResults;
+      }
+      /**
+       * Simple cosine similarity
+       */
+      cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        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];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+      }
+      /**
+       * Basic content chunker
+       */
+      chunkContent(content, maxChunkSize = 1e3, overlap = 100) {
+        const chunks = [];
+        let start = 0;
+        while (start < content.length) {
+          let end = start + maxChunkSize;
+          if (end >= content.length) {
+            end = content.length;
+          } else {
+            const lastNewline = content.lastIndexOf("\n", end);
+            if (lastNewline > start + maxChunkSize / 2) {
+              end = lastNewline;
+            }
+          }
+          const chunk = content.substring(start, end).trim();
+          if (chunk.length > 50) {
+            chunks.push(chunk);
+          }
+          if (end === content.length) break;
+          start = end - overlap;
+        }
+        return chunks;
+      }
+    };
+  }
+});
+
+// src/mcp/resources.ts
+import * as fs10 from "fs";
+import * as path11 from "path";
 function getExposedProjects() {
   const config = loadMCPConfig();
   const allProjects = scanForProjects();
@@ -1138,12 +1360,12 @@ function getExposedProjects() {
   const activeProject = detectActiveProject(globalProjects);
   let linkedProjects = [];
   if (activeProject) {
-    const localConfigPath = path10.join(activeProject.dataPath, "config.yaml");
+    const localConfigPath = path11.join(activeProject.dataPath, "config.yaml");
     let cfgContent = null;
-    if (fs9.existsSync(path10.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
-      cfgContent = fs9.readFileSync(path10.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
-    } else if (fs9.existsSync(path10.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
-      cfgContent = fs9.readFileSync(path10.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
+    if (fs10.existsSync(path11.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
+      cfgContent = fs10.readFileSync(path11.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
+    } else if (fs10.existsSync(path11.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
+      cfgContent = fs10.readFileSync(path11.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
     }
     if (cfgContent) {
       if (cfgContent.includes("linked_projects:")) {
@@ -1203,11 +1425,11 @@ function getProjectContext(projectName) {
   if (!project.knowledgePath) {
     return null;
   }
-  const contextPath = path10.join(project.knowledgePath, "project-context.md");
-  if (!fs9.existsSync(contextPath)) {
+  const contextPath = path11.join(project.knowledgePath, "project-context.md");
+  if (!fs10.existsSync(contextPath)) {
     return null;
   }
-  return fs9.readFileSync(contextPath, "utf-8");
+  return fs10.readFileSync(contextPath, "utf-8");
 }
 function getProjectTasks(projectName) {
   const config = loadMCPConfig();
@@ -1220,18 +1442,18 @@ function getProjectTasks(projectName) {
   if (!permissions.tasks) {
     return [];
   }
-  if (!project.tasksPath || !fs9.existsSync(project.tasksPath)) {
+  if (!project.tasksPath || !fs10.existsSync(project.tasksPath)) {
     return [];
   }
   const tasks = [];
   try {
-    const taskDirs = fs9.readdirSync(project.tasksPath, { withFileTypes: true });
+    const taskDirs = fs10.readdirSync(project.tasksPath, { withFileTypes: true });
     for (const dir of taskDirs) {
       if (!dir.isDirectory()) continue;
-      const metaPath = path10.join(project.tasksPath, dir.name, "meta.json");
-      if (fs9.existsSync(metaPath)) {
+      const metaPath = path11.join(project.tasksPath, dir.name, "meta.json");
+      if (fs10.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs10.readFileSync(metaPath, "utf-8"));
           tasks.push(meta);
         } catch {
         }
@@ -1241,7 +1463,7 @@ function getProjectTasks(projectName) {
   }
   return tasks;
 }
-function searchKnowledge(query) {
+async function searchKnowledge(query) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
   const results = [];
@@ -1249,12 +1471,34 @@ function searchKnowledge(query) {
   for (const project of projects) {
     const permissions = getProjectPermissions(config, project.name, project.dataPath);
     if (!permissions.knowledge || !project.knowledgePath) continue;
+    const projConfig = config.projects.find(
+      (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
+    );
+    const useRAG = projConfig?.semanticSearch?.enabled;
+    if (useRAG) {
+      try {
+        const indexPath = path11.join(project.knowledgePath, "embeddings.json");
+        const rag = new RAGService(indexPath, projConfig?.semanticSearch?.model);
+        const ragResults = await rag.search(query, 5);
+        for (const r of ragResults) {
+          results.push({
+            project: project.name,
+            file: path11.relative(project.knowledgePath, r.filePath),
+            matches: [r.content],
+            // The chunk content is the match
+            score: r.score
+          });
+        }
+      } catch (e) {
+      }
+      continue;
+    }
     try {
-      const files = fs9.readdirSync(project.knowledgePath);
+      const files = fs10.readdirSync(project.knowledgePath);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path10.join(project.knowledgePath, file);
-        const content = fs9.readFileSync(filePath, "utf-8");
+        const filePath = path11.join(project.knowledgePath, file);
+        const content = fs10.readFileSync(filePath, "utf-8");
         const lines = content.split("\n");
         const matches = [];
         for (const line of lines) {
@@ -1276,11 +1520,44 @@ function searchKnowledge(query) {
   }
   return results;
 }
+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);
+  if (!project) {
+    return { success: false, message: `Project '${projectName}' not found`, filesIndexed: 0 };
+  }
+  const projConfig = config.projects.find(
+    (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
+  );
+  if (!projConfig?.semanticSearch?.enabled) {
+    return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0 };
+  }
+  if (!project.knowledgePath || !fs10.existsSync(project.knowledgePath)) {
+    return { success: false, message: "No knowledge directory found", filesIndexed: 0 };
+  }
+  try {
+    const indexPath = path11.join(project.knowledgePath, "embeddings.json");
+    const rag = new RAGService(indexPath, projConfig.semanticSearch.model);
+    const files = fs10.readdirSync(project.knowledgePath).filter((f) => f.endsWith(".md"));
+    let count = 0;
+    for (const file of files) {
+      const filePath = path11.join(project.knowledgePath, file);
+      const content = fs10.readFileSync(filePath, "utf-8");
+      await rag.indexFile(path11.join(project.knowledgePath, file), content);
+      count++;
+    }
+    return { success: true, message: `Successfully indexed ${count} files`, filesIndexed: count };
+  } catch (error) {
+    return { success: false, message: `Indexing failed: ${error}`, filesIndexed: 0 };
+  }
+}
 var init_resources = __esm({
   "src/mcp/resources.ts"() {
     "use strict";
     init_config();
     init_detection();
+    init_rag();
   }
 });
 
@@ -1429,6 +1706,18 @@ function registerToolHandlers(server) {
           required: ["query"]
         }
       },
+      {
+        name: "index_knowledge",
+        description: "Update the semantic search index for a specific project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project to index" },
+            force: { type: "boolean", description: "Force re-indexing of all files" }
+          },
+          required: ["project"]
+        }
+      },
       {
         name: "list_projects",
         description: "List all projects exposed via MCP",
@@ -1477,9 +1766,14 @@ function registerToolHandlers(server) {
     try {
       switch (name) {
         case "search_knowledge": {
-          const results = searchKnowledge(args.query);
+          const results = await searchKnowledge(args.query);
           return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
         }
+        case "index_knowledge": {
+          const params = args;
+          const result = await indexKnowledge(params.project, params.force);
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
         case "list_projects": {
           const projects = getExposedProjects();
           return {
@@ -1752,8 +2046,8 @@ var init_server = __esm({
 });
 
 // src/mcp/install.ts
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 import * as os from "os";
 function checkInstallStatus(workspacePath) {
   return {
@@ -1764,37 +2058,37 @@ function checkInstallStatus(workspacePath) {
   };
 }
 function checkAntigravityConfig() {
-  if (!fs10.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  if (!fs11.existsSync(ANTIGRAVITY_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs10.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    const content = JSON.parse(fs11.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkClaudeConfig() {
-  if (!fs10.existsSync(CLAUDE_CONFIG)) return false;
+  if (!fs11.existsSync(CLAUDE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs10.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs11.readFileSync(CLAUDE_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeGlobalConfig() {
-  if (!fs10.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  if (!fs11.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs10.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    const content = JSON.parse(fs11.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     return !!content["mcp.servers"]?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path11.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs10.existsSync(configPath)) return false;
+  const configPath = path12.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs11.existsSync(configPath)) return false;
   try {
-    const content = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs11.readFileSync(configPath, "utf-8"));
     return !!content.servers?.["rrce"];
   } catch {
     return false;
@@ -1819,14 +2113,14 @@ function installToConfig(target, workspacePath) {
   }
 }
 function installToAntigravity() {
-  const dir = path11.dirname(ANTIGRAVITY_CONFIG);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path12.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs10.existsSync(ANTIGRAVITY_CONFIG)) {
+  if (fs11.existsSync(ANTIGRAVITY_CONFIG)) {
     try {
-      config = JSON.parse(fs10.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+      config = JSON.parse(fs11.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -1836,21 +2130,21 @@ function installToAntigravity() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs10.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    fs11.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToClaude() {
-  const dir = path11.dirname(CLAUDE_CONFIG);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path12.dirname(CLAUDE_CONFIG);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs10.existsSync(CLAUDE_CONFIG)) {
+  if (fs11.existsSync(CLAUDE_CONFIG)) {
     try {
-      config = JSON.parse(fs10.readFileSync(CLAUDE_CONFIG, "utf-8"));
+      config = JSON.parse(fs11.readFileSync(CLAUDE_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -1860,21 +2154,21 @@ function installToClaude() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs10.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    fs11.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeGlobal() {
-  const dir = path11.dirname(VSCODE_GLOBAL_CONFIG);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path12.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
   let settings = {};
-  if (fs10.existsSync(VSCODE_GLOBAL_CONFIG)) {
+  if (fs11.existsSync(VSCODE_GLOBAL_CONFIG)) {
     try {
-      settings = JSON.parse(fs10.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+      settings = JSON.parse(fs11.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -1884,22 +2178,22 @@ function installToVSCodeGlobal() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs10.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    fs11.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path11.join(workspacePath, ".vscode");
-  const configPath = path11.join(vscodeDir, "mcp.json");
-  if (!fs10.existsSync(vscodeDir)) {
-    fs10.mkdirSync(vscodeDir, { recursive: true });
+  const vscodeDir = path12.join(workspacePath, ".vscode");
+  const configPath = path12.join(vscodeDir, "mcp.json");
+  if (!fs11.existsSync(vscodeDir)) {
+    fs11.mkdirSync(vscodeDir, { recursive: true });
   }
   let config = { servers: {} };
-  if (fs10.existsSync(configPath)) {
+  if (fs11.existsSync(configPath)) {
     try {
-      config = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+      config = JSON.parse(fs11.readFileSync(configPath, "utf-8"));
     } catch {
     }
   }
@@ -1909,7 +2203,7 @@ function installToVSCodeWorkspace(workspacePath) {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs10.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs11.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
@@ -1933,14 +2227,14 @@ var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path11.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path11.join(os.homedir(), ".config/claude/claude_desktop_config.json");
-    VSCODE_GLOBAL_CONFIG = path11.join(os.homedir(), ".config/Code/User/settings.json");
+    ANTIGRAVITY_CONFIG = path12.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path12.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path12.join(os.homedir(), ".config/Code/User/settings.json");
   }
 });
 
 // src/mcp/commands/configure.ts
-import { spinner, note as note2, multiselect, isCancel as isCancel2 } from "@clack/prompts";
+import { spinner, note as note2, multiselect, isCancel as isCancel2, confirm } from "@clack/prompts";
 import pc3 from "picocolors";
 async function handleConfigure() {
   const s = spinner();
@@ -1982,9 +2276,30 @@ async function handleConfigure() {
   }
   const selectedPaths = selected;
   logger.info("Configure: User selected projects by path", selectedPaths);
+  let enableSemanticSearch = false;
+  if (selectedPaths.length > 0) {
+    const shouldEnable = await confirm({
+      message: "Enable Semantic Search (Local Mini RAG)?",
+      initialValue: false
+    });
+    if (isCancel2(shouldEnable)) return;
+    enableSemanticSearch = shouldEnable;
+    if (enableSemanticSearch) {
+      note2(
+        `This enables "search_knowledge" tool for agents.
+First use will download a ~100MB embedding model (all-MiniLM-L6-v2)
+to your local device (one-time).`,
+        "Semantic Search Enabled"
+      );
+    }
+  }
   for (const project of projects) {
     const shouldExpose = selectedPaths.includes(project.dataPath);
-    setProjectConfig(config, project.name, shouldExpose, void 0, project.dataPath);
+    let semanticConfig = void 0;
+    if (shouldExpose && enableSemanticSearch) {
+      semanticConfig = { enabled: true };
+    }
+    setProjectConfig(config, project.name, shouldExpose, void 0, project.dataPath, semanticConfig);
   }
   saveMCPConfig(config);
   logger.info("Configure: Config saved", config);
@@ -1999,8 +2314,8 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs17 = await import("fs");
-  const path16 = await import("path");
+  const fs18 = await import("fs");
+  const path17 = await import("path");
   note2(
     `MCP Hub requires a ${pc3.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -2014,8 +2329,8 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs17.existsSync(resolvedPath)) {
-      fs17.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs18.existsSync(resolvedPath)) {
+      fs18.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
@@ -2023,7 +2338,7 @@ locally in each project. MCP needs a central location.`,
       `${pc3.green("\u2713")} Global path configured: ${pc3.cyan(resolvedPath)}
 
 MCP config will be stored at:
-${path16.join(resolvedPath, "mcp.yaml")}`,
+${path17.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -2500,7 +2815,7 @@ __export(App_exports, {
 });
 import { useState as useState4, useEffect as useEffect4 } from "react";
 import { Box as Box10, useInput as useInput3, useApp } from "ink";
-import fs11 from "fs";
+import fs12 from "fs";
 import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 var TABS, App;
 var init_App = __esm({
@@ -2569,18 +2884,18 @@ var init_App = __esm({
       useEffect4(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs11.existsSync(logPath)) {
-          const stats = fs11.statSync(logPath);
+        if (fs12.existsSync(logPath)) {
+          const stats = fs12.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs11.existsSync(logPath)) {
-            const stats = fs11.statSync(logPath);
+          if (fs12.existsSync(logPath)) {
+            const stats = fs12.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs11.openSync(logPath, "r");
-              fs11.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs11.closeSync(fd);
+              const fd = fs12.openSync(logPath, "r");
+              fs12.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs12.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -2638,7 +2953,7 @@ var init_App = __esm({
 });
 
 // src/mcp/commands/start.ts
-import { confirm, isCancel as isCancel4, text } from "@clack/prompts";
+import { confirm as confirm2, isCancel as isCancel4, text } from "@clack/prompts";
 async function handleStartServer() {
   const React11 = await import("react");
   const { render } = await import("ink");
@@ -2652,7 +2967,7 @@ async function handleStartServer() {
     return cfg?.expose ?? config.defaults.includeNew;
   });
   if (exposedProjects.length === 0) {
-    const shouldConfig = await confirm({
+    const shouldConfig = await confirm2({
       message: "No projects are currently exposed. Configure now?",
       initialValue: true
     });
@@ -2813,7 +3128,7 @@ __export(mcp_exports, {
   handleStartServer: () => handleStartServer,
   runMCP: () => runMCP
 });
-import { intro, outro, confirm as confirm2, note as note6, isCancel as isCancel5 } from "@clack/prompts";
+import { intro, outro, confirm as confirm3, note as note6, isCancel as isCancel5 } from "@clack/prompts";
 import pc7 from "picocolors";
 async function runMCP(subcommand2) {
   if (subcommand2) {
@@ -2861,13 +3176,13 @@ async function runMCP(subcommand2) {
 Allow AI assistants to access your project context.`,
       "Getting Started"
     );
-    const shouldInstall = await confirm2({
+    const shouldInstall = await confirm3({
       message: "Install MCP server integrations now?",
       initialValue: true
     });
     if (shouldInstall && !isCancel5(shouldInstall)) {
       await runInstallWizard(workspacePath);
-      const shouldStart = await confirm2({
+      const shouldStart = await confirm3({
         message: "Start the MCP Dashboard?",
         initialValue: true
       });
@@ -2912,10 +3227,10 @@ var init_mcp = __esm({
 });
 
 // src/commands/wizard/setup-flow.ts
-import { group, select as select2, multiselect as multiselect3, confirm as confirm3, spinner as spinner3, note as note7, outro as outro2, cancel as cancel2, isCancel as isCancel6 } from "@clack/prompts";
+import { group, select as select2, multiselect as multiselect3, confirm as confirm4, spinner as spinner3, note as note7, outro as outro2, cancel as cancel2, isCancel as isCancel6 } from "@clack/prompts";
 import pc8 from "picocolors";
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const s = spinner3();
   const config = await group(
@@ -2953,15 +3268,15 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
           required: false
         });
       },
-      addToGitignore: () => confirm3({
+      addToGitignore: () => confirm4({
         message: "Add generated folders to .gitignore? (as comments - uncomment if needed)",
         initialValue: true
       }),
-      confirm: () => confirm3({
+      confirm: () => confirm4({
         message: "Create configuration?",
         initialValue: true
       }),
-      exposeToMCP: () => confirm3({
+      exposeToMCP: () => confirm4({
         message: "Expose this project to MCP (AI Agent) server?",
         initialValue: true
       })
@@ -3030,7 +3345,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
         outro2(pc8.green(`\u2713 Setup complete! Your agents are ready to use.`));
       }
     } else {
-      const shouldConfigureMCP = await confirm3({
+      const shouldConfigureMCP = await confirm4({
         message: "Would you like to configure the MCP server now?",
         initialValue: true
       });
@@ -3055,14 +3370,14 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path12.join(dataPath, "knowledge"));
-    ensureDir(path12.join(dataPath, "refs"));
-    ensureDir(path12.join(dataPath, "tasks"));
-    ensureDir(path12.join(dataPath, "templates"));
+    ensureDir(path13.join(dataPath, "knowledge"));
+    ensureDir(path13.join(dataPath, "refs"));
+    ensureDir(path13.join(dataPath, "tasks"));
+    ensureDir(path13.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path12.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path13.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (config.tools.includes("copilot")) {
     const copilotPath = getAgentPromptPath(workspacePath, "copilot");
@@ -3074,8 +3389,8 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
     ensureDir(antigravityPath);
     copyPromptsToDir(prompts, antigravityPath, ".md");
   }
-  const workspaceConfigPath = path12.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path12.dirname(workspaceConfigPath));
+  const workspaceConfigPath = path13.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path13.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -3103,7 +3418,7 @@ linked_projects:
 `;
     });
   }
-  fs12.writeFileSync(workspaceConfigPath, configContent);
+  fs13.writeFileSync(workspaceConfigPath, configContent);
   if (config.addToGitignore) {
     updateGitignore(workspacePath, config.storageMode, config.tools);
   }
@@ -3132,8 +3447,8 @@ linked_projects:
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path12.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path12.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path13.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path13.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -3144,7 +3459,7 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
   }
 }
 function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path12.join(workspacePath, ".gitignore");
+  const gitignorePath = path13.join(workspacePath, ".gitignore");
   const entries = [];
   if (storageMode === "workspace") {
     entries.push(".rrce-workflow/");
@@ -3160,8 +3475,8 @@ function updateGitignore(workspacePath, storageMode, tools) {
   }
   try {
     let content = "";
-    if (fs12.existsSync(gitignorePath)) {
-      content = fs12.readFileSync(gitignorePath, "utf-8");
+    if (fs13.existsSync(gitignorePath)) {
+      content = fs13.readFileSync(gitignorePath, "utf-8");
     }
     const lines = content.split("\n").map((line) => line.trim());
     const newEntries = [];
@@ -3186,7 +3501,7 @@ function updateGitignore(workspacePath, storageMode, tools) {
       newContent += "\n# rrce-workflow generated folders (uncomment to ignore)\n";
     }
     newContent += newEntries.map((e) => `# ${e}`).join("\n") + "\n";
-    fs12.writeFileSync(gitignorePath, newContent);
+    fs13.writeFileSync(gitignorePath, newContent);
     return true;
   } catch {
     return false;
@@ -3205,9 +3520,9 @@ var init_setup_flow = __esm({
 });
 
 // src/commands/wizard/link-flow.ts
-import { multiselect as multiselect4, spinner as spinner4, note as note8, outro as outro3, cancel as cancel3, isCancel as isCancel7, confirm as confirm4 } from "@clack/prompts";
+import { multiselect as multiselect4, spinner as spinner4, note as note8, outro as outro3, cancel as cancel3, isCancel as isCancel7, confirm as confirm5 } from "@clack/prompts";
 import pc9 from "picocolors";
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
@@ -3245,7 +3560,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs13.readFileSync(configFilePath, "utf-8");
+  let configContent = fs14.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -3272,7 +3587,7 @@ linked_projects:
 `;
     });
   }
-  fs13.writeFileSync(configFilePath, configContent);
+  fs14.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -3284,7 +3599,7 @@ linked_projects:
   ];
   note8(summary.join("\n"), "Link Summary");
   outro3(pc9.green(`\u2713 Projects linked! Open ${pc9.bold(workspaceFile)} in VSCode to access linked data.`));
-  const shouldExpose = await confirm4({
+  const shouldExpose = await confirm5({
     message: "Also expose these linked projects to the MCP server (for Agent access)?",
     initialValue: true
   });
@@ -3312,17 +3627,17 @@ var init_link_flow = __esm({
 });
 
 // src/commands/wizard/sync-flow.ts
-import { confirm as confirm5, spinner as spinner5, note as note9, outro as outro4, cancel as cancel4, isCancel as isCancel8 } from "@clack/prompts";
+import { confirm as confirm6, spinner as spinner5, note as note9, outro as outro4, cancel as cancel4, isCancel as isCancel8 } from "@clack/prompts";
 import pc10 from "picocolors";
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path14 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path13.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path14.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs14.existsSync(path13.join(localPath, dir))
+    (dir) => fs15.existsSync(path14.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro4(pc10.yellow("No data found in workspace storage to sync."));
@@ -3335,7 +3650,7 @@ ${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 Destination: ${pc10.cyan(globalPath)}`,
     "Sync Preview"
   );
-  const shouldSync = await confirm5({
+  const shouldSync = await confirm6({
     message: "Proceed with sync to global storage?",
     initialValue: true
   });
@@ -3348,8 +3663,8 @@ Destination: ${pc10.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path13.join(localPath, dir);
-      const destDir = path13.join(globalPath, dir);
+      const srcDir = path14.join(localPath, dir);
+      const destDir = path14.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -3379,10 +3694,10 @@ var init_sync_flow = __esm({
 });
 
 // src/commands/wizard/update-flow.ts
-import { confirm as confirm6, spinner as spinner6, note as note10, outro as outro5, cancel as cancel5, isCancel as isCancel9 } from "@clack/prompts";
+import { confirm as confirm7, spinner as spinner6, note as note10, outro as outro5, cancel as cancel5, isCancel as isCancel9 } from "@clack/prompts";
 import pc11 from "picocolors";
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner6();
   s.start("Checking for updates");
@@ -3402,7 +3717,7 @@ Target locations:
 ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       "Update Preview"
     );
-    const shouldUpdate = await confirm6({
+    const shouldUpdate = await confirm7({
       message: "Proceed with update?",
       initialValue: true
     });
@@ -3412,10 +3727,10 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path14.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path15.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs15.readFileSync(configFilePath, "utf-8");
+    const configContent = fs16.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -3443,8 +3758,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path14.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path14.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path15.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path15.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -3470,7 +3785,7 @@ __export(wizard_exports, {
 });
 import { intro as intro2, select as select3, spinner as spinner7, note as note11, outro as outro6, isCancel as isCancel10 } from "@clack/prompts";
 import pc12 from "picocolors";
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 async function runWizard() {
   intro2(pc12.cyan(pc12.inverse(" RRCE-Workflow Setup ")));
   const s = spinner7();
@@ -3490,18 +3805,18 @@ Workspace: ${pc12.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs16.existsSync(configFilePath);
+  const isAlreadyConfigured = fs17.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs16.readFileSync(configFilePath, "utf-8");
+      const configContent = fs17.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs16.existsSync(localDataPath);
+  const hasLocalData = fs17.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     menuOptions.push({
@@ -3576,9 +3891,9 @@ init_wizard();
 init_prompts();
 import { intro as intro3, select as select4, note as note12, cancel as cancel7, isCancel as isCancel11, outro as outro7 } from "@clack/prompts";
 import pc13 from "picocolors";
-import * as path15 from "path";
+import * as path16 from "path";
 async function runSelector() {
-  const workspaceName = path15.basename(process.cwd());
+  const workspaceName = path16.basename(process.cwd());
   intro3(pc13.cyan(pc13.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.43",
+  "version": "0.2.44",
   "description": "RRCE-Workflow TUI - Agentic code workflow generator for AI-assisted development",
   "author": "RRCE Team",
   "license": "MIT",
@@ -49,11 +49,13 @@
     "@clack/core": "^0.5.0",
     "@clack/prompts": "^0.11.0",
     "@modelcontextprotocol/sdk": "^1.25.1",
+    "@xenova/transformers": "^2.17.2",
     "gray-matter": "^4.0.3",
     "ink": "^6.6.0",
     "ink-link": "^5.0.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
+    "onnxruntime-node": "^1.23.2",
     "picocolors": "^1.1.1",
     "react": "^19.2.3",
     "zod": "^4.2.1"