rrce-workflow 0.3.14 → 0.3.16

package/dist/index.js

@@ -2524,6 +2524,234 @@ var init_dependency_graph = __esm({
   }
 });
 
+// src/mcp/services/symbol-extractor.ts
+function extractSymbols(content, filePath) {
+  const lines = content.split("\n");
+  const symbols = [];
+  const exports = [];
+  const imports = [];
+  const language = getLanguageFromPath(filePath);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const lineNum = i + 1;
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || !trimmed) {
+      continue;
+    }
+    const importMatch = line.match(/^import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+    if (importMatch) {
+      imports.push(importMatch[3] ?? "");
+      continue;
+    }
+    const reExportMatch = line.match(/^export\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
+    if (reExportMatch) {
+      const items = (reExportMatch[1] ?? "").split(",").map((s) => s.trim().split(" as ")[0]?.trim() ?? "");
+      exports.push(...items.filter(Boolean));
+      continue;
+    }
+    const isExported = trimmed.startsWith("export ");
+    const cleanLine = isExported ? trimmed.replace(/^export\s+(default\s+)?/, "") : trimmed;
+    const funcMatch = cleanLine.match(/^(?:async\s+)?function\s+(\w+)\s*(\([^)]*\))/);
+    if (funcMatch && funcMatch[1]) {
+      const name = funcMatch[1];
+      const params = funcMatch[2] ?? "()";
+      symbols.push({
+        name,
+        type: "function",
+        line: lineNum,
+        signature: `function ${name}${params}`,
+        exported: isExported
+      });
+      if (isExported) exports.push(name);
+      continue;
+    }
+    const arrowMatch = cleanLine.match(/^(const|let|var)\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/);
+    if (arrowMatch && arrowMatch[2]) {
+      const name = arrowMatch[2];
+      symbols.push({
+        name,
+        type: "function",
+        line: lineNum,
+        signature: `const ${name} = (...)`,
+        exported: isExported
+      });
+      if (isExported) exports.push(name);
+      continue;
+    }
+    const classMatch = cleanLine.match(/^(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{]+))?/);
+    if (classMatch && classMatch[1]) {
+      const name = classMatch[1];
+      const extendsClass = classMatch[2];
+      let signature = `class ${name}`;
+      if (extendsClass) signature += ` extends ${extendsClass}`;
+      symbols.push({
+        name,
+        type: "class",
+        line: lineNum,
+        signature,
+        exported: isExported
+      });
+      if (isExported) exports.push(name);
+      continue;
+    }
+    const interfaceMatch = cleanLine.match(/^interface\s+(\w+)(?:<[^>]+>)?(?:\s+extends\s+([^{]+))?/);
+    if (interfaceMatch && interfaceMatch[1]) {
+      const name = interfaceMatch[1];
+      symbols.push({
+        name,
+        type: "interface",
+        line: lineNum,
+        signature: `interface ${name}`,
+        exported: isExported
+      });
+      if (isExported) exports.push(name);
+      continue;
+    }
+    const typeMatch = cleanLine.match(/^type\s+(\w+)(?:<[^>]+>)?\s*=/);
+    if (typeMatch && typeMatch[1]) {
+      const name = typeMatch[1];
+      symbols.push({
+        name,
+        type: "type",
+        line: lineNum,
+        signature: `type ${name}`,
+        exported: isExported
+      });
+      if (isExported) exports.push(name);
+      continue;
+    }
+    const enumMatch = cleanLine.match(/^(?:const\s+)?enum\s+(\w+)/);
+    if (enumMatch && enumMatch[1]) {
+      const name = enumMatch[1];
+      symbols.push({
+        name,
+        type: "enum",
+        line: lineNum,
+        signature: `enum ${name}`,
+        exported: isExported
+      });
+      if (isExported) exports.push(name);
+      continue;
+    }
+    const varMatch = cleanLine.match(/^(const|let|var)\s+(\w+)\s*(?::\s*([^=]+))?\s*=/);
+    if (varMatch && varMatch[2]) {
+      if (line.includes("=>")) continue;
+      const name = varMatch[2];
+      const varType = varMatch[1];
+      symbols.push({
+        name,
+        type: varType === "const" ? "const" : "variable",
+        line: lineNum,
+        signature: `${varMatch[1]} ${name}`,
+        exported: isExported
+      });
+      if (isExported) exports.push(name);
+      continue;
+    }
+    const defaultExportMatch = trimmed.match(/^export\s+default\s+(?:class|function)?\s*(\w+)?/);
+    if (defaultExportMatch && defaultExportMatch[1]) {
+      exports.push(defaultExportMatch[1]);
+    }
+  }
+  return {
+    filePath,
+    language,
+    symbols,
+    exports: Array.from(new Set(exports)),
+    imports: Array.from(new Set(imports))
+  };
+}
+function fuzzyMatchScore(query, symbolName) {
+  const q = query.toLowerCase();
+  const s = symbolName.toLowerCase();
+  if (q === s) return 1;
+  if (s.startsWith(q)) return 0.9;
+  if (s.includes(q)) return 0.7;
+  if (q.startsWith(s)) return 0.6;
+  const distance = levenshteinDistance(q, s);
+  const maxLen = Math.max(q.length, s.length);
+  const similarity = 1 - distance / maxLen;
+  return Math.max(0, similarity * 0.5);
+}
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function getLanguageFromPath(filePath) {
+  const ext = filePath.toLowerCase().split(".").pop() ?? "";
+  const langMap = {
+    "ts": "typescript",
+    "tsx": "typescript",
+    "js": "javascript",
+    "jsx": "javascript",
+    "mjs": "javascript",
+    "cjs": "javascript",
+    "py": "python",
+    "go": "go",
+    "rs": "rust",
+    "java": "java",
+    "kt": "kotlin",
+    "rb": "ruby",
+    "php": "php",
+    "swift": "swift",
+    "c": "c",
+    "cpp": "cpp",
+    "h": "c",
+    "hpp": "cpp",
+    "cs": "csharp"
+  };
+  return langMap[ext] ?? "unknown";
+}
+function searchSymbols(symbolResults, query, options = {}) {
+  const { type = "any", fuzzy = true, limit = 10, minScore = 0.3 } = options;
+  const matches = [];
+  for (const result of symbolResults) {
+    for (const symbol of result.symbols) {
+      if (type !== "any" && symbol.type !== type) continue;
+      const score = fuzzy ? fuzzyMatchScore(query, symbol.name) : symbol.name.toLowerCase().includes(query.toLowerCase()) ? 1 : 0;
+      if (score >= minScore) {
+        matches.push({
+          ...symbol,
+          file: result.filePath,
+          score
+        });
+      }
+    }
+  }
+  matches.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.name.length - b.name.length;
+  });
+  return matches.slice(0, limit);
+}
+var init_symbol_extractor = __esm({
+  "src/mcp/services/symbol-extractor.ts"() {
+    "use strict";
+  }
+});
+
 // src/mcp/resources.ts
 import * as fs15 from "fs";
 import * as path17 from "path";
@@ -2689,7 +2917,10 @@ function getProjectTasks(projectName) {
   }
   return tasks;
 }
-async function searchCode(query, projectFilter, limit = 10) {
+function estimateTokens(text2) {
+  return Math.ceil(text2.length / 4);
+}
+async function searchCode(query, projectFilter, limit = 10, options) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
   const results = [];
@@ -2697,8 +2928,8 @@ async function searchCode(query, projectFilter, limit = 10) {
     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 indexingInProgress2 = indexingJobs.isRunning(project.name);
+    const advisoryMessage2 = indexingInProgress2 ? "Indexing in progress; results may be stale/incomplete." : void 0;
     const projConfig = findProjectConfig(config, { name: project.name, path: project.sourcePath || project.path });
     const useRAG = projConfig?.semanticSearch?.enabled;
     if (!useRAG) {
@@ -2724,8 +2955,8 @@ async function searchCode(query, projectFilter, limit = 10) {
           context: codeChunk.context,
           language: codeChunk.language,
           score: codeChunk.score,
-          indexingInProgress: indexingInProgress || void 0,
-          advisoryMessage
+          indexingInProgress: indexingInProgress2 || void 0,
+          advisoryMessage: advisoryMessage2
         });
       }
     } catch (e) {
@@ -2733,9 +2964,56 @@ async function searchCode(query, projectFilter, limit = 10) {
     }
   }
   results.sort((a, b) => b.score - a.score);
-  return results.slice(0, limit);
+  let filteredResults = results;
+  if (options?.min_score !== void 0 && options.min_score > 0) {
+    filteredResults = results.filter((r) => r.score >= options.min_score);
+  }
+  let limitedResults = filteredResults.slice(0, limit);
+  let truncated = false;
+  let tokenCount = 0;
+  if (options?.max_tokens !== void 0 && options.max_tokens > 0) {
+    const budgetedResults = [];
+    for (const result of limitedResults) {
+      const resultTokens = estimateTokens(result.snippet + (result.context || ""));
+      if (tokenCount + resultTokens > options.max_tokens) {
+        truncated = true;
+        break;
+      }
+      budgetedResults.push(result);
+      tokenCount += resultTokens;
+    }
+    limitedResults = budgetedResults;
+  } else {
+    tokenCount = limitedResults.reduce((sum, r) => sum + estimateTokens(r.snippet + (r.context || "")), 0);
+  }
+  let indexAgeSeconds;
+  let lastIndexedAt;
+  let indexingInProgress;
+  let advisoryMessage;
+  if (projectFilter) {
+    const project = projects.find((p) => p.name === projectFilter);
+    if (project) {
+      indexingInProgress = indexingJobs.isRunning(project.name);
+      advisoryMessage = indexingInProgress ? "Indexing in progress; results may be stale/incomplete." : void 0;
+      const progress = indexingJobs.getProgress(project.name);
+      if (progress.completedAt) {
+        lastIndexedAt = new Date(progress.completedAt).toISOString();
+        indexAgeSeconds = Math.floor((Date.now() - progress.completedAt) / 1e3);
+      }
+    }
+  }
+  const cleanResults = limitedResults.map(({ indexingInProgress: _, advisoryMessage: __, ...rest }) => rest);
+  return {
+    results: cleanResults,
+    token_count: tokenCount,
+    truncated,
+    index_age_seconds: indexAgeSeconds,
+    last_indexed_at: lastIndexedAt,
+    indexingInProgress,
+    advisoryMessage
+  };
 }
-async function searchKnowledge(query, projectFilter) {
+async function searchKnowledge(query, projectFilter, options) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
   const results = [];
@@ -2744,8 +3022,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 indexingInProgress2 = indexingJobs.isRunning(project.name);
+    const advisoryMessage2 = indexingInProgress2 ? "Indexing in progress; results may be stale/incomplete." : void 0;
     const projConfig = findProjectConfig(config, { name: project.name, path: project.sourcePath || project.path });
     const useRAG = projConfig?.semanticSearch?.enabled;
     if (useRAG) {
@@ -2761,8 +3039,8 @@ async function searchKnowledge(query, projectFilter) {
             matches: [r.content],
             // The chunk content is the match
             score: r.score,
-            indexingInProgress: indexingInProgress || void 0,
-            advisoryMessage
+            indexingInProgress: indexingInProgress2 || void 0,
+            advisoryMessage: advisoryMessage2
           });
         }
         continue;
@@ -2789,8 +3067,8 @@ async function searchKnowledge(query, projectFilter) {
             file,
             matches: matches.slice(0, 5),
             // Limit to 5 matches per file
-            indexingInProgress: indexingInProgress || void 0,
-            advisoryMessage
+            indexingInProgress: indexingInProgress2 || void 0,
+            advisoryMessage: advisoryMessage2
           });
         }
       }
@@ -2798,7 +3076,54 @@ async function searchKnowledge(query, projectFilter) {
       logger.error(`[searchKnowledge] Failed to read knowledge directory ${project.knowledgePath}`, err);
     }
   }
-  return results;
+  let filteredResults = results;
+  if (options?.min_score !== void 0 && options.min_score > 0) {
+    filteredResults = results.filter((r) => (r.score ?? 1) >= options.min_score);
+  }
+  filteredResults.sort((a, b) => (b.score ?? 1) - (a.score ?? 1));
+  let truncated = false;
+  let tokenCount = 0;
+  let budgetedResults = filteredResults;
+  if (options?.max_tokens !== void 0 && options.max_tokens > 0) {
+    budgetedResults = [];
+    for (const result of filteredResults) {
+      const resultTokens = estimateTokens(result.matches.join("\n"));
+      if (tokenCount + resultTokens > options.max_tokens) {
+        truncated = true;
+        break;
+      }
+      budgetedResults.push(result);
+      tokenCount += resultTokens;
+    }
+  } else {
+    tokenCount = filteredResults.reduce((sum, r) => sum + estimateTokens(r.matches.join("\n")), 0);
+  }
+  let indexAgeSeconds;
+  let lastIndexedAt;
+  let indexingInProgress;
+  let advisoryMessage;
+  if (projectFilter) {
+    const project = projects.find((p) => p.name === projectFilter);
+    if (project) {
+      indexingInProgress = indexingJobs.isRunning(project.name);
+      advisoryMessage = indexingInProgress ? "Indexing in progress; results may be stale/incomplete." : void 0;
+      const progress = indexingJobs.getProgress(project.name);
+      if (progress.completedAt) {
+        lastIndexedAt = new Date(progress.completedAt).toISOString();
+        indexAgeSeconds = Math.floor((Date.now() - progress.completedAt) / 1e3);
+      }
+    }
+  }
+  const cleanResults = budgetedResults.map(({ indexingInProgress: _, advisoryMessage: __, ...rest }) => rest);
+  return {
+    results: cleanResults,
+    token_count: tokenCount,
+    truncated,
+    index_age_seconds: indexAgeSeconds,
+    last_indexed_at: lastIndexedAt,
+    indexingInProgress,
+    advisoryMessage
+  };
 }
 function getScanContext(project, scanRoot) {
   const gitignorePath = path17.join(scanRoot, ".gitignore");
@@ -3160,6 +3485,453 @@ async function findRelatedFiles2(filePath, projectName, options = {}) {
     };
   }
 }
+async function searchSymbols2(name, projectName, options = {}) {
+  const config = loadMCPConfig();
+  const projects = getExposedProjects();
+  const project = projects.find((p) => p.name === projectName);
+  if (!project) {
+    return {
+      success: false,
+      project: projectName,
+      results: [],
+      message: `Project '${projectName}' not found`
+    };
+  }
+  const projectRoot = project.sourcePath || project.path || "";
+  if (!fs15.existsSync(projectRoot)) {
+    return {
+      success: false,
+      project: projectName,
+      results: [],
+      message: `Project root not found: ${projectRoot}`
+    };
+  }
+  try {
+    const codeFiles = [];
+    const scanDir = (dir) => {
+      const entries = fs15.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path17.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.includes(entry.name)) continue;
+          scanDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path17.extname(entry.name).toLowerCase();
+          if (CODE_EXTENSIONS.includes(ext)) {
+            codeFiles.push(fullPath);
+          }
+        }
+      }
+    };
+    scanDir(projectRoot);
+    const symbolResults = [];
+    for (const file of codeFiles.slice(0, 500)) {
+      try {
+        const content = fs15.readFileSync(file, "utf-8");
+        const result = extractSymbols(content, file);
+        symbolResults.push(result);
+      } catch (e) {
+      }
+    }
+    const matches = searchSymbols(symbolResults, name, {
+      type: options.type,
+      fuzzy: options.fuzzy ?? true,
+      limit: options.limit ?? 10,
+      minScore: 0.3
+    });
+    const results = matches.map((m) => ({
+      name: m.name,
+      type: m.type,
+      file: path17.relative(projectRoot, m.file),
+      line: m.line,
+      signature: m.signature,
+      exported: m.exported,
+      score: m.score
+    }));
+    return {
+      success: true,
+      project: projectName,
+      results
+    };
+  } catch (e) {
+    logger.error(`[searchSymbols] Error searching symbols in ${projectName}`, e);
+    return {
+      success: false,
+      project: projectName,
+      results: [],
+      message: `Error searching symbols: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+async function getFileSummary(filePath, projectName) {
+  const config = loadMCPConfig();
+  const projects = getExposedProjects();
+  const project = projects.find((p) => p.name === projectName);
+  if (!project) {
+    return {
+      success: false,
+      message: `Project '${projectName}' not found`
+    };
+  }
+  const projectRoot = project.sourcePath || project.path || "";
+  let absolutePath = filePath;
+  if (!path17.isAbsolute(filePath)) {
+    absolutePath = path17.resolve(projectRoot, filePath);
+  }
+  if (!fs15.existsSync(absolutePath)) {
+    return {
+      success: false,
+      message: `File not found: ${filePath}`
+    };
+  }
+  try {
+    const stat = fs15.statSync(absolutePath);
+    const content = fs15.readFileSync(absolutePath, "utf-8");
+    const lines = content.split("\n");
+    const symbolResult = extractSymbols(content, absolutePath);
+    return {
+      success: true,
+      summary: {
+        path: path17.relative(projectRoot, absolutePath),
+        language: symbolResult.language,
+        lines: lines.length,
+        size_bytes: stat.size,
+        last_modified: stat.mtime.toISOString(),
+        exports: symbolResult.exports,
+        imports: symbolResult.imports,
+        symbols: symbolResult.symbols.map((s) => ({
+          name: s.name,
+          type: s.type,
+          line: s.line
+        }))
+      }
+    };
+  } catch (e) {
+    logger.error(`[getFileSummary] Error reading ${filePath}`, e);
+    return {
+      success: false,
+      message: `Error reading file: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+}
+async function getContextBundle(query, projectName, options = {}) {
+  const maxTokens = options.max_tokens ?? 4e3;
+  const include = {
+    project_context: options.include?.project_context ?? true,
+    knowledge: options.include?.knowledge ?? true,
+    code: options.include?.code ?? true,
+    related_files: options.include?.related_files ?? false
+  };
+  const contextBudget = Math.floor(maxTokens * 0.4);
+  const knowledgeBudget = Math.floor(maxTokens * 0.3);
+  const codeBudget = Math.floor(maxTokens * 0.3);
+  let totalTokens = 0;
+  let truncated = false;
+  let indexAgeSeconds;
+  let projectContext = null;
+  if (include.project_context) {
+    const rawContext = getProjectContext(projectName);
+    if (rawContext) {
+      const contextTokens = estimateTokens(rawContext);
+      if (contextTokens <= contextBudget) {
+        projectContext = rawContext;
+        totalTokens += contextTokens;
+      } else {
+        const maxChars = contextBudget * 4;
+        projectContext = rawContext.slice(0, maxChars) + "\n\n[truncated]";
+        totalTokens += contextBudget;
+        truncated = true;
+      }
+    }
+  }
+  const knowledgeResults = [];
+  if (include.knowledge) {
+    const knowledgeSearch = await searchKnowledge(query, projectName, { max_tokens: knowledgeBudget });
+    for (const r of knowledgeSearch.results) {
+      knowledgeResults.push({
+        file: r.file,
+        matches: r.matches,
+        score: r.score
+      });
+    }
+    totalTokens += knowledgeSearch.token_count;
+    if (knowledgeSearch.truncated) truncated = true;
+    if (knowledgeSearch.index_age_seconds !== void 0) {
+      indexAgeSeconds = knowledgeSearch.index_age_seconds;
+    }
+  }
+  const codeResults = [];
+  if (include.code) {
+    const codeSearch = await searchCode(query, projectName, 10, { max_tokens: codeBudget });
+    for (const r of codeSearch.results) {
+      codeResults.push({
+        file: r.file,
+        snippet: r.snippet,
+        lineStart: r.lineStart,
+        lineEnd: r.lineEnd,
+        context: r.context,
+        score: r.score
+      });
+    }
+    totalTokens += codeSearch.token_count;
+    if (codeSearch.truncated) truncated = true;
+    if (codeSearch.index_age_seconds !== void 0 && indexAgeSeconds === void 0) {
+      indexAgeSeconds = codeSearch.index_age_seconds;
+    }
+  }
+  const relatedFiles = [];
+  if (include.related_files && codeResults.length > 0) {
+    const topFile = codeResults[0]?.file;
+    if (topFile) {
+      const related = await findRelatedFiles2(topFile, projectName, { depth: 1 });
+      if (related.success) {
+        for (const r of related.relationships.slice(0, 5)) {
+          relatedFiles.push(r.file);
+        }
+      }
+    }
+  }
+  return {
+    success: true,
+    project_context: projectContext,
+    knowledge_results: knowledgeResults,
+    code_results: codeResults,
+    related_files: relatedFiles,
+    token_count: totalTokens,
+    truncated,
+    index_age_seconds: indexAgeSeconds
+  };
+}
+async function prefetchTaskContext(projectName, taskSlug, options = {}) {
+  const maxTokens = options.max_tokens ?? 6e3;
+  const task = getTask(projectName, taskSlug);
+  if (!task) {
+    return {
+      success: false,
+      task: null,
+      project_context: null,
+      referenced_files: [],
+      knowledge_matches: [],
+      code_matches: [],
+      token_count: 0,
+      truncated: false,
+      message: `Task '${taskSlug}' not found in project '${projectName}'`
+    };
+  }
+  const searchQuery = `${task.title || ""} ${task.summary || ""}`.trim();
+  const bundle = await getContextBundle(searchQuery, projectName, {
+    max_tokens: Math.floor(maxTokens * 0.7),
+    // Reserve 30% for referenced files
+    include: {
+      project_context: true,
+      knowledge: true,
+      code: true,
+      related_files: false
+    }
+  });
+  const referencedFiles = [];
+  const references = task.references;
+  if (references && Array.isArray(references)) {
+    for (const ref of references.slice(0, 5)) {
+      const summary = await getFileSummary(ref, projectName);
+      if (summary.success && summary.summary) {
+        referencedFiles.push({
+          path: summary.summary.path,
+          language: summary.summary.language,
+          lines: summary.summary.lines,
+          exports: summary.summary.exports
+        });
+      }
+    }
+  }
+  const taskTokens = estimateTokens(JSON.stringify(task));
+  const refTokens = estimateTokens(JSON.stringify(referencedFiles));
+  return {
+    success: true,
+    task,
+    project_context: bundle.project_context,
+    referenced_files: referencedFiles,
+    knowledge_matches: bundle.knowledge_results,
+    code_matches: bundle.code_results,
+    token_count: bundle.token_count + taskTokens + refTokens,
+    truncated: bundle.truncated
+  };
+}
+function searchTasks(projectName, options = {}) {
+  const allTasks = getProjectTasks(projectName);
+  const limit = options.limit ?? 20;
+  let filtered = allTasks;
+  if (options.status) {
+    filtered = filtered.filter((t) => t.status === options.status);
+  }
+  if (options.agent) {
+    filtered = filtered.filter((t) => {
+      const agents = t.agents;
+      if (!agents) return false;
+      return agents[options.agent]?.status !== void 0;
+    });
+  }
+  if (options.since) {
+    const sinceDate = new Date(options.since).getTime();
+    filtered = filtered.filter((t) => {
+      const updatedAt = t.updated_at;
+      if (!updatedAt) return false;
+      return new Date(updatedAt).getTime() >= sinceDate;
+    });
+  }
+  if (options.keyword) {
+    const kw = options.keyword.toLowerCase();
+    filtered = filtered.map((t) => {
+      const title = (t.title || "").toLowerCase();
+      const summary = (t.summary || "").toLowerCase();
+      let relevance = 0;
+      if (title.includes(kw)) relevance += 2;
+      if (summary.includes(kw)) relevance += 1;
+      if (t.task_slug.toLowerCase().includes(kw)) relevance += 1;
+      return { ...t, relevance };
+    }).filter((t) => t.relevance > 0);
+    filtered.sort((a, b) => (b.relevance ?? 0) - (a.relevance ?? 0));
+  } else {
+    filtered.sort((a, b) => {
+      const aDate = new Date(a.updated_at || 0).getTime();
+      const bDate = new Date(b.updated_at || 0).getTime();
+      return bDate - aDate;
+    });
+  }
+  return filtered.slice(0, limit);
+}
+function validatePhase(projectName, taskSlug, phase) {
+  const task = getTask(projectName, taskSlug);
+  if (!task) {
+    return {
+      valid: false,
+      phase,
+      status: "not_found",
+      missing_items: ["Task does not exist"],
+      suggestions: [`Create task with: create_task(project: "${projectName}", task_slug: "${taskSlug}")`]
+    };
+  }
+  const agents = task.agents;
+  const phaseData = agents?.[phase === "execution" ? "executor" : phase];
+  const status = phaseData?.status || "pending";
+  const missing = [];
+  const suggestions = [];
+  switch (phase) {
+    case "research":
+      if (status !== "complete") {
+        missing.push("Research phase not complete");
+        suggestions.push(`Run research phase: /rrce_research ${taskSlug}`);
+      }
+      if (!phaseData?.artifact) {
+        missing.push("Research artifact not saved");
+        suggestions.push("Save research brief to complete the phase");
+      }
+      break;
+    case "planning":
+      const researchStatus = agents?.research?.status;
+      if (researchStatus !== "complete") {
+        missing.push("Research phase not complete");
+        suggestions.push(`Complete research first: /rrce_research ${taskSlug}`);
+      }
+      if (status !== "complete") {
+        missing.push("Planning phase not complete");
+        suggestions.push(`Run planning phase: /rrce_plan ${taskSlug}`);
+      }
+      if (!phaseData?.artifact) {
+        missing.push("Planning artifact not saved");
+      }
+      if (!phaseData?.task_count) {
+        missing.push("Task breakdown not defined");
+      }
+      break;
+    case "execution":
+      const planningStatus = agents?.planning?.status;
+      if (planningStatus !== "complete") {
+        missing.push("Planning phase not complete");
+        suggestions.push(`Complete planning first: /rrce_plan ${taskSlug}`);
+      }
+      if (status !== "complete") {
+        missing.push("Execution phase not complete");
+        suggestions.push(`Run execution phase: /rrce_execute ${taskSlug}`);
+      }
+      break;
+    case "documentation":
+      const executorStatus = agents?.executor?.status;
+      if (executorStatus !== "complete") {
+        missing.push("Execution phase not complete");
+        suggestions.push(`Complete execution first: /rrce_execute ${taskSlug}`);
+      }
+      if (status !== "complete") {
+        missing.push("Documentation phase not complete");
+        suggestions.push(`Run documentation phase: /rrce_docs ${taskSlug}`);
+      }
+      break;
+  }
+  return {
+    valid: missing.length === 0,
+    phase,
+    status,
+    missing_items: missing,
+    suggestions
+  };
+}
+function startSession(projectName, taskSlug, agent, phase) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project || !project.tasksPath) {
+    return { success: false, message: `Project '${projectName}' not found or not exposed.` };
+  }
+  const taskDir = path17.join(project.tasksPath, taskSlug);
+  if (!fs15.existsSync(taskDir)) {
+    return { success: false, message: `Task '${taskSlug}' not found.` };
+  }
+  const session = {
+    agent,
+    phase,
+    task_slug: taskSlug,
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    heartbeat: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const sessionPath = path17.join(taskDir, "session.json");
+  fs15.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+  return { success: true, message: `Session started for ${agent} agent on task '${taskSlug}' (phase: ${phase})` };
+}
+function endSession(projectName, taskSlug) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project || !project.tasksPath) {
+    return { success: false, message: `Project '${projectName}' not found or not exposed.` };
+  }
+  const sessionPath = path17.join(project.tasksPath, taskSlug, "session.json");
+  if (!fs15.existsSync(sessionPath)) {
+    return { success: true, message: `No active session for task '${taskSlug}'.` };
+  }
+  fs15.unlinkSync(sessionPath);
+  return { success: true, message: `Session ended for task '${taskSlug}'.` };
+}
+function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.sourcePath || p.path));
+  if (!project || !project.tasksPath) {
+    return { success: false, message: `Project '${projectName}' not found or not exposed.` };
+  }
+  const taskDir = path17.join(project.tasksPath, taskSlug);
+  if (!fs15.existsSync(taskDir)) {
+    fs15.mkdirSync(taskDir, { recursive: true });
+  }
+  const todos = {
+    phase,
+    agent,
+    items,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const todosPath = path17.join(taskDir, "agent-todos.json");
+  fs15.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
+  return { success: true, message: `Updated ${items.length} todo items for task '${taskSlug}'.`, count: items.length };
+}
 var INDEXABLE_EXTENSIONS, CODE_EXTENSIONS, SKIP_DIRS;
 var init_resources = __esm({
   "src/mcp/resources.ts"() {
@@ -3173,6 +3945,7 @@ var init_resources = __esm({
     init_indexing_jobs();
     init_context_extractor();
     init_dependency_graph();
+    init_symbol_extractor();
     init_paths();
     INDEXABLE_EXTENSIONS = [
       ".ts",
@@ -3476,25 +4249,29 @@ function registerToolHandlers(server) {
       },
       {
         name: "search_knowledge",
-        description: "Search across all exposed project knowledge bases",
+        description: "Search across all exposed project knowledge bases. Returns results with token count and optional truncation.",
         inputSchema: {
           type: "object",
           properties: {
             query: { type: "string", description: "Search query to find in knowledge files" },
-            project: { type: "string", description: "Optional: limit search to specific project name" }
+            project: { type: "string", description: "Optional: limit search to specific project name" },
+            max_tokens: { type: "number", description: "Optional: maximum tokens for response (truncates by relevance)" },
+            min_score: { type: "number", description: "Optional: minimum relevance score threshold (0-1)" }
           },
           required: ["query"]
         }
       },
       {
         name: "search_code",
-        description: "Semantic search across code files. Returns code snippets with line numbers and function/class context. Use for finding implementations, patterns, or understanding code.",
+        description: "Semantic search across code files. Returns code snippets with line numbers, function/class context, and token budget support.",
         inputSchema: {
           type: "object",
           properties: {
             query: { type: "string", description: 'Search query (e.g., "error handling", "authentication logic", "database connection")' },
             project: { type: "string", description: "Optional: limit search to specific project name" },
-            limit: { type: "number", description: "Maximum number of results (default 10)" }
+            limit: { type: "number", description: "Maximum number of results (default 10)" },
+            max_tokens: { type: "number", description: "Optional: maximum tokens for response (truncates by relevance)" },
+            min_score: { type: "number", description: "Optional: minimum relevance score threshold (0-1)" }
           },
           required: ["query"]
         }
@@ -3514,6 +4291,99 @@ function registerToolHandlers(server) {
           required: ["file", "project"]
         }
       },
+      {
+        name: "search_symbols",
+        description: "Search for code symbols (functions, classes, types, variables) by name. Uses fuzzy matching. Faster than search_code for finding definitions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Symbol name to search for" },
+            project: { type: "string", description: "Name of the project" },
+            type: { type: "string", enum: ["function", "class", "type", "interface", "variable", "const", "enum", "any"], description: "Filter by symbol type (default: any)" },
+            fuzzy: { type: "boolean", description: "Use fuzzy matching (default: true)" },
+            limit: { type: "number", description: "Maximum results (default: 10)" }
+          },
+          required: ["name", "project"]
+        }
+      },
+      {
+        name: "get_file_summary",
+        description: "Get a quick summary of a file without reading full content. Returns: language, LOC, exports, imports, key symbols.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file: { type: "string", description: "Path to the file (absolute or project-relative)" },
+            project: { type: "string", description: "Name of the project" }
+          },
+          required: ["file", "project"]
+        }
+      },
+      {
+        name: "get_context_bundle",
+        description: "Get bundled context for a query: project context + knowledge + code in one call. Reduces multi-tool chaining. Respects token budget.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Natural language query or task description" },
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "Optional: task slug to include task-specific context" },
+            max_tokens: { type: "number", description: "Max tokens for response (default: 4000)" },
+            include: {
+              type: "object",
+              description: "What to include in the bundle",
+              properties: {
+                project_context: { type: "boolean", description: "Include project context (default: true)" },
+                knowledge: { type: "boolean", description: "Include knowledge search results (default: true)" },
+                code: { type: "boolean", description: "Include code search results (default: true)" },
+                related_files: { type: "boolean", description: "Include related files (default: false)" }
+              }
+            }
+          },
+          required: ["query", "project"]
+        }
+      },
+      {
+        name: "prefetch_task_context",
+        description: "Pre-gather all context for a task: task meta, referenced files, knowledge matches, code matches. Single call for task-aware context.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The task slug" },
+            max_tokens: { type: "number", description: "Max tokens for response (default: 6000)" }
+          },
+          required: ["project", "task_slug"]
+        }
+      },
+      {
+        name: "search_tasks",
+        description: "Search across all tasks by keyword, status, agent phase, or date. Returns matching tasks sorted by relevance.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            keyword: { type: "string", description: "Search in title/summary" },
+            status: { type: "string", description: "Filter by status (draft, in_progress, complete, etc.)" },
+            agent: { type: "string", description: "Filter by agent phase (research, planning, executor, documentation)" },
+            since: { type: "string", description: "ISO date - tasks updated after this date" },
+            limit: { type: "number", description: "Max results (default: 20)" }
+          },
+          required: ["project"]
+        }
+      },
+      {
+        name: "validate_phase",
+        description: "Check if a task phase has all prerequisites complete. Returns validation result with missing items and suggestions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The task slug" },
+            phase: { type: "string", enum: ["research", "planning", "execution", "documentation"], description: "Phase to validate" }
+          },
+          required: ["project", "task_slug", "phase"]
+        }
+      },
       {
         name: "index_knowledge",
         description: "Update the semantic search index for a specific project",
@@ -3614,7 +4484,61 @@ function registerToolHandlers(server) {
             project: { type: "string", description: "Name of the project" },
             task_slug: { type: "string", description: "The slug of the task to delete" }
           },
-          required: ["project", "task_slug"]
+          required: ["project", "task_slug"]
+        }
+      },
+      {
+        name: "start_session",
+        description: "Start an agent session for active task tracking. Call this when beginning work on a task phase.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task" },
+            agent: { type: "string", description: "Agent type: research, planning, executor, or documentation" },
+            phase: { type: "string", description: 'Current phase description (e.g., "clarification", "task breakdown")' }
+          },
+          required: ["project", "task_slug", "agent", "phase"]
+        }
+      },
+      {
+        name: "end_session",
+        description: "End an agent session. Call this before emitting completion signal.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task" }
+          },
+          required: ["project", "task_slug"]
+        }
+      },
+      {
+        name: "update_agent_todos",
+        description: "Update the agent todo list for a task. Use this to track granular work items during a phase.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task" },
+            phase: { type: "string", description: "Current phase" },
+            agent: { type: "string", description: "Agent type" },
+            items: {
+              type: "array",
+              description: "Todo items array",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "string" },
+                  content: { type: "string" },
+                  status: { type: "string", enum: ["pending", "in_progress", "completed"] },
+                  priority: { type: "string", enum: ["high", "medium", "low"] }
+                },
+                required: ["id", "content", "status", "priority"]
+              }
+            }
+          },
+          required: ["project", "task_slug", "phase", "agent", "items"]
         }
       }
     ];
@@ -3640,13 +4564,19 @@ function registerToolHandlers(server) {
         }
         case "search_knowledge": {
           const params = args;
-          const results = await searchKnowledge(params.query, params.project);
-          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+          const result = await searchKnowledge(params.query, params.project, {
+            max_tokens: params.max_tokens,
+            min_score: params.min_score
+          });
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
         }
         case "search_code": {
           const params = args;
-          const results = await searchCode(params.query, params.project, params.limit);
-          if (results.length === 0) {
+          const result = await searchCode(params.query, params.project, params.limit, {
+            max_tokens: params.max_tokens,
+            min_score: params.min_score
+          });
+          if (result.results.length === 0) {
             return {
               content: [{
                 type: "text",
@@ -3654,7 +4584,7 @@ function registerToolHandlers(server) {
               }]
             };
           }
-          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
         }
         case "find_related_files": {
           const params = args;
@@ -3665,6 +4595,35 @@ function registerToolHandlers(server) {
           });
           return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
         }
+        case "search_symbols": {
+          const params = args;
+          const result = await searchSymbols2(params.name, params.project, {
+            type: params.type,
+            fuzzy: params.fuzzy,
+            limit: params.limit
+          });
+          if (!result.success) {
+            return { content: [{ type: "text", text: result.message || "Search failed" }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        case "get_file_summary": {
+          const params = args;
+          const result = await getFileSummary(params.file, params.project);
+          if (!result.success) {
+            return { content: [{ type: "text", text: result.message || "Failed to get file summary" }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(result.summary, null, 2) }] };
+        }
+        case "get_context_bundle": {
+          const params = args;
+          const result = await getContextBundle(params.query, params.project, {
+            task_slug: params.task_slug,
+            max_tokens: params.max_tokens,
+            include: params.include
+          });
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
         case "index_knowledge": {
           const params = args;
           const result = await indexKnowledge(params.project, params.force);
@@ -3756,6 +4715,47 @@ ${JSON.stringify(task, null, 2)}` }] };
           const success = deleteTask(params.project, params.task_slug);
           return { content: [{ type: "text", text: success ? `\u2713 Task '${params.task_slug}' deleted.` : `\u2717 Failed to delete '${params.task_slug}'.` }] };
         }
+        case "start_session": {
+          const params = args;
+          const result = startSession(params.project, params.task_slug, params.agent, params.phase);
+          return { content: [{ type: "text", text: result.message }], isError: !result.success };
+        }
+        case "end_session": {
+          const params = args;
+          const result = endSession(params.project, params.task_slug);
+          return { content: [{ type: "text", text: result.message }], isError: !result.success };
+        }
+        case "update_agent_todos": {
+          const params = args;
+          const result = updateAgentTodos(params.project, params.task_slug, params.phase, params.agent, params.items);
+          return { content: [{ type: "text", text: result.message }], isError: !result.success };
+        }
+        case "prefetch_task_context": {
+          const params = args;
+          const result = await prefetchTaskContext(params.project, params.task_slug, {
+            max_tokens: params.max_tokens
+          });
+          if (!result.success) {
+            return { content: [{ type: "text", text: result.message || "Failed to prefetch task context" }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        case "search_tasks": {
+          const params = args;
+          const results = searchTasks(params.project, {
+            keyword: params.keyword,
+            status: params.status,
+            agent: params.agent,
+            since: params.since,
+            limit: params.limit
+          });
+          return { content: [{ type: "text", text: JSON.stringify({ count: results.length, tasks: results }, null, 2) }] };
+        }
+        case "validate_phase": {
+          const params = args;
+          const result = validatePhase(params.project, params.task_slug, params.phase);
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
         case "help_setup": {
           const msg = `
 RRCE MCP Server is running, but no projects are configured/exposed.
@@ -4008,8 +5008,8 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs26 = await import("fs");
-  const path25 = await import("path");
+  const fs27 = await import("fs");
+  const path26 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -4023,8 +5023,8 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs26.existsSync(resolvedPath)) {
-      fs26.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs27.existsSync(resolvedPath)) {
+      fs27.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
@@ -4032,7 +5032,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:
-${path25.join(resolvedPath, "mcp.yaml")}`,
+${path26.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -4312,6 +5312,37 @@ var init_ConfigContext = __esm({
 // src/mcp/ui/lib/tasks-fs.ts
 import * as fs19 from "fs";
 import * as path21 from "path";
+function readSession(project, taskSlug) {
+  const rrceData = getProjectRRCEData(project);
+  const sessionPath = path21.join(rrceData, "tasks", taskSlug, "session.json");
+  if (!fs19.existsSync(sessionPath)) {
+    return null;
+  }
+  try {
+    const raw = fs19.readFileSync(sessionPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isSessionStale(session, thresholdMs = SESSION_STALE_THRESHOLD_MS) {
+  const heartbeatTime = Date.parse(session.heartbeat);
+  if (isNaN(heartbeatTime)) return true;
+  return Date.now() - heartbeatTime > thresholdMs;
+}
+function readAgentTodos(project, taskSlug) {
+  const rrceData = getProjectRRCEData(project);
+  const todosPath = path21.join(rrceData, "tasks", taskSlug, "agent-todos.json");
+  if (!fs19.existsSync(todosPath)) {
+    return null;
+  }
+  try {
+    const raw = fs19.readFileSync(todosPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 function detectStorageModeFromConfig(workspaceRoot) {
   const configPath = getConfigPath(workspaceRoot);
   try {
@@ -4387,10 +5418,104 @@ function updateTaskStatus(project, taskSlug, status) {
     return { ok: false, error: String(e) };
   }
 }
+var SESSION_STALE_THRESHOLD_MS;
 var init_tasks_fs = __esm({
   "src/mcp/ui/lib/tasks-fs.ts"() {
     "use strict";
     init_paths();
+    SESSION_STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/mcp/ui/ui-helpers.ts
+var getStatusIcon, getStatusColor, getChecklistProgress, getCheckbox, getProgressBar, getFolderIcon, getAgentStatusIcon, getPhaseIcon, getTreeBranch, formatRelativeTime, getTodoStatusIcon;
+var init_ui_helpers = __esm({
+  "src/mcp/ui/ui-helpers.ts"() {
+    "use strict";
+    getStatusIcon = (status) => {
+      const icons = {
+        pending: "\u23F3",
+        in_progress: "\u{1F504}",
+        blocked: "\u{1F6AB}",
+        complete: "\u2705"
+      };
+      return icons[status] || "\u25CB";
+    };
+    getStatusColor = (status) => {
+      const colors = {
+        pending: "yellow",
+        in_progress: "yellow",
+        blocked: "red",
+        complete: "green"
+      };
+      return colors[status] || "white";
+    };
+    getChecklistProgress = (checklist) => {
+      if (!checklist || checklist.length === 0) {
+        return { completed: 0, total: 0, percentage: 0 };
+      }
+      const completed = checklist.filter((item) => item.status === "done").length;
+      return {
+        completed,
+        total: checklist.length,
+        percentage: Math.round(completed / checklist.length * 100)
+      };
+    };
+    getCheckbox = (status) => {
+      return status === "done" ? "\u2611" : "\u2610";
+    };
+    getProgressBar = (percentage, length = 10) => {
+      const filled = Math.floor(percentage / 100 * length);
+      const empty = length - filled;
+      return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+    };
+    getFolderIcon = (isOpen) => {
+      return isOpen ? "\u{1F4C2}" : "\u{1F4C1}";
+    };
+    getAgentStatusIcon = (status) => {
+      const icons = {
+        complete: "\u2713",
+        in_progress: "\u27F3",
+        pending: "\u25CB",
+        blocked: "\u2715"
+      };
+      return icons[status] || "\u2014";
+    };
+    getPhaseIcon = (agent) => {
+      const icons = {
+        research: "\u{1F52C}",
+        planning: "\u{1F4DD}",
+        executor: "\u26A1",
+        documentation: "\u{1F4DA}"
+      };
+      return icons[agent] || "\u{1F527}";
+    };
+    getTreeBranch = (isLast) => {
+      return isLast ? "\u2514\u2500" : "\u251C\u2500";
+    };
+    formatRelativeTime = (dateString) => {
+      if (!dateString) return "\u2014";
+      const date = Date.parse(dateString);
+      if (isNaN(date)) return "\u2014";
+      const now = Date.now();
+      const diffMs = now - date;
+      const diffMins = Math.floor(diffMs / (1e3 * 60));
+      const diffHours = Math.floor(diffMs / (1e3 * 60 * 60));
+      const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+      if (diffMins < 1) return "just now";
+      if (diffMins < 60) return `${diffMins}m ago`;
+      if (diffHours < 24) return `${diffHours}h ago`;
+      if (diffDays < 7) return `${diffDays}d ago`;
+      return `${Math.floor(diffDays / 7)}w ago`;
+    };
+    getTodoStatusIcon = (status) => {
+      const icons = {
+        completed: "\u2713",
+        in_progress: "\u27F3",
+        pending: "\u25CB"
+      };
+      return icons[status] || "\u25CB";
+    };
   }
 });
 
@@ -4405,6 +5530,7 @@ var init_Overview = __esm({
     init_Header();
     init_ConfigContext();
     init_tasks_fs();
+    init_ui_helpers();
     Overview = ({ serverStatus, stats, logs }) => {
       const { projects } = useConfig();
       const activeTasks = useMemo2(() => {
@@ -4413,7 +5539,16 @@ var init_Overview = __esm({
           const { tasks } = listProjectTasks(p);
           const inProgress = tasks.filter((t) => t.status === "in_progress");
           for (const t of inProgress) {
-            active.push({ project: p.name, title: t.title || t.task_slug, slug: t.task_slug });
+            const session = readSession(p, t.task_slug);
+            const todos = readAgentTodos(p, t.task_slug);
+            active.push({
+              project: p.name,
+              title: t.title || t.task_slug,
+              slug: t.task_slug,
+              session,
+              todos,
+              isStale: session ? isSessionStale(session) : false
+            });
           }
         }
         return active;
@@ -4421,6 +5556,15 @@ var init_Overview = __esm({
       const recentLogs = useMemo2(() => {
         return logs.slice(-5).reverse();
       }, [logs]);
+      const getElapsedTime = (startedAt) => {
+        const start = Date.parse(startedAt);
+        if (isNaN(start)) return "";
+        const elapsed = Date.now() - start;
+        const mins = Math.floor(elapsed / 6e4);
+        if (mins < 60) return `${mins}m`;
+        const hours = Math.floor(mins / 60);
+        return `${hours}h ${mins % 60}m`;
+      };
       return /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", flexGrow: 1, children: [
         /* @__PURE__ */ jsx3(Header, {}),
         /* @__PURE__ */ jsxs(Box2, { borderStyle: "round", paddingX: 1, borderColor: "white", flexDirection: "column", flexGrow: 1, children: [
@@ -4477,13 +5621,35 @@ var init_Overview = __esm({
           ] }),
           /* @__PURE__ */ jsxs(Box2, { marginTop: 1, borderStyle: "single", borderColor: "blue", flexDirection: "column", paddingX: 1, children: [
             /* @__PURE__ */ jsx3(Text2, { bold: true, color: "blue", children: "\u{1F3C3} Active Tasks" }),
-            activeTasks.length === 0 ? /* @__PURE__ */ jsx3(Box2, { paddingY: 1, children: /* @__PURE__ */ jsx3(Text2, { color: "dim", children: "No tasks currently in progress." }) }) : activeTasks.slice(0, 3).map((t, i) => /* @__PURE__ */ jsxs(Box2, { marginTop: i === 0 ? 0 : 0, children: [
-              /* @__PURE__ */ jsxs(Text2, { color: "yellow", children: [
-                "\u{1F504} ",
-                t.project,
-                ": "
+            activeTasks.length === 0 ? /* @__PURE__ */ jsx3(Box2, { paddingY: 1, children: /* @__PURE__ */ jsx3(Text2, { color: "dim", children: "No tasks currently in progress." }) }) : activeTasks.slice(0, 3).map((t, i) => /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", marginTop: i === 0 ? 0 : 1, children: [
+              /* @__PURE__ */ jsxs(Box2, { children: [
+                /* @__PURE__ */ jsx3(Text2, { color: "yellow", children: "\u{1F504} " }),
+                /* @__PURE__ */ jsx3(Text2, { bold: true, color: "white", children: t.project }),
+                /* @__PURE__ */ jsx3(Text2, { color: "dim", children: ": " }),
+                /* @__PURE__ */ jsx3(Text2, { color: "white", children: t.title })
+              ] }),
+              t.session && /* @__PURE__ */ jsxs(Box2, { marginLeft: 3, children: [
+                /* @__PURE__ */ jsxs(Text2, { children: [
+                  getPhaseIcon(t.session.agent),
+                  " "
+                ] }),
+                /* @__PURE__ */ jsx3(Text2, { color: t.isStale ? "dim" : "cyan", children: t.session.agent }),
+                /* @__PURE__ */ jsx3(Text2, { color: "dim", children: " \u2022 " }),
+                /* @__PURE__ */ jsx3(Text2, { color: t.isStale ? "dim" : "white", children: t.session.phase }),
+                /* @__PURE__ */ jsx3(Text2, { color: "dim", children: " \u2022 " }),
+                /* @__PURE__ */ jsx3(Text2, { color: t.isStale ? "red" : "green", children: t.isStale ? "stale" : `${getElapsedTime(t.session.started_at)} elapsed` })
               ] }),
-              /* @__PURE__ */ jsx3(Text2, { children: t.title })
+              t.todos && t.todos.items.length > 0 && /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", marginLeft: 3, children: t.todos.items.slice(0, 3).map((item, idx) => /* @__PURE__ */ jsxs(Box2, { children: [
+                /* @__PURE__ */ jsxs(Text2, { color: "dim", children: [
+                  getTreeBranch(idx === Math.min(2, t.todos.items.length - 1)),
+                  " "
+                ] }),
+                /* @__PURE__ */ jsx3(Text2, { color: item.status === "completed" ? "green" : item.status === "in_progress" ? "yellow" : "dim", children: getTodoStatusIcon(item.status) }),
+                /* @__PURE__ */ jsxs(Text2, { color: item.status === "completed" ? "dim" : "white", children: [
+                  " ",
+                  item.content.length > 40 ? item.content.substring(0, 37) + "..." : item.content
+                ] })
+              ] }, item.id)) })
             ] }, `${t.project}-${t.slug}`)),
             activeTasks.length > 3 && /* @__PURE__ */ jsxs(Text2, { color: "dim", children: [
               "   ...and ",
@@ -4497,7 +5663,7 @@ var init_Overview = __esm({
           ] }),
           /* @__PURE__ */ jsxs(Box2, { marginTop: 0, justifyContent: "space-between", children: [
             /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(Text2, { color: "dim", children: "r:Restart q:Quit 1-4/\u25C4 \u25BA:Tabs" }) }),
-            /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(Text2, { color: "dim", children: "RRCE MCP Hub v0.3.7" }) })
+            /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsx3(Text2, { color: "dim", children: "RRCE MCP Hub v0.3.14" }) })
           ] })
         ] })
       ] });
@@ -4607,7 +5773,37 @@ var init_project_utils = __esm({
 // src/mcp/ui/ProjectsView.tsx
 import { useEffect as useEffect3, useMemo as useMemo3, useState as useState3 } from "react";
 import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import * as fs20 from "fs";
+import * as path22 from "path";
 import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function getIndexStats(project) {
+  const stats = { knowledgeCount: 0, codeCount: 0, lastIndexed: null };
+  try {
+    const knowledgePath = project.knowledgePath;
+    if (knowledgePath) {
+      const embPath = path22.join(knowledgePath, "embeddings.json");
+      const codeEmbPath = path22.join(knowledgePath, "code-embeddings.json");
+      if (fs20.existsSync(embPath)) {
+        const stat = fs20.statSync(embPath);
+        stats.lastIndexed = stat.mtime.toISOString();
+        try {
+          const data = JSON.parse(fs20.readFileSync(embPath, "utf-8"));
+          stats.knowledgeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
+        } catch {
+        }
+      }
+      if (fs20.existsSync(codeEmbPath)) {
+        try {
+          const data = JSON.parse(fs20.readFileSync(codeEmbPath, "utf-8"));
+          stats.codeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return stats;
+}
 var ProjectsView;
 var init_ProjectsView = __esm({
   "src/mcp/ui/ProjectsView.tsx"() {
@@ -4618,6 +5814,7 @@ var init_ProjectsView = __esm({
     init_indexing_jobs();
     init_config_utils();
     init_project_utils();
+    init_ui_helpers();
     ProjectsView = ({ config: initialConfig, projects: allProjects, onConfigChange, workspacePath }) => {
       const { driftReports, checkAllDrift } = useConfig();
       const [config, setConfig] = useState3(initialConfig);
@@ -4664,29 +5861,41 @@ var init_ProjectsView = __esm({
           const isExposed = projectConfig ? projectConfig.expose : config.defaults.includeNew;
           const drift = driftReports[p.path];
           const idx = indexingStats[p.name];
+          const stats = getIndexStats(p);
+          const isCurrentProject = p.path === workspacePath;
           let label = formatProjectLabel(p);
+          if (isCurrentProject) {
+            label += " (current)";
+          }
           if (drift?.hasDrift) {
-            label += ` \u26A0`;
+            label += " \u26A0";
           }
+          let statsRow = "";
           if (idx?.state === "running") {
-            label += `
-\u27F3 Indexing ${idx.itemsDone}/${idx.itemsTotal ?? "?"}`;
+            statsRow = `   \u27F3 Indexing... ${idx.itemsDone}/${idx.itemsTotal ?? "?"}`;
           } else if (idx?.state === "failed") {
-            label += `
-\u2715 Index Fail`;
-          } else if (idx?.enabled && idx?.state === "complete") {
-            label += `
-\u2713 Indexed`;
+            statsRow = "   \u2715 Index failed";
+          } else if (stats.knowledgeCount > 0 || stats.codeCount > 0) {
+            const parts = [];
+            if (stats.knowledgeCount > 0) parts.push(`\u{1F4DA} ${stats.knowledgeCount} docs`);
+            if (stats.codeCount > 0) parts.push(`\u{1F4BB} ${stats.codeCount} files`);
+            if (stats.lastIndexed) parts.push(`\u{1F550} ${formatRelativeTime(stats.lastIndexed)}`);
+            statsRow = `   \u{1F4CA} ${parts.join(" \u2502 ")}`;
+          } else if (isExposed) {
+            statsRow = "   \u{1F4CA} Not indexed";
           }
+          const fullLabel = statsRow ? `${label}
+${statsRow}` : label;
           return {
-            label,
+            label: fullLabel,
             value: p.path,
             key: p.path,
             exposed: isExposed,
-            indexing: idx
+            indexing: idx,
+            isCurrentProject
           };
         });
-      }, [sortedProjects, config, driftReports, indexingStats]);
+      }, [sortedProjects, config, driftReports, indexingStats, workspacePath]);
       const initialSelected = useMemo3(() => {
         return projectItems.filter((p) => p.exposed).map((p) => p.value);
       }, [projectItems]);
@@ -4745,87 +5954,103 @@ var init_ProjectsView = __esm({
   }
 });
 
-// src/mcp/ui/ui-helpers.ts
-var getStatusIcon, getStatusColor, getChecklistProgress, getCheckbox, getProgressBar, getFolderIcon;
-var init_ui_helpers = __esm({
-  "src/mcp/ui/ui-helpers.ts"() {
-    "use strict";
-    getStatusIcon = (status) => {
-      const icons = {
-        pending: "\u23F3",
-        in_progress: "\u{1F504}",
-        blocked: "\u{1F6AB}",
-        complete: "\u2705"
-      };
-      return icons[status] || "\u25CB";
-    };
-    getStatusColor = (status) => {
-      const colors = {
-        pending: "yellow",
-        in_progress: "yellow",
-        blocked: "red",
-        complete: "green"
-      };
-      return colors[status] || "white";
-    };
-    getChecklistProgress = (checklist) => {
-      if (!checklist || checklist.length === 0) {
-        return { completed: 0, total: 0, percentage: 0 };
-      }
-      const completed = checklist.filter((item) => item.status === "done").length;
-      return {
-        completed,
-        total: checklist.length,
-        percentage: Math.round(completed / checklist.length * 100)
-      };
-    };
-    getCheckbox = (status) => {
-      return status === "done" ? "\u2611" : "\u2610";
-    };
-    getProgressBar = (percentage, length = 10) => {
-      const filled = Math.floor(percentage / 100 * length);
-      const empty = length - filled;
-      return "\u2588".repeat(filled) + "\u2591".repeat(empty);
-    };
-    getFolderIcon = (isOpen) => {
-      return isOpen ? "\u{1F4C2}" : "\u{1F4C1}";
-    };
-  }
-});
-
 // src/mcp/ui/components/TaskRow.tsx
 import "react";
 import { Box as Box5, Text as Text5 } from "ink";
 import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function getActiveAgent(task) {
+  if (!task.agents) return null;
+  for (const [agent, info] of Object.entries(task.agents)) {
+    if (info?.status === "in_progress") {
+      return { agent, status: "in_progress" };
+    }
+  }
+  const agentOrder = ["documentation", "executor", "planning", "research"];
+  for (const agent of agentOrder) {
+    if (task.agents[agent]?.status === "complete") {
+      return { agent, status: "complete" };
+    }
+  }
+  return null;
+}
 var TaskRow;
 var init_TaskRow = __esm({
   "src/mcp/ui/components/TaskRow.tsx"() {
     "use strict";
     init_ui_helpers();
     init_project_utils();
-    TaskRow = ({ row, isSelected, isExpanded, taskCount, hasDrift }) => {
+    TaskRow = ({
+      row,
+      isSelected,
+      isExpanded,
+      taskCount,
+      hasDrift,
+      isCurrentProject = false,
+      isLastTask = false
+    }) => {
       if (row.kind === "project") {
-        return /* @__PURE__ */ jsx6(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsxs4(Box5, { children: [
-          /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "white", children: isSelected ? "> " : "  " }),
-          /* @__PURE__ */ jsxs4(Text5, { color: isSelected ? "cyan" : "white", children: [
+        const projectColor = isCurrentProject ? "cyan" : isSelected ? "yellow" : "white";
+        const isBold = isCurrentProject || isSelected;
+        return /* @__PURE__ */ jsxs4(Box5, { children: [
+          /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8 " : "  " }),
+          /* @__PURE__ */ jsxs4(Text5, { bold: isBold, color: projectColor, children: [
             getFolderIcon(isExpanded),
             " ",
             formatProjectLabel(row.project)
           ] }),
+          isCurrentProject && /* @__PURE__ */ jsx6(Text5, { color: "cyan", dimColor: true, children: " (current)" }),
           hasDrift && /* @__PURE__ */ jsx6(Text5, { color: "magenta", children: " \u26A0" }),
           /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
             " ",
-            taskCount > 0 ? `(${taskCount})` : ""
+            taskCount > 0 ? `[${taskCount}]` : ""
           ] })
-        ] }) });
+        ] });
+      }
+      const task = row.task;
+      const taskLabel = task.title || task.task_slug;
+      const status = task.status || "";
+      const isPlaceholder = task.task_slug === "__none__";
+      const branch = getTreeBranch(isLastTask);
+      const activeAgent = getActiveAgent(task);
+      const progress = getChecklistProgress(task.checklist || []);
+      const relativeTime = task.updated_at ? formatRelativeTime(task.updated_at) : "";
+      if (isPlaceholder) {
+        return /* @__PURE__ */ jsxs4(Box5, { children: [
+          /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
+            "     ",
+            branch,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx6(Text5, { color: "dim", italic: true, children: taskLabel })
+        ] });
       }
-      const taskLabel = row.task.title || row.task.task_slug;
-      const status = row.task.status || "";
       return /* @__PURE__ */ jsxs4(Box5, { children: [
-        /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "white", children: isSelected ? "> " : "  " }),
-        /* @__PURE__ */ jsx6(Text5, { color: "dim", children: "    - " }),
-        /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "white", children: taskLabel }),
-        row.task.task_slug !== "__none__" && /* @__PURE__ */ jsx6(Text5, { backgroundColor: getStatusColor(status), color: "black", children: ` ${getStatusIcon(status)} ${status.toUpperCase().replace("_", " ")} ` })
+        /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "dim", children: isSelected ? "\u25B8" : " " }),
+        /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
+          "   ",
+          branch,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx6(Text5, { color: isSelected ? "cyan" : "white", children: "\u{1F4CB} " }),
+        /* @__PURE__ */ jsx6(Text5, { bold: isSelected, color: isSelected ? "cyan" : "white", children: taskLabel.length > 25 ? taskLabel.substring(0, 22) + "..." : taskLabel }),
+        activeAgent && /* @__PURE__ */ jsxs4(Text5, { children: [
+          /* @__PURE__ */ jsx6(Text5, { color: "dim", children: " " }),
+          /* @__PURE__ */ jsx6(Text5, { children: getPhaseIcon(activeAgent.agent) }),
+          /* @__PURE__ */ jsx6(Text5, { color: activeAgent.status === "in_progress" ? "yellow" : "green", children: getAgentStatusIcon(activeAgent.status) })
+        ] }),
+        progress.total > 0 && /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
+          " ",
+          getProgressBar(progress.percentage, 6),
+          " ",
+          progress.completed,
+          "/",
+          progress.total
+        ] }),
+        relativeTime && relativeTime !== "\u2014" && /* @__PURE__ */ jsxs4(Text5, { color: "dim", children: [
+          " ",
+          relativeTime
+        ] }),
+        !activeAgent && status && /* @__PURE__ */ jsx6(Text5, { backgroundColor: getStatusColor(status), color: "black", children: ` ${getStatusIcon(status)} ` })
       ] });
     };
   }
@@ -4834,102 +6059,124 @@ var init_TaskRow = __esm({
 // src/mcp/ui/components/TaskDetails.tsx
 import "react";
 import { Box as Box6, Text as Text6 } from "ink";
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 var TaskDetails;
 var init_TaskDetails = __esm({
   "src/mcp/ui/components/TaskDetails.tsx"() {
     "use strict";
     init_ui_helpers();
-    TaskDetails = ({ task }) => {
+    TaskDetails = ({ task, agentTodos }) => {
       if (!task) {
         return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", justifyContent: "center", alignItems: "center", gap: 1, flexGrow: 1, children: [
           /* @__PURE__ */ jsx7(Text6, { bold: true, color: "dim", children: "\u2500 No Task Selected \u2500" }),
-          /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Use \u2191/\u2193 to navigate, Enter to expand projects" }),
-          /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Press 's' to cycle task status" })
+          /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Use \u2191/\u2193 to navigate" }),
+          /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Enter to expand projects" }),
+          /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "'s' to cycle task status" })
         ] });
       }
+      const progress = getChecklistProgress(task.checklist || []);
       return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
         /* @__PURE__ */ jsxs5(Box6, { marginBottom: 1, flexDirection: "column", children: [
           /* @__PURE__ */ jsx7(Text6, { bold: true, color: "cyan", children: task.title || task.task_slug }),
-          task.summary && /* @__PURE__ */ jsx7(Text6, { color: "white", children: task.summary })
+          task.summary && /* @__PURE__ */ jsx7(Text6, { color: "white", wrap: "wrap", children: task.summary.length > 100 ? task.summary.substring(0, 97) + "..." : task.summary })
         ] }),
-        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
-        /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, paddingX: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
+        /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
           /* @__PURE__ */ jsx7(Text6, { bold: true, color: "white", children: "\u{1F4CB} STATUS" }),
-          /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginTop: 1, children: [
-            /* @__PURE__ */ jsxs5(Text6, { children: [
-              /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Status: " }),
-              " ",
+          /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginTop: 0, marginLeft: 1, children: [
+            /* @__PURE__ */ jsxs5(Box6, { children: [
+              /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Status:  " }),
               /* @__PURE__ */ jsx7(Text6, { color: getStatusColor(task.status || ""), children: task.status || "unknown" })
             ] }),
-            /* @__PURE__ */ jsxs5(Text6, { children: [
-              /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Updated:" }),
-              " ",
-              /* @__PURE__ */ jsx7(Text6, { children: task.updated_at || "\u2014" })
+            /* @__PURE__ */ jsxs5(Box6, { children: [
+              /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Updated: " }),
+              /* @__PURE__ */ jsx7(Text6, { children: formatRelativeTime(task.updated_at || "") })
             ] }),
-            /* @__PURE__ */ jsxs5(Text6, { children: [
-              /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Tags:   " }),
-              " ",
-              " ",
-              (() => {
-                const tags = task.tags || [];
-                return tags.length > 0 ? tags.map((tag, i) => /* @__PURE__ */ jsxs5(Text6, { children: [
-                  /* @__PURE__ */ jsx7(Text6, { color: "cyan", children: tag }),
-                  i < tags.length - 1 && /* @__PURE__ */ jsx7(Text6, { color: "dim", children: ", " })
-                ] }, tag)) : /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "\u2014" });
-              })()
+            task.tags && task.tags.length > 0 && /* @__PURE__ */ jsxs5(Box6, { children: [
+              /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "Tags:    " }),
+              task.tags.map((tag, i) => /* @__PURE__ */ jsxs5(Text6, { children: [
+                /* @__PURE__ */ jsx7(Text6, { color: "cyan", children: tag }),
+                i < task.tags.length - 1 && /* @__PURE__ */ jsx7(Text6, { color: "dim", children: ", " })
+              ] }, tag))
             ] })
           ] })
         ] }),
-        /* @__PURE__ */ jsx7(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }) }),
-        /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, paddingX: 1, flexDirection: "column", children: [
-          /* @__PURE__ */ jsx7(Text6, { bold: true, color: "white", children: "\u{1F4CB} CHECKLIST" }),
-          task.checklist && task.checklist.length > 0 && /* @__PURE__ */ jsx7(Box6, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsxs5(Box6, { marginBottom: 1, children: [
-            /* @__PURE__ */ jsx7(Text6, { backgroundColor: "white", children: getProgressBar(getChecklistProgress(task.checklist).percentage) }),
-            /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
-              " ",
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
+        /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs5(Box6, { children: [
+            /* @__PURE__ */ jsx7(Text6, { bold: true, color: "white", children: "\u{1F4CB} CHECKLIST " }),
+            progress.total > 0 && /* @__PURE__ */ jsxs5(Text6, { color: "dim", children: [
+              getProgressBar(progress.percentage, 8),
               " ",
-              getChecklistProgress(task.checklist).completed,
+              progress.completed,
               "/",
-              getChecklistProgress(task.checklist).total,
-              " (",
-              getChecklistProgress(task.checklist).percentage,
-              "%)"
+              progress.total
             ] })
-          ] }) }),
-          (task.checklist || []).length === 0 ? /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "\u2014" }) : (task.checklist || []).slice(0, 12).map((c, i) => {
-            const isDone = c.status === "done";
-            return /* @__PURE__ */ jsxs5(Text6, { color: isDone ? "dim" : "white", children: [
-              /* @__PURE__ */ jsxs5(Text6, { color: isDone ? "green" : "dim", children: [
-                getCheckbox(c.status || "pending"),
-                " "
-              ] }),
-              c.label || c.id || "item"
-            ] }, c.id || i);
-          })
+          ] }),
+          /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginLeft: 1, children: [
+            (task.checklist || []).length === 0 ? /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "No checklist items" }) : (task.checklist || []).slice(0, 8).map((c, i) => {
+              const isDone = c.status === "done";
+              return /* @__PURE__ */ jsxs5(Text6, { color: isDone ? "dim" : "white", children: [
+                /* @__PURE__ */ jsxs5(Text6, { color: isDone ? "green" : "dim", children: [
+                  getCheckbox(c.status || "pending"),
+                  " "
+                ] }),
+                (c.label || c.id || "item").substring(0, 35)
+              ] }, c.id || i);
+            }),
+            (task.checklist || []).length > 8 && /* @__PURE__ */ jsxs5(Text6, { color: "dim", children: [
+              "...and ",
+              (task.checklist || []).length - 8,
+              " more"
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
+        agentTodos && agentTodos.items.length > 0 && /* @__PURE__ */ jsxs5(Fragment, { children: [
+          /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs5(Box6, { children: [
+              /* @__PURE__ */ jsx7(Text6, { bold: true, color: "white", children: "\u{1F3AF} AGENT TODOS " }),
+              /* @__PURE__ */ jsxs5(Text6, { color: "dim", children: [
+                "(",
+                agentTodos.agent,
+                " \u2022 ",
+                agentTodos.phase,
+                ")"
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginLeft: 1, children: [
+              agentTodos.items.slice(0, 5).map((item, i) => /* @__PURE__ */ jsxs5(Text6, { children: [
+                /* @__PURE__ */ jsxs5(Text6, { color: item.status === "completed" ? "green" : item.status === "in_progress" ? "yellow" : "dim", children: [
+                  getTodoStatusIcon(item.status),
+                  " "
+                ] }),
+                /* @__PURE__ */ jsx7(Text6, { color: item.status === "completed" ? "dim" : "white", children: item.content.substring(0, 35) })
+              ] }, item.id || i)),
+              agentTodos.items.length > 5 && /* @__PURE__ */ jsxs5(Text6, { color: "dim", children: [
+                "...and ",
+                agentTodos.items.length - 5,
+                " more"
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" })
         ] }),
-        /* @__PURE__ */ jsx7(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text6, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }) }),
-        /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, paddingX: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
           /* @__PURE__ */ jsx7(Text6, { bold: true, color: "white", children: "\u{1F916} AGENTS" }),
-          /* @__PURE__ */ jsx7(Box6, { marginTop: 1, flexDirection: "column", children: !task.agents ? /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "\u2014" }) : Object.entries(task.agents).map(([agent, info]) => /* @__PURE__ */ jsxs5(Text6, { children: [
+          /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", marginLeft: 1, children: !task.agents || Object.keys(task.agents).length === 0 ? /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "No agent activity yet" }) : Object.entries(task.agents).map(([agent, info]) => /* @__PURE__ */ jsxs5(Box6, { children: [
+            /* @__PURE__ */ jsxs5(Text6, { children: [
+              getPhaseIcon(agent),
+              " "
+            ] }),
             /* @__PURE__ */ jsxs5(Text6, { color: "dim", children: [
-              "- ",
               agent,
               ": "
             ] }),
-            info?.status === "complete" && /* @__PURE__ */ jsx7(Text6, { color: "green", children: "\u2713" }),
-            info?.status === "in_progress" && /* @__PURE__ */ jsx7(Text6, { color: "yellow", children: "\u27F3" }),
-            info?.status === "pending" && /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "\u25CB" }),
-            info?.blocked && /* @__PURE__ */ jsx7(Text6, { color: "red", children: "\u2715" }),
-            /* @__PURE__ */ jsxs5(Text6, { color: info?.status === "complete" ? "dim" : "white", children: [
-              " ",
-              info?.status || "\u2014"
-            ] }),
-            info?.artifact && /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
-              " (",
-              info.artifact,
-              ")"
-            ] })
+            info?.status === "complete" && /* @__PURE__ */ jsx7(Text6, { color: "green", children: "\u2713 " }),
+            info?.status === "in_progress" && /* @__PURE__ */ jsx7(Text6, { color: "yellow", children: "\u27F3 " }),
+            info?.status === "pending" && /* @__PURE__ */ jsx7(Text6, { color: "dim", children: "\u25CB " }),
+            info?.blocked && /* @__PURE__ */ jsx7(Text6, { color: "red", children: "\u2715 " }),
+            /* @__PURE__ */ jsx7(Text6, { color: info?.status === "complete" ? "dim" : "white", children: info?.status || "pending" })
           ] }, agent)) })
         ] })
       ] });
@@ -4993,19 +6240,30 @@ var init_TasksView = __esm({
       const flattenedRows = useMemo4(() => {
         const rows = [];
         for (const p of sortedProjects) {
-          rows.push({ kind: "project", project: p });
+          const isCurrentProject = p.path === workspacePath;
+          rows.push({ kind: "project", project: p, isCurrentProject });
           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: "" } });
+          tasks.forEach((t, idx) => {
+            rows.push({
+              kind: "task",
+              project: p,
+              task: t,
+              isLastTask: idx === tasks.length - 1
+            });
+          });
+          if (tasks.length === 0) {
+            rows.push({
+              kind: "task",
+              project: p,
+              task: { task_slug: "__none__", title: "(no tasks)", status: "" },
+              isLastTask: true
+            });
           }
         }
         return rows;
-      }, [sortedProjects, expanded, taskCache]);
+      }, [sortedProjects, expanded, taskCache, workspacePath]);
       useInput3((input, key) => {
         if (input === "R") {
           setErrorLine(null);
@@ -5037,7 +6295,7 @@ var init_TasksView = __esm({
         }
         if (input === "s") {
           const row = flattenedRows[selectedIndex];
-          if (row?.kind === "task") {
+          if (row?.kind === "task" && row.task.task_slug !== "__none__") {
             setErrorLine(null);
             const desired = nextStatus(row.task.status);
             const result = updateTaskStatus(row.project, row.task.task_slug, desired);
@@ -5063,43 +6321,55 @@ var init_TasksView = __esm({
       }, [flattenedRows]);
       const selectedRow = flattenedRows[selectedIndex];
       const selectedTask = selectedRow?.kind === "task" && selectedRow.task.task_slug !== "__none__" ? selectedRow.task : null;
-      return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
-        /* @__PURE__ */ jsxs6(Box7, { justifyContent: "space-between", children: [
+      const totalTasks = Object.values(taskCache).flat().length;
+      return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "white", flexGrow: 1, children: [
+        /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, justifyContent: "space-between", borderBottom: true, children: [
           /* @__PURE__ */ jsxs6(Box7, { children: [
             /* @__PURE__ */ jsx8(Text7, { bold: true, color: "cyan", children: "\u2699 Tasks" }),
-            /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: " \u2022 " }),
+            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: " \u2502 " }),
             /* @__PURE__ */ jsxs6(Text7, { children: [
               sortedProjects.length,
               " projects"
             ] }),
-            /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: " \u2022 " }),
+            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: " \u2022 " }),
             /* @__PURE__ */ jsxs6(Text7, { children: [
-              Object.values(taskCache).flat().length,
+              totalTasks,
               " tasks"
             ] })
           ] }),
-          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "\u2191/\u2193:Nav Enter:Expand s:Status R:Refresh" })
+          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "\u2191\u2193:Nav  Enter:Expand  s:Status  R:Refresh" })
         ] }),
-        errorLine && /* @__PURE__ */ jsx8(Box7, { marginTop: 0, children: /* @__PURE__ */ jsx8(Text7, { color: "red", children: errorLine }) }),
-        /* @__PURE__ */ jsxs6(Box7, { marginTop: 1, flexDirection: "row", flexGrow: 1, children: [
-          /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", width: "55%", children: [
-            flattenedRows.length === 0 ? /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "No projects detected." }) : flattenedRows.map((row, idx) => {
-              const k = projectKey(row.project);
-              return /* @__PURE__ */ jsx8(
-                TaskRow,
-                {
-                  row,
-                  isSelected: idx === selectedIndex,
-                  isExpanded: expanded.has(k),
-                  taskCount: (taskCache[k] || []).length,
-                  hasDrift: !!driftReports[row.project.path]?.hasDrift
-                },
-                row.kind === "project" ? `p:${k}` : `t:${k}:${row.task.task_slug}`
-              );
-            }),
-            /* @__PURE__ */ jsx8(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text7, { color: "gray", children: "\u25B2/\u25BC navigate \u2022 Enter expand/collapse \u2022 s cycle status \u2022 R refresh" }) })
-          ] }),
-          /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", width: "45%", paddingLeft: 2, children: /* @__PURE__ */ jsx8(TaskDetails, { task: selectedTask }) })
+        errorLine && /* @__PURE__ */ jsx8(Box7, { paddingX: 1, children: /* @__PURE__ */ jsxs6(Text7, { color: "red", children: [
+          "\u26A0 ",
+          errorLine
+        ] }) }),
+        /* @__PURE__ */ jsxs6(Box7, { flexDirection: "row", flexGrow: 1, paddingX: 1, paddingY: 1, children: [
+          /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", width: "55%", borderStyle: "single", borderColor: "dim", borderRight: true, paddingRight: 1, children: flattenedRows.length === 0 ? /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
+            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "No projects detected." }),
+            /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "Run the wizard to set up projects." })
+          ] }) : /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", children: flattenedRows.map((row, idx) => {
+            const k = projectKey(row.project);
+            const isCurrentProject = row.kind === "project" ? row.isCurrentProject : false;
+            const isLastTask = row.kind === "task" ? row.isLastTask : false;
+            return /* @__PURE__ */ jsx8(
+              TaskRow,
+              {
+                row,
+                isSelected: idx === selectedIndex,
+                isExpanded: expanded.has(k),
+                taskCount: (taskCache[k] || []).length,
+                hasDrift: !!driftReports[row.project.path]?.hasDrift,
+                isCurrentProject,
+                isLastTask
+              },
+              row.kind === "project" ? `p:${k}` : `t:${k}:${row.task.task_slug}`
+            );
+          }) }) }),
+          /* @__PURE__ */ jsx8(Box7, { flexDirection: "column", width: "45%", paddingLeft: 1, children: /* @__PURE__ */ jsx8(TaskDetails, { task: selectedTask }) })
+        ] }),
+        /* @__PURE__ */ jsxs6(Box7, { paddingX: 1, justifyContent: "space-between", borderTop: true, children: [
+          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "s:Cycle Status  R:Refresh  ?:Help" }),
+          /* @__PURE__ */ jsx8(Text7, { color: "dim", children: "RRCE MCP Hub v0.3.14" })
         ] })
       ] });
     };
@@ -5227,7 +6497,7 @@ __export(App_exports, {
 });
 import { useState as useState5, useEffect as useEffect6, useMemo as useMemo5, useCallback as useCallback3 } from "react";
 import { Box as Box11, useInput as useInput5, useApp } from "ink";
-import fs20 from "fs";
+import fs21 from "fs";
 import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 var App;
 var init_App = __esm({
@@ -5300,18 +6570,18 @@ var init_App = __esm({
       useEffect6(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs20.existsSync(logPath)) {
-          const stats = fs20.statSync(logPath);
+        if (fs21.existsSync(logPath)) {
+          const stats = fs21.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs20.existsSync(logPath)) {
-            const stats = fs20.statSync(logPath);
+          if (fs21.existsSync(logPath)) {
+            const stats = fs21.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs20.openSync(logPath, "r");
-              fs20.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs20.closeSync(fd);
+              const fd = fs21.openSync(logPath, "r");
+              fs21.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs21.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -5536,15 +6806,15 @@ __export(update_flow_exports, {
 });
 import { confirm as confirm5, spinner as spinner2, note as note6, outro as outro2, cancel as cancel2, isCancel as isCancel7 } from "@clack/prompts";
 import pc8 from "picocolors";
-import * as fs21 from "fs";
-import * as path22 from "path";
+import * as fs22 from "fs";
+import * as path23 from "path";
 import { stringify as stringify2, parse } from "yaml";
 function backupFile(filePath) {
-  if (!fs21.existsSync(filePath)) return null;
+  if (!fs22.existsSync(filePath)) return null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
   const backupPath = `${filePath}.${timestamp}.bak`;
   try {
-    fs21.copyFileSync(filePath, backupPath);
+    fs22.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (e) {
     console.error(`Failed to backup ${filePath}:`, e);
@@ -5554,9 +6824,9 @@ function backupFile(filePath) {
 function getPackageVersion2() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path22.join(path22.dirname(agentCoreDir), "package.json");
-    if (fs21.existsSync(packageJsonPath)) {
-      return JSON.parse(fs21.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path23.join(path23.dirname(agentCoreDir), "package.json");
+    if (fs22.existsSync(packageJsonPath)) {
+      return JSON.parse(fs22.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -5571,9 +6841,9 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
   const configFilePath = getConfigPath(workspacePath);
   let currentSyncedVersion;
-  if (fs21.existsSync(configFilePath)) {
+  if (fs22.existsSync(configFilePath)) {
     try {
-      const content = fs21.readFileSync(configFilePath, "utf-8");
+      const content = fs22.readFileSync(configFilePath, "utf-8");
       const config = parse(content);
       currentSyncedVersion = config.last_synced_version;
     } catch (e) {
@@ -5581,8 +6851,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   }
   const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
   const ideTargets = [];
-  if (fs21.existsSync(configFilePath)) {
-    const configContent = fs21.readFileSync(configFilePath, "utf-8");
+  if (fs22.existsSync(configFilePath)) {
+    const configContent = fs22.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");
@@ -5591,14 +6861,14 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     const dirs = ["templates", "prompts", "docs"];
     const updatedFiles = [];
     for (const dir of dirs) {
-      const srcDir = path22.join(agentCoreDir, dir);
-      if (!fs21.existsSync(srcDir)) continue;
+      const srcDir = path23.join(agentCoreDir, dir);
+      if (!fs22.existsSync(srcDir)) continue;
       const syncFiles = (src, rel) => {
-        const entries = fs21.readdirSync(src, { withFileTypes: true });
+        const entries = fs22.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const entrySrc = path22.join(src, entry.name);
-          const entryRel = path22.join(rel, entry.name);
-          const entryDest = path22.join(dataPath, entryRel);
+          const entrySrc = path23.join(src, entry.name);
+          const entryRel = path23.join(rel, entry.name);
+          const entryDest = path23.join(dataPath, entryRel);
           if (entry.isDirectory()) {
             ensureDir(entryDest);
             syncFiles(entrySrc, entryRel);
@@ -5606,7 +6876,7 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
             if (driftReport.modifiedFiles.includes(entryRel)) {
               backupFile(entryDest);
             }
-            fs21.copyFileSync(entrySrc, entryDest);
+            fs22.copyFileSync(entrySrc, entryDest);
             updatedFiles.push(entryRel);
           }
         }
@@ -5617,12 +6887,12 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     DriftService.saveManifest(dataPath, manifest);
   }
   const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-  ensureDir(path22.join(rrceHome, "templates"));
-  ensureDir(path22.join(rrceHome, "docs"));
-  copyDirRecursive(path22.join(agentCoreDir, "templates"), path22.join(rrceHome, "templates"));
-  copyDirRecursive(path22.join(agentCoreDir, "docs"), path22.join(rrceHome, "docs"));
-  if (fs21.existsSync(configFilePath)) {
-    const configContent = fs21.readFileSync(configFilePath, "utf-8");
+  ensureDir(path23.join(rrceHome, "templates"));
+  ensureDir(path23.join(rrceHome, "docs"));
+  copyDirRecursive(path23.join(agentCoreDir, "templates"), path23.join(rrceHome, "templates"));
+  copyDirRecursive(path23.join(agentCoreDir, "docs"), path23.join(rrceHome, "docs"));
+  if (fs22.existsSync(configFilePath)) {
+    const configContent = fs22.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -5644,21 +6914,21 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     try {
       const yaml = parse(configContent);
       yaml.last_synced_version = runningVersion;
-      fs21.writeFileSync(configFilePath, stringify2(yaml));
+      fs22.writeFileSync(configFilePath, stringify2(yaml));
     } catch (e) {
       console.error("Failed to update config.yaml version:", e);
     }
   }
-  const mcpPath = path22.join(rrceHome, "mcp.yaml");
-  if (fs21.existsSync(mcpPath)) {
+  const mcpPath = path23.join(rrceHome, "mcp.yaml");
+  if (fs22.existsSync(mcpPath)) {
     try {
-      const content = fs21.readFileSync(mcpPath, "utf-8");
+      const content = fs22.readFileSync(mcpPath, "utf-8");
       const yaml = parse(content);
       if (yaml.projects) {
         const project = yaml.projects.find((p) => p.name === workspaceName);
         if (project) {
           project.last_synced_version = runningVersion;
-          fs21.writeFileSync(mcpPath, stringify2(yaml));
+          fs22.writeFileSync(mcpPath, stringify2(yaml));
         }
       }
     } catch (e) {
@@ -5694,9 +6964,9 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     const configFilePath = getConfigPath(workspacePath);
     let currentSyncedVersion;
-    if (fs21.existsSync(configFilePath)) {
+    if (fs22.existsSync(configFilePath)) {
       try {
-        const content = fs21.readFileSync(configFilePath, "utf-8");
+        const content = fs22.readFileSync(configFilePath, "utf-8");
         const config = parse(content);
         currentSyncedVersion = config.last_synced_version;
       } catch (e) {
@@ -5720,8 +6990,8 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
       `  \u2022 docs/ (documentation)`
     ];
     const ideTargets = [];
-    if (fs21.existsSync(configFilePath)) {
-      const configContent = fs21.readFileSync(configFilePath, "utf-8");
+    if (fs22.existsSync(configFilePath)) {
+      const configContent = fs22.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");
@@ -5750,14 +7020,14 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       const dirs = ["templates", "prompts", "docs"];
       const updatedFiles = [];
       for (const dir of dirs) {
-        const srcDir = path22.join(agentCoreDir, dir);
-        if (!fs21.existsSync(srcDir)) continue;
+        const srcDir = path23.join(agentCoreDir, dir);
+        if (!fs22.existsSync(srcDir)) continue;
         const syncFiles = (src, rel) => {
-          const entries = fs21.readdirSync(src, { withFileTypes: true });
+          const entries = fs22.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
-            const entrySrc = path22.join(src, entry.name);
-            const entryRel = path22.join(rel, entry.name);
-            const entryDest = path22.join(dataPath, entryRel);
+            const entrySrc = path23.join(src, entry.name);
+            const entryRel = path23.join(rel, entry.name);
+            const entryDest = path23.join(dataPath, entryRel);
             if (entry.isDirectory()) {
               ensureDir(entryDest);
               syncFiles(entrySrc, entryRel);
@@ -5765,7 +7035,7 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
               if (driftReport.modifiedFiles.includes(entryRel)) {
                 backupFile(entryDest);
               }
-              fs21.copyFileSync(entrySrc, entryDest);
+              fs22.copyFileSync(entrySrc, entryDest);
               updatedFiles.push(entryRel);
             }
           }
@@ -5776,12 +7046,12 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       DriftService.saveManifest(dataPath, manifest);
     }
     const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-    ensureDir(path22.join(rrceHome, "templates"));
-    ensureDir(path22.join(rrceHome, "docs"));
-    copyDirRecursive(path22.join(agentCoreDir, "templates"), path22.join(rrceHome, "templates"));
-    copyDirRecursive(path22.join(agentCoreDir, "docs"), path22.join(rrceHome, "docs"));
-    if (fs21.existsSync(configFilePath)) {
-      const configContent = fs21.readFileSync(configFilePath, "utf-8");
+    ensureDir(path23.join(rrceHome, "templates"));
+    ensureDir(path23.join(rrceHome, "docs"));
+    copyDirRecursive(path23.join(agentCoreDir, "templates"), path23.join(rrceHome, "templates"));
+    copyDirRecursive(path23.join(agentCoreDir, "docs"), path23.join(rrceHome, "docs"));
+    if (fs22.existsSync(configFilePath)) {
+      const configContent = fs22.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
@@ -5803,21 +7073,21 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       try {
         const yaml = parse(configContent);
         yaml.last_synced_version = runningVersion;
-        fs21.writeFileSync(configFilePath, stringify2(yaml));
+        fs22.writeFileSync(configFilePath, stringify2(yaml));
       } catch (e) {
         console.error("Failed to update config.yaml version:", e);
       }
     }
-    const mcpPath = path22.join(rrceHome, "mcp.yaml");
-    if (fs21.existsSync(mcpPath)) {
+    const mcpPath = path23.join(rrceHome, "mcp.yaml");
+    if (fs22.existsSync(mcpPath)) {
       try {
-        const content = fs21.readFileSync(mcpPath, "utf-8");
+        const content = fs22.readFileSync(mcpPath, "utf-8");
         const yaml = parse(content);
         if (yaml.projects) {
           const project = yaml.projects.find((p) => p.name === workspaceName);
           if (project) {
             project.last_synced_version = runningVersion;
-            fs21.writeFileSync(mcpPath, stringify2(yaml));
+            fs22.writeFileSync(mcpPath, stringify2(yaml));
           }
         }
       } catch (e) {
@@ -5852,8 +7122,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path22.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path22.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path23.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path23.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -5876,8 +7146,8 @@ var init_update_flow = __esm({
 // src/commands/wizard/index.ts
 import { intro as intro2, select as select5, spinner as spinner7, note as note11, outro as outro7, isCancel as isCancel12, confirm as confirm10 } from "@clack/prompts";
 import pc13 from "picocolors";
-import * as fs25 from "fs";
-import * as path24 from "path";
+import * as fs26 from "fs";
+import * as path25 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/lib/git.ts
@@ -6554,7 +7824,7 @@ async function handlePostSetup(config, workspacePath, workspaceName, linkedProje
 init_paths();
 import { multiselect as multiselect4, spinner as spinner4, note as note8, outro as outro4, cancel as cancel4, isCancel as isCancel9, confirm as confirm7 } from "@clack/prompts";
 import pc10 from "picocolors";
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 init_detection();
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
@@ -6593,7 +7863,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs22.readFileSync(configFilePath, "utf-8");
+  let configContent = fs23.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -6620,7 +7890,7 @@ linked_projects:
 `;
     });
   }
-  fs22.writeFileSync(configFilePath, configContent);
+  fs23.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -6656,15 +7926,15 @@ init_paths();
 init_utils();
 import { confirm as confirm8, spinner as spinner5, note as note9, outro as outro5, cancel as cancel5, isCancel as isCancel10 } from "@clack/prompts";
 import pc11 from "picocolors";
-import * as fs23 from "fs";
-import * as path23 from "path";
+import * as fs24 from "fs";
+import * as path24 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path23.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path24.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs23.existsSync(path23.join(localPath, dir))
+    (dir) => fs24.existsSync(path24.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro5(pc11.yellow("No data found in workspace storage to sync."));
@@ -6690,8 +7960,8 @@ Destination: ${pc11.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path23.join(localPath, dir);
-      const destDir = path23.join(globalPath, dir);
+      const srcDir = path24.join(localPath, dir);
+      const destDir = path24.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -6719,7 +7989,7 @@ init_update_flow();
 // src/commands/wizard/delete-flow.ts
 import { multiselect as multiselect5, confirm as confirm9, spinner as spinner6, note as note10, cancel as cancel6, isCancel as isCancel11 } from "@clack/prompts";
 import pc12 from "picocolors";
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 init_detection();
 init_config();
 async function runDeleteGlobalProjectFlow(availableProjects) {
@@ -6763,8 +8033,8 @@ Are you sure?`,
     for (const projectName of projectsToDelete) {
       const project = globalProjects.find((p) => p.name === projectName);
       if (!project) continue;
-      if (fs24.existsSync(project.dataPath)) {
-        fs24.rmSync(project.dataPath, { recursive: true, force: true });
+      if (fs25.existsSync(project.dataPath)) {
+        fs25.rmSync(project.dataPath, { recursive: true, force: true });
       }
       const newConfig = removeProjectConfig(mcpConfig, projectName);
       configChanged = true;
@@ -6786,9 +8056,9 @@ init_config();
 function getPackageVersion3() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path24.join(path24.dirname(agentCoreDir), "package.json");
-    if (fs25.existsSync(packageJsonPath)) {
-      return JSON.parse(fs25.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path25.join(path25.dirname(agentCoreDir), "package.json");
+    if (fs26.existsSync(packageJsonPath)) {
+      return JSON.parse(fs26.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -6796,9 +8066,9 @@ function getPackageVersion3() {
 }
 function getLastSyncedVersion(workspacePath, workspaceName) {
   const configFilePath = getConfigPath(workspacePath);
-  if (fs25.existsSync(configFilePath)) {
+  if (fs26.existsSync(configFilePath)) {
     try {
-      const content = fs25.readFileSync(configFilePath, "utf-8");
+      const content = fs26.readFileSync(configFilePath, "utf-8");
       const config = parse2(content);
       if (config.last_synced_version) {
         return config.last_synced_version;
@@ -6807,10 +8077,10 @@ function getLastSyncedVersion(workspacePath, workspaceName) {
     }
   }
   const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
-  const mcpPath = path24.join(rrceHome, "mcp.yaml");
-  if (fs25.existsSync(mcpPath)) {
+  const mcpPath = path25.join(rrceHome, "mcp.yaml");
+  if (fs26.existsSync(mcpPath)) {
     try {
-      const content = fs25.readFileSync(mcpPath, "utf-8");
+      const content = fs26.readFileSync(mcpPath, "utf-8");
       const config = parse2(content);
       const project = config.projects?.find((p) => p.name === workspaceName);
       if (project?.last_synced_version) {
@@ -6880,11 +8150,11 @@ Workspace: ${pc13.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  let isAlreadyConfigured = fs25.existsSync(configFilePath);
+  let isAlreadyConfigured = fs26.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs25.readFileSync(configFilePath, "utf-8");
+      const configContent = fs26.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
@@ -6901,7 +8171,7 @@ Workspace: ${pc13.bold(workspaceName)}`,
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs25.existsSync(localDataPath);
+  const hasLocalData = fs26.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const continueToMenu = await checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode);
     if (!continueToMenu) {