rrce-workflow 0.3.28 → 0.3.30

package/agent-core/prompts/cleanup.md

@@ -0,0 +1,199 @@
+---
+name: RRCE Cleanup
+description: Extract valuable knowledge from tasks and delete artifacts
+argument-hint: "TASK_SLUG=<slug> [TASK_SLUG_2=<slug>] [--all]"
+tools: ['rrce_get_task', 'rrce_search_knowledge', 'rrce_search_code', 'rrce_delete_task', 'rrce_index_knowledge', 'rrce_list_tasks', 'read', 'write']
+required-args: []
+optional-args:
+  - name: TASK_SLUG
+    prompt: "Enter task slug(s) to cleanup (comma-separated or leave blank for --all)"
+  - name: ALL
+    default: "false"
+auto-identity:
+  user: "$GIT_USER"
+  model: "$AGENT_MODEL"
+---
+
+You are the Knowledge Cleanup Agent. Extract valuable insights from tasks and safely delete artifacts.
+
+## Pipeline Position
+- **Maintenance Agent**: Runs on user-demand only (no automatic scheduling)
+- **Scope**: Single task, multiple tasks, or --all mode for project
+- **Write Scope**: Writes to `{{RRCE_DATA}}/knowledge/` and deletes from `{{RRCE_DATA}}/tasks/`
+
+## Mission
+Extract durable knowledge from task artifacts, deduplicate against existing knowledge base, merge or create appropriate knowledge files, then delete task directories.
+
+## Prerequisites
+- Task must exist (get `{{TASK_SLUG}}` or use `rrce_list_tasks` to discover)
+- Knowledge base should exist (`{{RRCE_DATA}}/knowledge/`)
+
+## Workflow
+
+### Step 1: Determine Cleanup Scope
+Check `{{TASK_SLUG}}` and `{{ALL}}`:
+- `{{ALL}} == "true"`: Cleanup all tasks for project
+- Single value: Cleanup specific task
+- Multiple comma-separated values: Bulk cleanup (max 10 per batch)
+
+Get task list using `rrce_list_tasks(project: "{{WORKSPACE_NAME}}")`
+
+### Step 2: For Each Task
+
+**2A. Read Task Artifacts**
+- `meta.json` - Status, title, summary, tags
+- `research/*.md` - Requirements, alternatives, best practices
+- `planning/*.md` - Task breakdown, chosen approach, implementation notes
+- `execution/*.md` - Changes made, lessons learned, bugs discovered
+- `docs/*.md` - Final documentation (if present)
+
+**2B. Extract Knowledge by Status**
+
+**Complete tasks**: Full extraction
+- Research findings and technical decisions
+- Implementation patterns and lessons learned
+- Test results and edge cases
+- Integration notes
+
+**In-progress tasks**: Partial extraction
+- Research completed
+- Planning decisions made
+- Implementation progress
+- Blockers discovered
+
+**Cancelled tasks**: Learning extraction
+- Why cancelled (scope, blockers, priorities)
+- What was learned (research, prototypes)
+- Avoidable pitfalls
+
+**Draft tasks**: Initial research
+- Requirements gathered
+- Alternatives considered
+- Initial findings
+
+**2C. Check for Duplicates**
+Use `rrce_search_knowledge` to detect overlapping content:
+- Query with key findings from task
+- Similarity threshold: 0.85+
+- If high match found, note which sections already exist
+
+**2D. Decide: Merge vs Create New File**
+
+**Criteria for Merging into Existing Files**:
+- Domain-specific files exist (e.g., `authentication-oauth-2026-01-05.md`)
+- Content directly extends existing knowledge
+- File is under 400 lines (headroom for merge)
+- High similarity found (>0.85) in RAG search
+
+**Criteria for Creating New Files**:
+- No existing domain file or generic target
+- New technical domain not covered in knowledge base
+- Existing files would exceed 500 lines after merge
+- Content is significantly different from existing
+
+**File Naming Convention**:
+- Format: `{domain}-{YYYY-MM-DD}.md`
+- Domain: Extracted from task content (e.g., "authentication", "ui-components", "api-design")
+- Date: Current cleanup date
+- Example: `authentication-oauth-2026-01-05.md`
+
+**Merge Targets** (priority order):
+1. Domain-specific file (if match found)
+2. `project-context.md` - general project insights
+3. `architecture.md` - architectural decisions
+4. `mcp-server.md` - MCP tool/agent changes
+5. Create new domain file
+
+**2E. Write Knowledge File**
+
+If merging:
+- Read existing file
+- Preserve structure and formatting
+- Add new section with insights
+- Update "Updated: YYYY-MM-DD" timestamp
+- Keep file under 500 lines (split if needed)
+
+If creating new:
+- Use template structure:
+```markdown
+# [Domain] Insights
+
+Updated: YYYY-MM-DD
+
+## Summary
+[Brief overview]
+
+## Key Findings
+- [Finding 1]
+- [Finding 2]
+
+## Related Files
+- Code path or task artifact
+
+## Checklist
+- [ ] Follow-up item 1
+```
+
+### Step 3: Delete Task
+After successful knowledge extraction:
+- Call `rrce_delete_task(project: "{{WORKSPACE_NAME}}", task_slug: "<slug>")`
+- If deletion fails, log error but keep knowledge for manual review
+
+### Step 4: Reindex Knowledge
+After all tasks processed:
+- Call `rrce_index_knowledge(project: "{{WORKSPACE_NAME}}")`
+- Report indexing results
+
+## Non-Negotiables
+
+1. **Extract insights, not artifacts** - Don't copy entire research/planning files verbatim. Summarize durable insights.
+2. **Check duplicates before writing** - Use `rrce_search_knowledge` to avoid redundancy.
+3. **Keep files lean** - Target <500 lines per file. Split if needed.
+4. **Version updates** - Add `Updated: YYYY-MM-DD` to modified sections.
+5. **Handle deletion failures gracefully** - Log errors, keep knowledge for manual review.
+6. **Batch limit** - Max 10 tasks per bulk cleanup. Show progress: "Cleaning up task X of Y..."
+
+## Error Handling
+
+- Task not found: "Task '{slug}' does not exist. Skipping."
+- No artifacts to extract: Log and proceed to deletion.
+- Knowledge file write fails: "Failed to write knowledge file: {error}. Task not deleted."
+- Delete task fails: "Task deletion failed: {error}. Knowledge preserved for manual review."
+- RAG search fails: Proceed with extraction (may have duplicates).
+
+## Progress Reporting
+
+For bulk cleanup:
+```
+Cleaning up 3 tasks:
+  ✓ task-auth-login (knowledge extracted, deleted)
+  ✓ task-api-refactor (knowledge extracted, deleted)
+  ⚠ task-ui-refresh (knowledge extracted, delete failed - see logs)
+```
+
+## Deliverable
+
+- **Knowledge files**: Updated or created in `{{RRCE_DATA}}/knowledge/`
+- **Task directories**: Deleted (or error logged)
+- **Reindex**: `rrce_index_knowledge` executed
+- **Summary**: Tasks cleaned, files created/merged, any failures
+
+## Example Flow
+
+```
+1. rrce_list_tasks(project) → [task-a, task-b, task-c]
+2. For task-a:
+   - Read artifacts
+   - Extract insights (status: complete)
+   - rrce_search_knowledge("authentication") → Found existing file
+   - Merge into authentication-oauth-2025-12-15.md
+   - rrce_delete_task(project, "task-a") → Success
+3. For task-b:
+   - Read artifacts
+   - Extract insights (status: cancelled)
+   - rrce_search_knowledge("payment flow") → No match
+   - Create payment-flow-2026-01-05.md
+   - rrce_delete_task(project, "task-b") → Success
+4. rrce_index_knowledge(project) → Index updated
+5. Report: "Cleaned up 2 tasks. Updated 1 file, created 1 file."
+```

package/agent-core/prompts/design.md

@@ -333,7 +333,14 @@ After saving plan:
 - If **"y"**: Invoke development using task tool (see below)
 - If **"n"**: Provide completion summary, end session
 
-### 2.8 Development Handoff
+### 2.8 Development Handoff (CRITICAL)
+
+**NEVER call the task tool unless:**
+1. You have completed both research AND planning phases
+2. You have asked "Should I run `/rrce_develop {{TASK_SLUG}}`?"
+3. **The user has explicitly responded with "y"**
+
+The initial `/rrce_design` command invocation is NOT confirmation to proceed. It only starts the design session.
 
 Wait for user to respond with "y" to the prompt above. Only after receiving explicit user confirmation, then use the `task` tool to delegate:
 

package/agent-core/prompts/orchestrator.md

@@ -136,6 +136,7 @@ Use `rrce_search_tasks` to find relevant tasks:
 | `/rrce_design` | task-slug "request" | Research + plan in single session |
 | `/rrce_develop` | task-slug | Execute code changes |
 | `/rrce_docs` | doc-type [task-slug] | Generate documentation |
+| `/rrce_cleanup` | task-slug [--all] | Extract knowledge and delete tasks |
 | `/rrce_sync` | [scope] | Sync knowledge base |
 | `/rrce_doctor` | [focus-area] | Health check |
 

package/dist/index.js

@@ -5178,6 +5178,149 @@ var init_agent = __esm({
   }
 });
 
+// src/mcp/handlers/tools/cleanup.ts
+import * as path28 from "path";
+import * as fs25 from "fs";
+async function cleanupSingleTask(projectName, taskSlug, projectDataPath) {
+  try {
+    const task = getTask(projectName, taskSlug);
+    if (!task) {
+      return { success: false, message: `Task '${taskSlug}' not found in project '${projectName}'.` };
+    }
+    const taskDir = path28.join(projectDataPath, "tasks", taskSlug);
+    const artifacts = { meta: task };
+    const researchPath = path28.join(taskDir, "research", `${taskSlug}-research.md`);
+    if (fs25.existsSync(researchPath)) {
+      artifacts.research = fs25.readFileSync(researchPath, "utf-8");
+    }
+    const planningPath = path28.join(taskDir, "planning", `${taskSlug}-plan.md`);
+    if (fs25.existsSync(planningPath)) {
+      artifacts.planning = fs25.readFileSync(planningPath, "utf-8");
+    }
+    const executionPath = path28.join(taskDir, "execution", `${taskSlug}-execution.md`);
+    if (fs25.existsSync(executionPath)) {
+      artifacts.execution = fs25.readFileSync(executionPath, "utf-8");
+    }
+    const docsPath = path28.join(taskDir, "docs", `${taskSlug}-docs.md`);
+    if (fs25.existsSync(docsPath)) {
+      artifacts.docs = fs25.readFileSync(docsPath, "utf-8");
+    }
+    return {
+      success: true,
+      message: `Task '${taskSlug}' artifacts loaded. ${Object.keys(artifacts).length - 1} artifact files found.`,
+      knowledgeFiles: []
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to load task '${taskSlug}': ${error.message}`
+    };
+  }
+}
+function getProjectDataPath(projectName) {
+  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.dataPath) {
+    return null;
+  }
+  return project.dataPath;
+}
+async function handleCleanupTool(name, args) {
+  if (!args) return null;
+  if (name === "cleanup_task") {
+    const params = args;
+    const projectDataPath = getProjectDataPath(params.project);
+    if (!projectDataPath) {
+      return {
+        content: [{ type: "text", text: `Project '${params.project}' not found or not exposed.` }],
+        isError: true
+      };
+    }
+    let taskSlugs = [];
+    if (params.cleanup_all) {
+      const allTasks = getProjectTasks(params.project);
+      taskSlugs = allTasks.map((t) => t.task_slug);
+    } else if (params.task_slugs && params.task_slugs.length > 0) {
+      taskSlugs = params.task_slugs;
+    } else if (params.task_slug) {
+      taskSlugs = [params.task_slug];
+    }
+    if (taskSlugs.length === 0) {
+      return {
+        content: [{ type: "text", text: "No tasks specified for cleanup. Provide task_slug, task_slugs array, or set cleanup_all=true." }],
+        isError: true
+      };
+    }
+    const MAX_BATCH_SIZE = 10;
+    if (taskSlugs.length > MAX_BATCH_SIZE) {
+      return {
+        content: [{ type: "text", text: `Too many tasks (${taskSlugs.length}). Maximum ${MAX_BATCH_SIZE} tasks per batch.` }],
+        isError: true
+      };
+    }
+    const results = await Promise.all(
+      taskSlugs.map((slug) => cleanupSingleTask(params.project, slug, projectDataPath))
+    );
+    const successCount = results.filter((r) => r.success).length;
+    const failureCount = results.filter((r) => !r.success).length;
+    let responseText = `Loaded ${successCount} task(s) for cleanup.`;
+    if (failureCount > 0) {
+      responseText += ` Failed to load ${failureCount} task(s):
+`;
+      results.filter((r) => !r.success).forEach((r) => {
+        responseText += `  - ${r.message}
+`;
+      });
+    }
+    responseText += `
+
+Task artifacts loaded. The cleanup agent will now:
+`;
+    responseText += `1. Extract knowledge from each task
+`;
+    responseText += `2. Check for duplicates in knowledge base
+`;
+    responseText += `3. Merge or create knowledge files
+`;
+    responseText += `4. Delete task directories
+`;
+    responseText += `5. Reindex knowledge
+
+`;
+    responseText += `Proceeding with cleanup...`;
+    return {
+      content: [{ type: "text", text: responseText }]
+    };
+  }
+  return null;
+}
+var cleanupTools;
+var init_cleanup = __esm({
+  "src/mcp/handlers/tools/cleanup.ts"() {
+    "use strict";
+    init_resources2();
+    init_config();
+    init_detection_service();
+    cleanupTools = [
+      {
+        name: "cleanup_task",
+        description: "Cleanup task(s) by extracting knowledge and deleting artifacts. Supports single task, multiple tasks, or --all mode.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "Single task slug to cleanup" },
+            task_slugs: { type: "array", items: { type: "string" }, description: "Multiple task slugs to cleanup" },
+            cleanup_all: { type: "boolean", description: "Cleanup all tasks for project" }
+          },
+          required: ["project"]
+        }
+      }
+    ];
+  }
+});
+
 // src/mcp/handlers/tools.ts
 import "@modelcontextprotocol/sdk/server/index.js";
 import {
@@ -5191,7 +5334,8 @@ function registerToolHandlers(server) {
       ...searchTools,
       ...taskTools,
       ...sessionTools,
-      ...agentTools
+      ...agentTools,
+      ...cleanupTools
     ];
     const projects = getExposedProjects();
     if (projects.length === 0) {
@@ -5217,6 +5361,8 @@ function registerToolHandlers(server) {
       if (sessionResult) return sessionResult;
       const agentResult = await handleAgentTool(name, args);
       if (agentResult) return agentResult;
+      const cleanupResult = await handleCleanupTool(name, args);
+      if (cleanupResult) return cleanupResult;
       throw new Error(`Unknown tool: ${name}`);
     } catch (error) {
       logger.error(`Tool execution failed: ${name}`, error);
@@ -5234,6 +5380,7 @@ var init_tools = __esm({
     init_task();
     init_session();
     init_agent();
+    init_cleanup();
   }
 });
 
@@ -5459,8 +5606,8 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs34 = await import("fs");
-  const path34 = await import("path");
+  const fs35 = await import("fs");
+  const path35 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -5474,8 +5621,8 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs34.existsSync(resolvedPath)) {
-      fs34.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs35.existsSync(resolvedPath)) {
+      fs35.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
@@ -5483,7 +5630,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:
-${path34.join(resolvedPath, "mcp.yaml")}`,
+${path35.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -5587,15 +5734,15 @@ __export(ConfigContext_exports, {
   useConfig: () => useConfig
 });
 import { createContext, useContext, useState, useCallback, useMemo, useEffect } from "react";
-import * as fs25 from "fs";
-import * as path28 from "path";
+import * as fs26 from "fs";
+import * as path29 from "path";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function getPackageVersion() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path28.join(path28.dirname(agentCoreDir), "package.json");
-    if (fs25.existsSync(packageJsonPath)) {
-      return JSON.parse(fs25.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path29.join(path29.dirname(agentCoreDir), "package.json");
+    if (fs26.existsSync(packageJsonPath)) {
+      return JSON.parse(fs26.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -5662,16 +5809,16 @@ var init_ConfigContext = __esm({
 });
 
 // src/mcp/ui/lib/tasks-fs.ts
-import * as fs26 from "fs";
-import * as path29 from "path";
+import * as fs27 from "fs";
+import * as path30 from "path";
 function readSession(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const sessionPath = path29.join(rrceData, "tasks", taskSlug, "session.json");
-  if (!fs26.existsSync(sessionPath)) {
+  const sessionPath = path30.join(rrceData, "tasks", taskSlug, "session.json");
+  if (!fs27.existsSync(sessionPath)) {
     return null;
   }
   try {
-    const raw = fs26.readFileSync(sessionPath, "utf-8");
+    const raw = fs27.readFileSync(sessionPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5684,12 +5831,12 @@ function isSessionStale(session, thresholdMs = SESSION_STALE_THRESHOLD_MS) {
 }
 function readAgentTodos(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const todosPath = path29.join(rrceData, "tasks", taskSlug, "agent-todos.json");
-  if (!fs26.existsSync(todosPath)) {
+  const todosPath = path30.join(rrceData, "tasks", taskSlug, "agent-todos.json");
+  if (!fs27.existsSync(todosPath)) {
     return null;
   }
   try {
-    const raw = fs26.readFileSync(todosPath, "utf-8");
+    const raw = fs27.readFileSync(todosPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5702,8 +5849,8 @@ function detectStorageModeFromConfig(workspaceRoot) {
     if (configPath.startsWith(rrceHome)) {
       return "global";
     }
-    if (fs26.existsSync(configPath)) {
-      const content = fs26.readFileSync(configPath, "utf-8");
+    if (fs27.existsSync(configPath)) {
+      const content = fs27.readFileSync(configPath, "utf-8");
       if (content.includes("mode: workspace")) return "workspace";
       if (content.includes("mode: global")) return "global";
     }
@@ -5713,7 +5860,7 @@ function detectStorageModeFromConfig(workspaceRoot) {
 }
 function getEffectiveGlobalBase() {
   const dummy = resolveDataPath("global", "__rrce_dummy__", "");
-  return path29.dirname(path29.dirname(dummy));
+  return path30.dirname(path30.dirname(dummy));
 }
 function getProjectRRCEData(project) {
   const workspaceRoot = project.sourcePath || project.path;
@@ -5722,19 +5869,19 @@ function getProjectRRCEData(project) {
 }
 function listProjectTasks(project) {
   const rrceData = getProjectRRCEData(project);
-  const tasksPath = path29.join(rrceData, "tasks");
-  if (!fs26.existsSync(tasksPath)) {
+  const tasksPath = path30.join(rrceData, "tasks");
+  if (!fs27.existsSync(tasksPath)) {
     return { projectName: project.name, tasksPath, tasks: [] };
   }
   const tasks = [];
   try {
-    const entries = fs26.readdirSync(tasksPath, { withFileTypes: true });
+    const entries = fs27.readdirSync(tasksPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const metaPath = path29.join(tasksPath, entry.name, "meta.json");
-      if (!fs26.existsSync(metaPath)) continue;
+      const metaPath = path30.join(tasksPath, entry.name, "meta.json");
+      if (!fs27.existsSync(metaPath)) continue;
       try {
-        const raw = fs26.readFileSync(metaPath, "utf-8");
+        const raw = fs27.readFileSync(metaPath, "utf-8");
         const meta = JSON.parse(raw);
         if (!meta.task_slug) meta.task_slug = entry.name;
         tasks.push(meta);
@@ -5753,18 +5900,18 @@ function listProjectTasks(project) {
 }
 function updateTaskStatus(project, taskSlug, status) {
   const rrceData = getProjectRRCEData(project);
-  const metaPath = path29.join(rrceData, "tasks", taskSlug, "meta.json");
-  if (!fs26.existsSync(metaPath)) {
+  const metaPath = path30.join(rrceData, "tasks", taskSlug, "meta.json");
+  if (!fs27.existsSync(metaPath)) {
     return { ok: false, error: `meta.json not found for task '${taskSlug}'` };
   }
   try {
-    const meta = JSON.parse(fs26.readFileSync(metaPath, "utf-8"));
+    const meta = JSON.parse(fs27.readFileSync(metaPath, "utf-8"));
     const next = {
       ...meta,
       status,
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs26.writeFileSync(metaPath, JSON.stringify(next, null, 2));
+    fs27.writeFileSync(metaPath, JSON.stringify(next, null, 2));
     return { ok: true, meta: next };
   } catch (e) {
     return { ok: false, error: String(e) };
@@ -6149,27 +6296,27 @@ var init_ProjectViews = __esm({
 });
 
 // src/mcp/ui/lib/projects.ts
-import * as fs27 from "fs";
-import * as path30 from "path";
+import * as fs28 from "fs";
+import * as path31 from "path";
 function getIndexStats(project) {
   const stats = { knowledgeCount: 0, codeCount: 0, lastIndexed: null };
   try {
     const knowledgePath = project.knowledgePath;
     if (knowledgePath) {
-      const embPath = path30.join(knowledgePath, "embeddings.json");
-      const codeEmbPath = path30.join(knowledgePath, "code-embeddings.json");
-      if (fs27.existsSync(embPath)) {
-        const stat = fs27.statSync(embPath);
+      const embPath = path31.join(knowledgePath, "embeddings.json");
+      const codeEmbPath = path31.join(knowledgePath, "code-embeddings.json");
+      if (fs28.existsSync(embPath)) {
+        const stat = fs28.statSync(embPath);
         stats.lastIndexed = stat.mtime.toISOString();
         try {
-          const data = JSON.parse(fs27.readFileSync(embPath, "utf-8"));
+          const data = JSON.parse(fs28.readFileSync(embPath, "utf-8"));
           stats.knowledgeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
       }
-      if (fs27.existsSync(codeEmbPath)) {
+      if (fs28.existsSync(codeEmbPath)) {
         try {
-          const data = JSON.parse(fs27.readFileSync(codeEmbPath, "utf-8"));
+          const data = JSON.parse(fs28.readFileSync(codeEmbPath, "utf-8"));
           stats.codeCount = Array.isArray(data) ? data.length : Object.keys(data).length;
         } catch {
         }
@@ -6914,7 +7061,7 @@ __export(App_exports, {
 });
 import { useState as useState5, useEffect as useEffect6, useMemo as useMemo5, useCallback as useCallback3 } from "react";
 import { Box as Box14, useInput as useInput5, useApp } from "ink";
-import fs28 from "fs";
+import fs29 from "fs";
 import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
 var App;
 var init_App = __esm({
@@ -6987,18 +7134,18 @@ var init_App = __esm({
       useEffect6(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs28.existsSync(logPath)) {
-          const stats = fs28.statSync(logPath);
+        if (fs29.existsSync(logPath)) {
+          const stats = fs29.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs28.existsSync(logPath)) {
-            const stats = fs28.statSync(logPath);
+          if (fs29.existsSync(logPath)) {
+            const stats = fs29.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs28.openSync(logPath, "r");
-              fs28.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs28.closeSync(fd);
+              const fd = fs29.openSync(logPath, "r");
+              fs29.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs29.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -7223,15 +7370,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 fs29 from "fs";
-import * as path31 from "path";
+import * as fs30 from "fs";
+import * as path32 from "path";
 import { stringify as stringify2, parse } from "yaml";
 function backupFile(filePath) {
-  if (!fs29.existsSync(filePath)) return null;
+  if (!fs30.existsSync(filePath)) return null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
   const backupPath = `${filePath}.${timestamp}.bak`;
   try {
-    fs29.copyFileSync(filePath, backupPath);
+    fs30.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (e) {
     console.error(`Failed to backup ${filePath}:`, e);
@@ -7241,9 +7388,9 @@ function backupFile(filePath) {
 function getPackageVersion2() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path31.join(path31.dirname(agentCoreDir), "package.json");
-    if (fs29.existsSync(packageJsonPath)) {
-      return JSON.parse(fs29.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path32.join(path32.dirname(agentCoreDir), "package.json");
+    if (fs30.existsSync(packageJsonPath)) {
+      return JSON.parse(fs30.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -7258,9 +7405,9 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
   const configFilePath = getConfigPath(workspacePath);
   let currentSyncedVersion;
-  if (fs29.existsSync(configFilePath)) {
+  if (fs30.existsSync(configFilePath)) {
     try {
-      const content = fs29.readFileSync(configFilePath, "utf-8");
+      const content = fs30.readFileSync(configFilePath, "utf-8");
       const config = parse(content);
       currentSyncedVersion = config.last_synced_version;
     } catch (e) {
@@ -7268,8 +7415,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
   }
   const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
   const ideTargets = [];
-  if (fs29.existsSync(configFilePath)) {
-    const configContent = fs29.readFileSync(configFilePath, "utf-8");
+  if (fs30.existsSync(configFilePath)) {
+    const configContent = fs30.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");
@@ -7278,14 +7425,14 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     const dirs = ["templates", "prompts", "docs"];
     const updatedFiles = [];
     for (const dir of dirs) {
-      const srcDir = path31.join(agentCoreDir, dir);
-      if (!fs29.existsSync(srcDir)) continue;
+      const srcDir = path32.join(agentCoreDir, dir);
+      if (!fs30.existsSync(srcDir)) continue;
       const syncFiles = (src, rel) => {
-        const entries = fs29.readdirSync(src, { withFileTypes: true });
+        const entries = fs30.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const entrySrc = path31.join(src, entry.name);
-          const entryRel = path31.join(rel, entry.name);
-          const entryDest = path31.join(dataPath, entryRel);
+          const entrySrc = path32.join(src, entry.name);
+          const entryRel = path32.join(rel, entry.name);
+          const entryDest = path32.join(dataPath, entryRel);
           if (entry.isDirectory()) {
             ensureDir(entryDest);
             syncFiles(entrySrc, entryRel);
@@ -7293,8 +7440,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
             if (driftReport.modifiedFiles.includes(entryRel)) {
               backupFile(entryDest);
             }
-            ensureDir(path31.dirname(entryDest));
-            fs29.copyFileSync(entrySrc, entryDest);
+            ensureDir(path32.dirname(entryDest));
+            fs30.copyFileSync(entrySrc, entryDest);
             updatedFiles.push(entryRel);
           }
         }
@@ -7305,12 +7452,12 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     DriftService.saveManifest(dataPath, manifest);
   }
   const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-  ensureDir(path31.join(rrceHome, "templates"));
-  ensureDir(path31.join(rrceHome, "docs"));
-  copyDirRecursive(path31.join(agentCoreDir, "templates"), path31.join(rrceHome, "templates"));
-  copyDirRecursive(path31.join(agentCoreDir, "docs"), path31.join(rrceHome, "docs"));
-  if (fs29.existsSync(configFilePath)) {
-    const configContent = fs29.readFileSync(configFilePath, "utf-8");
+  ensureDir(path32.join(rrceHome, "templates"));
+  ensureDir(path32.join(rrceHome, "docs"));
+  copyDirRecursive(path32.join(agentCoreDir, "templates"), path32.join(rrceHome, "templates"));
+  copyDirRecursive(path32.join(agentCoreDir, "docs"), path32.join(rrceHome, "docs"));
+  if (fs30.existsSync(configFilePath)) {
+    const configContent = fs30.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -7332,21 +7479,21 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     try {
       const yaml = parse(configContent);
       yaml.last_synced_version = runningVersion;
-      fs29.writeFileSync(configFilePath, stringify2(yaml));
+      fs30.writeFileSync(configFilePath, stringify2(yaml));
     } catch (e) {
       console.error("Failed to update config.yaml version:", e);
     }
   }
-  const mcpPath = path31.join(rrceHome, "mcp.yaml");
-  if (fs29.existsSync(mcpPath)) {
+  const mcpPath = path32.join(rrceHome, "mcp.yaml");
+  if (fs30.existsSync(mcpPath)) {
     try {
-      const content = fs29.readFileSync(mcpPath, "utf-8");
+      const content = fs30.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;
-          fs29.writeFileSync(mcpPath, stringify2(yaml));
+          fs30.writeFileSync(mcpPath, stringify2(yaml));
         }
       }
     } catch (e) {
@@ -7382,9 +7529,9 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     const configFilePath = getConfigPath(workspacePath);
     let currentSyncedVersion;
-    if (fs29.existsSync(configFilePath)) {
+    if (fs30.existsSync(configFilePath)) {
       try {
-        const content = fs29.readFileSync(configFilePath, "utf-8");
+        const content = fs30.readFileSync(configFilePath, "utf-8");
         const config = parse(content);
         currentSyncedVersion = config.last_synced_version;
       } catch (e) {
@@ -7408,8 +7555,8 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
       `  \u2022 docs/ (documentation)`
     ];
     const ideTargets = [];
-    if (fs29.existsSync(configFilePath)) {
-      const configContent = fs29.readFileSync(configFilePath, "utf-8");
+    if (fs30.existsSync(configFilePath)) {
+      const configContent = fs30.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");
@@ -7438,14 +7585,14 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       const dirs = ["templates", "prompts", "docs"];
       const updatedFiles = [];
       for (const dir of dirs) {
-        const srcDir = path31.join(agentCoreDir, dir);
-        if (!fs29.existsSync(srcDir)) continue;
+        const srcDir = path32.join(agentCoreDir, dir);
+        if (!fs30.existsSync(srcDir)) continue;
         const syncFiles = (src, rel) => {
-          const entries = fs29.readdirSync(src, { withFileTypes: true });
+          const entries = fs30.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
-            const entrySrc = path31.join(src, entry.name);
-            const entryRel = path31.join(rel, entry.name);
-            const entryDest = path31.join(dataPath, entryRel);
+            const entrySrc = path32.join(src, entry.name);
+            const entryRel = path32.join(rel, entry.name);
+            const entryDest = path32.join(dataPath, entryRel);
             if (entry.isDirectory()) {
               ensureDir(entryDest);
               syncFiles(entrySrc, entryRel);
@@ -7453,8 +7600,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
               if (driftReport.modifiedFiles.includes(entryRel)) {
                 backupFile(entryDest);
               }
-              ensureDir(path31.dirname(entryDest));
-              fs29.copyFileSync(entrySrc, entryDest);
+              ensureDir(path32.dirname(entryDest));
+              fs30.copyFileSync(entrySrc, entryDest);
               updatedFiles.push(entryRel);
             }
           }
@@ -7465,12 +7612,12 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       DriftService.saveManifest(dataPath, manifest);
     }
     const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-    ensureDir(path31.join(rrceHome, "templates"));
-    ensureDir(path31.join(rrceHome, "docs"));
-    copyDirRecursive(path31.join(agentCoreDir, "templates"), path31.join(rrceHome, "templates"));
-    copyDirRecursive(path31.join(agentCoreDir, "docs"), path31.join(rrceHome, "docs"));
-    if (fs29.existsSync(configFilePath)) {
-      const configContent = fs29.readFileSync(configFilePath, "utf-8");
+    ensureDir(path32.join(rrceHome, "templates"));
+    ensureDir(path32.join(rrceHome, "docs"));
+    copyDirRecursive(path32.join(agentCoreDir, "templates"), path32.join(rrceHome, "templates"));
+    copyDirRecursive(path32.join(agentCoreDir, "docs"), path32.join(rrceHome, "docs"));
+    if (fs30.existsSync(configFilePath)) {
+      const configContent = fs30.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
@@ -7492,21 +7639,21 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       try {
         const yaml = parse(configContent);
         yaml.last_synced_version = runningVersion;
-        fs29.writeFileSync(configFilePath, stringify2(yaml));
+        fs30.writeFileSync(configFilePath, stringify2(yaml));
       } catch (e) {
         console.error("Failed to update config.yaml version:", e);
       }
     }
-    const mcpPath = path31.join(rrceHome, "mcp.yaml");
-    if (fs29.existsSync(mcpPath)) {
+    const mcpPath = path32.join(rrceHome, "mcp.yaml");
+    if (fs30.existsSync(mcpPath)) {
       try {
-        const content = fs29.readFileSync(mcpPath, "utf-8");
+        const content = fs30.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;
-            fs29.writeFileSync(mcpPath, stringify2(yaml));
+            fs30.writeFileSync(mcpPath, stringify2(yaml));
           }
         }
       } catch (e) {
@@ -7541,8 +7688,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path31.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path31.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path32.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path32.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -7565,8 +7712,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 fs33 from "fs";
-import * as path33 from "path";
+import * as fs34 from "fs";
+import * as path34 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/lib/git.ts
@@ -8243,7 +8390,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 fs30 from "fs";
+import * as fs31 from "fs";
 init_detection();
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
@@ -8282,7 +8429,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs30.readFileSync(configFilePath, "utf-8");
+  let configContent = fs31.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -8309,7 +8456,7 @@ linked_projects:
 `;
     });
   }
-  fs30.writeFileSync(configFilePath, configContent);
+  fs31.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -8345,15 +8492,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 fs31 from "fs";
-import * as path32 from "path";
+import * as fs32 from "fs";
+import * as path33 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path32.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path33.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs31.existsSync(path32.join(localPath, dir))
+    (dir) => fs32.existsSync(path33.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro5(pc11.yellow("No data found in workspace storage to sync."));
@@ -8379,8 +8526,8 @@ Destination: ${pc11.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path32.join(localPath, dir);
-      const destDir = path32.join(globalPath, dir);
+      const srcDir = path33.join(localPath, dir);
+      const destDir = path33.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -8408,7 +8555,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 fs32 from "fs";
+import * as fs33 from "fs";
 init_detection();
 init_config();
 async function runDeleteGlobalProjectFlow(availableProjects) {
@@ -8452,8 +8599,8 @@ Are you sure?`,
     for (const projectName of projectsToDelete) {
       const project = globalProjects.find((p) => p.name === projectName);
       if (!project) continue;
-      if (fs32.existsSync(project.dataPath)) {
-        fs32.rmSync(project.dataPath, { recursive: true, force: true });
+      if (fs33.existsSync(project.dataPath)) {
+        fs33.rmSync(project.dataPath, { recursive: true, force: true });
       }
       const newConfig = removeProjectConfig(mcpConfig, projectName);
       configChanged = true;
@@ -8475,9 +8622,9 @@ init_config();
 function getPackageVersion3() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path33.join(path33.dirname(agentCoreDir), "package.json");
-    if (fs33.existsSync(packageJsonPath)) {
-      return JSON.parse(fs33.readFileSync(packageJsonPath, "utf8")).version;
+    const packageJsonPath = path34.join(path34.dirname(agentCoreDir), "package.json");
+    if (fs34.existsSync(packageJsonPath)) {
+      return JSON.parse(fs34.readFileSync(packageJsonPath, "utf8")).version;
     }
   } catch (e) {
   }
@@ -8485,9 +8632,9 @@ function getPackageVersion3() {
 }
 function getLastSyncedVersion(workspacePath, workspaceName) {
   const configFilePath = getConfigPath(workspacePath);
-  if (fs33.existsSync(configFilePath)) {
+  if (fs34.existsSync(configFilePath)) {
     try {
-      const content = fs33.readFileSync(configFilePath, "utf-8");
+      const content = fs34.readFileSync(configFilePath, "utf-8");
       const config = parse2(content);
       if (config.last_synced_version) {
         return config.last_synced_version;
@@ -8496,10 +8643,10 @@ function getLastSyncedVersion(workspacePath, workspaceName) {
     }
   }
   const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
-  const mcpPath = path33.join(rrceHome, "mcp.yaml");
-  if (fs33.existsSync(mcpPath)) {
+  const mcpPath = path34.join(rrceHome, "mcp.yaml");
+  if (fs34.existsSync(mcpPath)) {
     try {
-      const content = fs33.readFileSync(mcpPath, "utf-8");
+      const content = fs34.readFileSync(mcpPath, "utf-8");
       const config = parse2(content);
       const project = config.projects?.find((p) => p.name === workspaceName);
       if (project?.last_synced_version) {
@@ -8569,11 +8716,11 @@ Workspace: ${pc13.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  let isAlreadyConfigured = fs33.existsSync(configFilePath);
+  let isAlreadyConfigured = fs34.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs33.readFileSync(configFilePath, "utf-8");
+      const configContent = fs34.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
@@ -8590,7 +8737,7 @@ Workspace: ${pc13.bold(workspaceName)}`,
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs33.existsSync(localDataPath);
+  const hasLocalData = fs34.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const continueToMenu = await checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode);
     if (!continueToMenu) {

package/package.json

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