rrce-workflow 0.2.78 → 0.2.80

package/agent-core/templates/research_output.md

@@ -18,48 +18,150 @@
   - {{date}}: ISO date (YYYY-MM-DD)
   - {{source}}: URL or reference to original request
   - {{workspace_name}}: Project name
+  
+  NOTE: This document is the output of an interactive research session.
+  The Research agent engaged in constructive dialogue with the user to
+  achieve 100% understanding before this brief was generated.
 -->
 # Research Brief – {{task_title}}
 
-- Task ID: `{{task_id}}`
-- Task Slug: `{{task_slug}}`
-- Author: `{{author}}`
-- Date: `{{date}}`
-- Source Request / Conversation URL: `{{source}}`
-- Workspace: `{{workspace_name}}`
+| Field | Value |
+|-------|-------|
+| Task ID | `{{task_id}}` |
+| Task Slug | `{{task_slug}}` |
+| Author | `{{author}}` |
+| Date | `{{date}}` |
+| Source Request | `{{source}}` |
+| Workspace | `{{workspace_name}}` |
+
+---
 
 ## 1. Request Summary
-- Concise restatement of the user's ask.
-- Highlight explicit goals, constraints, and success metrics.
 
-## Checklist
-- [ ] Replace with concrete clarification or validation step.
-- [ ] Replace with next ready-to-run action.
+> **Original Request**: [Quote the user's initial request]
+
+**Refined Understanding** (after clarification):
+- [Clear, specific statement of what needs to be built]
+- [Why it needs to be built - problem/opportunity]
+
+---
+
+## 2. Clarification Summary
+
+The following was clarified through interactive dialogue:
+
+| Topic | Question Asked | User Response | Impact on Scope |
+|-------|----------------|---------------|-----------------|
+| Intent | | | |
+| Constraints | | | |
+| Success Criteria | | | |
+| Edge Cases | | | |
+
+**Key Decisions Made**:
+- [Decision 1 and rationale]
+- [Decision 2 and rationale]
+
+---
+
+## 3. Current Knowledge Snapshot
+
+Relevant prior work and context from project knowledge:
+
+| Source | Relevance |
+|--------|-----------|
+| `{{RRCE_DATA}}/knowledge/...` | [How it applies] |
+| [Search result] | [How it applies] |
+
+**Patterns to Follow**:
+- [Existing pattern 1 from codebase]
+- [Existing pattern 2 from codebase]
+
+---
+
+## 4. Requirements
+
+### Functional Requirements
+- [ ] [FR-1]: [Requirement description]
+- [ ] [FR-2]: [Requirement description]
+- [ ] [FR-3]: [Requirement description]
+
+### Non-Functional Requirements
+- [ ] [NFR-1]: [Performance/Security/etc. requirement]
+- [ ] [NFR-2]: [Requirement description]
+
+### Success Criteria
+How we'll know this is done:
+1. [Measurable outcome 1]
+2. [Measurable outcome 2]
+3. [Measurable outcome 3]
+
+---
+
+## 5. Scope Boundaries
+
+### In Scope
+- [Explicit inclusion 1]
+- [Explicit inclusion 2]
+
+### Out of Scope
+- [Explicit exclusion 1]
+- [Explicit exclusion 2]
+
+### Constraints
+- [Hard constraint 1 - e.g., timeline, tech, resources]
+- [Hard constraint 2]
+
+---
+
+## 6. Assumptions & Risks
+
+### Assumptions
+| ID | Assumption | Confidence | Validation Needed |
+|----|------------|------------|-------------------|
+| A1 | [Assumption] | High/Medium/Low | [How to validate] |
+| A2 | [Assumption] | High/Medium/Low | [How to validate] |
+
+### Risks
+| ID | Risk | Impact | Likelihood | Mitigation |
+|----|------|--------|------------|------------|
+| R1 | [Risk description] | High/Medium/Low | High/Medium/Low | [Mitigation] |
+| R2 | [Risk description] | High/Medium/Low | High/Medium/Low | [Mitigation] |
+
+---
+
+## 7. Opportunity & Alternative Approaches
+
+Approaches considered during research:
+
+| Approach | Pros | Cons | Recommendation |
+|----------|------|------|----------------|
+| [Approach A] | | | Chosen / Rejected |
+| [Approach B] | | | Chosen / Rejected |
+
+**Rationale for chosen approach**: [Explanation]
+
+---
 
-## 2. Current Knowledge Snapshot
-- Relevant prior work or documents from `{{RRCE_DATA}}/knowledge` or workspace.
-- Key facts that shape feasibility or scope.
+## 8. Hand-off Notes for Planning
 
-## 3. Clarifications & Responses
-| Question | Answer | Status (answered/pending) | Reference |
-| --- | --- | --- | --- |
-|  |  |  |  |
+### Ready for Planning
+- [ ] Core requirements are clear and specific
+- [ ] Success criteria are measurable
+- [ ] Scope boundaries are explicit
+- [ ] No blocking open questions remain
 
-## 4. Assumptions & Risks
-- Explicit assumptions that require validation.
-- Risks or edge cases that need attention.
+### Context for Planning Agent
+- [Important context the planner needs to know]
+- [Technical considerations for task breakdown]
 
-## 5. Opportunity & Alternative Approaches
-- Potential strategies worth evaluating.
-- Trade-offs or spikes recommended before execution.
+### Open Questions (Non-Blocking)
+- [Question that can be resolved during planning or execution]
 
-## 6. Raw Requirement Draft
-- Bullet the functional outcomes and non-functional requirements as currently understood.
-- Note acceptance signals or metrics where available.
+### References Added to meta.json
+- [List of knowledge files referenced]
 
-## 7. Hand-off Notes
-- Immediate next steps for Planning.
-- Pending clarifications or decisions to resolve.
-- References added to `meta.json`.
+---
 
-> Keep this document under 500 lines. Replace placeholders with concise entries and trim empty sections if unnecessary.
+> **Next Step**: `/plan TASK_SLUG={{task_slug}}`
+> 
+> Keep this document under 500 lines. Replace placeholders with concise entries and trim empty sections.

package/dist/index.js

@@ -1260,27 +1260,24 @@ function copyPromptsToDir(prompts, targetDir, extension) {
     fs7.writeFileSync(targetPath, content);
   }
 }
-function convertToOpenCodeAgent(prompt) {
+function convertToOpenCodeAgent(prompt, useFileReference = false, promptFilePath) {
   const { frontmatter, content } = prompt;
-  const tools = {
-    // Enable standard host tools by default
-    "read": true,
-    "write": true,
-    "edit": true,
-    "bash": true,
-    "grep": true,
-    "glob": true,
-    "webfetch": true
-  };
+  const tools = {};
+  const hostTools = ["read", "write", "edit", "bash", "grep", "glob", "webfetch", "terminalLastCommand"];
   if (frontmatter.tools) {
     for (const tool of frontmatter.tools) {
-      tools[`rrce_${tool}`] = true;
+      if (hostTools.includes(tool)) {
+        tools[tool] = true;
+      } else {
+        tools[`rrce_${tool}`] = true;
+      }
     }
   }
+  tools["webfetch"] = true;
   return {
     description: frontmatter.description,
     mode: "primary",
-    prompt: content,
+    prompt: useFileReference && promptFilePath ? `{file:${promptFilePath}}` : content,
     tools
   };
 }
@@ -1697,6 +1694,8 @@ async function installAgentPrompts(config, workspacePath, dataPaths) {
       if (primaryDataPath) {
         if (config.storageMode === "global") {
           try {
+            const promptsDir = path12.join(path12.dirname(OPENCODE_CONFIG), "prompts");
+            ensureDir(promptsDir);
             let opencodeConfig = { $schema: "https://opencode.ai/config.json" };
             if (fs10.existsSync(OPENCODE_CONFIG)) {
               opencodeConfig = JSON.parse(fs10.readFileSync(OPENCODE_CONFIG, "utf-8"));
@@ -1704,7 +1703,10 @@ async function installAgentPrompts(config, workspacePath, dataPaths) {
             if (!opencodeConfig.agent) opencodeConfig.agent = {};
             for (const prompt of prompts) {
               const baseName = path12.basename(prompt.filePath, ".md");
-              const agentConfig = convertToOpenCodeAgent(prompt);
+              const promptFileName = `rrce-${baseName}.md`;
+              const promptFilePath = path12.join(promptsDir, promptFileName);
+              fs10.writeFileSync(promptFilePath, prompt.content);
+              const agentConfig = convertToOpenCodeAgent(prompt, true, `./prompts/${promptFileName}`);
               opencodeConfig.agent[baseName] = agentConfig;
             }
             fs10.writeFileSync(OPENCODE_CONFIG, JSON.stringify(opencodeConfig, null, 2) + "\n");
@@ -2214,6 +2216,7 @@ var init_rag = __esm({
 // src/mcp/resources.ts
 import * as fs14 from "fs";
 import * as path16 from "path";
+import * as crypto from "crypto";
 function getExposedProjects() {
   const config = loadMCPConfig();
   const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
@@ -2534,9 +2537,101 @@ All file operations should be relative to WORKSPACE_ROOT shown above.
 `;
   return contextPreamble;
 }
+function getTask(projectName, taskSlug) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) return null;
+  const metaPath = path16.join(project.tasksPath, taskSlug, "meta.json");
+  if (!fs14.existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(fs14.readFileSync(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function createTask(projectName, taskSlug, taskData) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) {
+    throw new Error(`Project '${projectName}' not found or not configured with a tasks path.`);
+  }
+  const taskDir = path16.join(project.tasksPath, taskSlug);
+  if (fs14.existsSync(taskDir)) {
+    throw new Error(`Task with slug '${taskSlug}' already exists.`);
+  }
+  fs14.mkdirSync(taskDir, { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "research"), { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "planning"), { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "execution"), { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "docs"), { recursive: true });
+  const rrceHome = process.env.RRCE_HOME || path16.join(__require("os").homedir(), ".rrce-workflow");
+  const templatePath = path16.join(rrceHome, "templates", "meta.template.json");
+  let meta = {
+    task_id: crypto.randomUUID(),
+    task_slug: taskSlug,
+    status: "draft",
+    agents: {}
+  };
+  if (fs14.existsSync(templatePath)) {
+    try {
+      const template = JSON.parse(fs14.readFileSync(templatePath, "utf-8"));
+      meta = { ...template, ...meta };
+    } catch (e) {
+      logger.error("Failed to load meta template", e);
+    }
+  }
+  meta.created_at = (/* @__PURE__ */ new Date()).toISOString();
+  meta.updated_at = meta.created_at;
+  meta.workspace = {
+    name: project.name,
+    path: project.path || project.dataPath,
+    hash: project.name
+  };
+  Object.assign(meta, taskData);
+  const metaPath = path16.join(taskDir, "meta.json");
+  fs14.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+  return meta;
+}
+async function updateTask(projectName, taskSlug, taskData) {
+  const meta = getTask(projectName, taskSlug);
+  if (!meta) throw new Error(`Task '${taskSlug}' not found.`);
+  const updatedMeta = {
+    ...meta,
+    ...taskData,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Ensure nested objects are merged if they exist in taskData
+    agents: taskData.agents ? { ...meta.agents, ...taskData.agents } : meta.agents,
+    workspace: meta.workspace
+    // Protect workspace metadata
+  };
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) return null;
+  const metaPath = path16.join(project.tasksPath, taskSlug, "meta.json");
+  fs14.writeFileSync(metaPath, JSON.stringify(updatedMeta, null, 2));
+  return updatedMeta;
+}
+function deleteTask(projectName, taskSlug) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) return false;
+  const taskDir = path16.join(project.tasksPath, taskSlug);
+  if (!fs14.existsSync(taskDir)) return false;
+  if (fs14.rmSync) {
+    fs14.rmSync(taskDir, { recursive: true, force: true });
+  } else {
+    fs14.rmdirSync(taskDir, { recursive: true });
+  }
+  return true;
+}
 var init_resources = __esm({
   "src/mcp/resources.ts"() {
     "use strict";
+    init_logger();
     init_config();
     init_config_utils();
     init_detection();
@@ -2779,6 +2874,66 @@ function registerToolHandlers(server) {
           },
           required: ["agent"]
         }
+      },
+      {
+        name: "list_tasks",
+        description: "List all tasks for a project",
+        inputSchema: {
+          type: "object",
+          properties: { project: { type: "string", description: "Name of the project" } },
+          required: ["project"]
+        }
+      },
+      {
+        name: "get_task",
+        description: "Get details of a specific task",
+        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: "create_task",
+        description: "Create a new task in the project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug for the new task (kebab-case)" },
+            title: { type: "string", description: "The title of the task" },
+            summary: { type: "string", description: "Brief summary of the task" }
+          },
+          required: ["project", "task_slug"]
+        }
+      },
+      {
+        name: "update_task",
+        description: "Update an existing task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task" },
+            updates: { type: "object", description: "The fields to update in meta.json", additionalProperties: true }
+          },
+          required: ["project", "task_slug", "updates"]
+        }
+      },
+      {
+        name: "delete_task",
+        description: "Delete a task from the project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task to delete" }
+          },
+          required: ["project", "task_slug"]
+        }
       }
     ];
     const projects = getExposedProjects();
@@ -2866,6 +3021,38 @@ The system has pre-resolved the configuration for this project. Use these values
 `;
           return { content: [{ type: "text", text: contextPreamble + rendered }] };
         }
+        case "list_tasks": {
+          const params = args;
+          const tasks = getProjectTasks(params.project);
+          return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+        }
+        case "get_task": {
+          const params = args;
+          const task = getTask(params.project, params.task_slug);
+          if (!task) {
+            return { content: [{ type: "text", text: `Task '${params.task_slug}' not found in project '${params.project}'.` }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "create_task": {
+          const params = args;
+          const taskData = {
+            title: params.title || params.task_slug,
+            summary: params.summary || ""
+          };
+          const task = await createTask(params.project, params.task_slug, taskData);
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "update_task": {
+          const params = args;
+          const task = await updateTask(params.project, params.task_slug, params.updates);
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "delete_task": {
+          const params = args;
+          const success = deleteTask(params.project, params.task_slug);
+          return { content: [{ type: "text", text: success ? `Task '${params.task_slug}' deleted.` : `Failed to delete task '${params.task_slug}'.` }] };
+        }
         case "help_setup": {
           const msg = `
 RRCE MCP Server is running, but no projects are configured/exposed.
@@ -4729,6 +4916,7 @@ import { confirm as confirm9, spinner as spinner6, note as note12, outro as outr
 import pc14 from "picocolors";
 import * as fs18 from "fs";
 import * as path19 from "path";
+import { stringify as stringify3 } from "yaml";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner6();
   s.start("Checking for updates");
@@ -4739,10 +4927,25 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const customGlobalPath = getEffectiveRRCEHome(workspacePath);
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     s.stop("Updates found");
+    const updateTargets = [
+      `  \u2022 prompts/ (${prompts.length} agent prompts)`,
+      `  \u2022 templates/ (output templates)`,
+      `  \u2022 docs/ (documentation)`
+    ];
+    const configFilePath = getConfigPath(workspacePath);
+    const ideTargets = [];
+    if (fs18.existsSync(configFilePath)) {
+      const configContent = fs18.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");
+    }
+    if (ideTargets.length > 0) {
+      updateTargets.push(`  \u2022 IDE integrations: ${ideTargets.join(", ")}`);
+    }
     note12(
       `The following will be updated from the package:
-  \u2022 prompts/ (${prompts.length} agent prompts)
-  \u2022 templates/ (output templates)
+${updateTargets.join("\n")}
 
 Target locations:
 ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
@@ -4759,29 +4962,51 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
       copyDirToAllStoragePaths(path19.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path19.join(agentCoreDir, "prompts"), "prompts", [dataPath]);
+      copyDirToAllStoragePaths(path19.join(agentCoreDir, "docs"), "docs", [dataPath]);
     }
-    const configFilePath = getConfigPath(workspacePath);
+    const rrceHome = customGlobalPath || getDefaultRRCEHome2();
+    ensureDir(path19.join(rrceHome, "templates"));
+    ensureDir(path19.join(rrceHome, "docs"));
+    copyDirRecursive(path19.join(agentCoreDir, "templates"), path19.join(rrceHome, "templates"));
+    copyDirRecursive(path19.join(agentCoreDir, "docs"), path19.join(rrceHome, "docs"));
     if (fs18.existsSync(configFilePath)) {
       const configContent = fs18.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
+        clearDirectory(copilotPath);
         copyPromptsToDir(prompts, copilotPath, ".agent.md");
       }
       if (configContent.includes("antigravity: true")) {
         const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
         ensureDir(antigravityPath);
+        clearDirectory(antigravityPath);
         copyPromptsToDir(prompts, antigravityPath, ".md");
       }
+      if (configContent.includes("opencode: true")) {
+        const primaryDataPath = dataPaths[0];
+        if (primaryDataPath) {
+          updateOpenCodeAgents(prompts, mode, primaryDataPath);
+        }
+      }
     }
     s.stop("Update complete");
     const summary = [
       `Updated:`,
       `  \u2713 ${prompts.length} agent prompts`,
       `  \u2713 Output templates`,
-      ``,
-      `Your configuration and knowledge files were preserved.`
+      `  \u2713 Documentation`
     ];
+    if (ideTargets.length > 0) {
+      summary.push(`  \u2713 IDE integrations: ${ideTargets.join(", ")}`);
+    }
+    summary.push(
+      ``,
+      `Your configuration and knowledge files were preserved.`,
+      ``,
+      pc14.dim(`\u{1F4A1} If using OpenCode, you may need to reload for changes to take effect.`)
+    );
     note12(summary.join("\n"), "Update Summary");
     outro5(pc14.green("\u2713 Successfully updated from package!"));
   } catch (error) {
@@ -4790,6 +5015,69 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     process.exit(1);
   }
 }
+function updateOpenCodeAgents(prompts, mode, primaryDataPath) {
+  if (mode === "global") {
+    try {
+      const promptsDir = path19.join(path19.dirname(OPENCODE_CONFIG), "prompts");
+      ensureDir(promptsDir);
+      let opencodeConfig = { $schema: "https://opencode.ai/config.json" };
+      if (fs18.existsSync(OPENCODE_CONFIG)) {
+        opencodeConfig = JSON.parse(fs18.readFileSync(OPENCODE_CONFIG, "utf-8"));
+      }
+      if (!opencodeConfig.agent) opencodeConfig.agent = {};
+      const currentAgentNames = prompts.map((p) => path19.basename(p.filePath, ".md"));
+      const existingAgentNames = Object.keys(opencodeConfig.agent);
+      const rrceAgentPrefixes = ["init", "research", "planning", "executor", "doctor", "documentation", "sync"];
+      for (const existingName of existingAgentNames) {
+        const isRrceAgent = rrceAgentPrefixes.some((prefix) => existingName.startsWith(prefix));
+        const stillExists = currentAgentNames.includes(existingName);
+        if (isRrceAgent && !stillExists) {
+          delete opencodeConfig.agent[existingName];
+          const oldPromptFile = path19.join(promptsDir, `rrce-${existingName}.md`);
+          if (fs18.existsSync(oldPromptFile)) {
+            fs18.unlinkSync(oldPromptFile);
+          }
+        }
+      }
+      for (const prompt of prompts) {
+        const baseName = path19.basename(prompt.filePath, ".md");
+        const promptFileName = `rrce-${baseName}.md`;
+        const promptFilePath = path19.join(promptsDir, promptFileName);
+        fs18.writeFileSync(promptFilePath, prompt.content);
+        const agentConfig = convertToOpenCodeAgent(prompt, true, `./prompts/${promptFileName}`);
+        opencodeConfig.agent[baseName] = agentConfig;
+      }
+      fs18.writeFileSync(OPENCODE_CONFIG, JSON.stringify(opencodeConfig, null, 2) + "\n");
+    } catch (e) {
+      console.error("Failed to update global OpenCode config with agents:", e);
+    }
+  } else {
+    const opencodeBaseDir = path19.join(primaryDataPath, ".opencode", "agent");
+    ensureDir(opencodeBaseDir);
+    clearDirectory(opencodeBaseDir);
+    for (const prompt of prompts) {
+      const baseName = path19.basename(prompt.filePath, ".md");
+      const agentConfig = convertToOpenCodeAgent(prompt);
+      const content = `---
+${stringify3({
+        description: agentConfig.description,
+        mode: agentConfig.mode,
+        tools: agentConfig.tools
+      })}---
+${agentConfig.prompt}`;
+      fs18.writeFileSync(path19.join(opencodeBaseDir, `${baseName}.md`), content);
+    }
+  }
+}
+function clearDirectory(dirPath) {
+  if (!fs18.existsSync(dirPath)) return;
+  const entries = fs18.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      fs18.unlinkSync(path19.join(dirPath, entry.name));
+    }
+  }
+}
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
   const globalPath = path19.join(customGlobalPath, "workspaces", workspaceName);
   const workspacePath = path19.join(workspaceRoot, ".rrce-workflow");
@@ -4808,6 +5096,7 @@ var init_update_flow = __esm({
     init_paths();
     init_prompts();
     init_utils();
+    init_install();
   }
 });
 

package/docs/architecture.md

@@ -7,7 +7,9 @@
 RRCE-Workflow is a TUI-based agentic code workflow generator designed to work seamlessly across:
 - **GitHub Copilot CLI**
 - **Antigravity IDE** (Google's agentic coding environment)
+- **OpenCode** (Native agentic TUI environment)
 - **VS Code** (with Copilot and other AI extensions)
+- **Claude Desktop**
 
 The system provides a structured multi-agent pipeline for software development tasks, with persistent knowledge caching and workspace-aware context management.
 
@@ -243,6 +245,7 @@ RRCE-Workflow prompts are designed to work across multiple AI coding tools:
 | Tool | Prompt Location | Extension | Notes |
 |------|----------------|-----------|-------|
 | **Antigravity IDE** | `.agent/workflows/` | `.md` | Native workflow support |
+| **OpenCode** | `.opencode/agent/` | `.md` | Custom Primary Agents |
 | **GitHub Copilot (VSCode)** | `.github/agents/` | `.agent.md` | Custom agents format |
 | **Copilot CLI** | Any location | `.md` | Reference via file path |
 
@@ -298,6 +301,17 @@ When you run `rrce-workflow wizard`, it creates:
 └── sync.md
 ```
 
+**For OpenCode:**
+```
+.opencode/agent/
+├── rrce-init.md
+├── rrce-research.md
+├── rrce-planning.md
+├── rrce-executor.md
+├── rrce-documentation.md
+└── rrce-sync.md
+```
+
 ### Copilot-Specific Features
 
 Our prompts include Copilot-compatible frontmatter:

package/package.json

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