rrce-workflow 0.3.0 → 0.3.2

package/dist/index.js

@@ -574,9 +574,97 @@ var init_detection_service = __esm({
   }
 });
 
-// src/lib/autocomplete-prompt.ts
+// src/types/prompt.ts
+import { z } from "zod";
+var PromptArgSchema, AutoIdentitySchema, PromptFrontmatterSchema;
+var init_prompt = __esm({
+  "src/types/prompt.ts"() {
+    "use strict";
+    PromptArgSchema = z.object({
+      name: z.string(),
+      default: z.string().optional(),
+      prompt: z.string().optional()
+    });
+    AutoIdentitySchema = z.object({
+      user: z.string(),
+      model: z.string()
+    });
+    PromptFrontmatterSchema = z.object({
+      name: z.string(),
+      description: z.string(),
+      "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
+      tools: z.array(z.string()).optional(),
+      mode: z.enum(["primary", "subagent"]).optional(),
+      "required-args": z.array(PromptArgSchema).optional(),
+      "optional-args": z.array(PromptArgSchema).optional(),
+      "auto-identity": AutoIdentitySchema.optional()
+    });
+  }
+});
+
+// src/lib/prompts.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+function parsePromptFile(filePath) {
+  try {
+    const fileContent = fs4.readFileSync(filePath, "utf-8");
+    const { data, content } = matter(fileContent);
+    const parsed = PromptFrontmatterSchema.safeParse(data);
+    if (!parsed.success) {
+      console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
+      return null;
+    }
+    return {
+      frontmatter: parsed.data,
+      content: content.trim(),
+      filePath
+    };
+  } catch (error) {
+    console.error(`Error reading prompt file ${filePath}:`, error);
+    return null;
+  }
+}
+function loadPromptsFromDir(dirPath) {
+  if (!fs4.existsSync(dirPath)) {
+    return [];
+  }
+  const files = fs4.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
+  const prompts = [];
+  for (const file of files) {
+    const prompt = parsePromptFile(path4.join(dirPath, file));
+    if (prompt) {
+      prompts.push(prompt);
+    }
+  }
+  return prompts;
+}
+function getAgentCoreDir() {
+  if (__dirname.includes("/src/") || __dirname.includes("\\src\\")) {
+    if (fs4.existsSync(path4.join(process.cwd(), "agent-core"))) {
+      return path4.join(process.cwd(), "agent-core");
+    }
+    return path4.resolve(__dirname, "../..", "agent-core");
+  }
+  return path4.join(__dirname, "..", "agent-core");
+}
+function getAgentCorePromptsDir() {
+  return path4.join(getAgentCoreDir(), "prompts");
+}
+var __filename, __dirname;
+var init_prompts = __esm({
+  "src/lib/prompts.ts"() {
+    "use strict";
+    init_prompt();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path4.dirname(__filename);
+  }
+});
+
+// src/lib/autocomplete-prompt.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
 import * as readline from "readline";
 import pc from "picocolors";
 function directoryPrompt(opts) {
@@ -635,19 +723,19 @@ function completeDirectory(line) {
       prefix = "";
       basePath = expanded;
     } else {
-      dirToScan = path4.dirname(expanded);
-      prefix = path4.basename(expanded).toLowerCase();
+      dirToScan = path5.dirname(expanded);
+      prefix = path5.basename(expanded).toLowerCase();
       basePath = dirToScan === "/" ? "/" : dirToScan + "/";
     }
-    if (!fs4.existsSync(dirToScan)) {
+    if (!fs5.existsSync(dirToScan)) {
       return [[], line];
     }
-    const entries = fs4.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
+    const entries = fs5.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
       if (!entry.isDirectory()) return false;
       if (entry.name.startsWith(".") && !prefix.startsWith(".")) return false;
       return prefix === "" || entry.name.toLowerCase().startsWith(prefix);
     }).map((entry) => {
-      const fullPath = path4.join(dirToScan, entry.name);
+      const fullPath = path5.join(dirToScan, entry.name);
       const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
       return displayPath + "/";
     }).sort();
@@ -693,7 +781,7 @@ __export(tui_utils_exports, {
 });
 import { select, note, isCancel } from "@clack/prompts";
 import pc2 from "picocolors";
-import * as path5 from "path";
+import * as path6 from "path";
 async function resolveGlobalPath() {
   const prefs = loadUserPreferences();
   const defaultPath = prefs.defaultGlobalPath || getDefaultRRCEHome2();
@@ -732,7 +820,7 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path5.join(process.env.HOME || "~", ".rrce-workflow");
+  const suggestedPath = path6.join(process.env.HOME || "~", ".rrce-workflow");
   const customPath = await directoryPrompt({
     message: "Enter custom global path (Tab to autocomplete):",
     defaultValue: suggestedPath,
@@ -751,7 +839,7 @@ Please choose a custom path instead.`,
   }
   let expandedPath = customPath;
   if (!expandedPath.endsWith(".rrce-workflow")) {
-    expandedPath = path5.join(expandedPath, ".rrce-workflow");
+    expandedPath = path6.join(expandedPath, ".rrce-workflow");
   }
   saveUserPreferences({ defaultGlobalPath: expandedPath, useCustomGlobalPath: true });
   return expandedPath;
@@ -766,8 +854,8 @@ var init_tui_utils = __esm({
 });
 
 // src/mcp/install.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import * as os from "os";
 function checkInstallStatus(workspacePath) {
   return {
@@ -779,46 +867,46 @@ function checkInstallStatus(workspacePath) {
   };
 }
 function checkAntigravityConfig() {
-  if (!fs5.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  if (!fs6.existsSync(ANTIGRAVITY_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkClaudeConfig() {
-  if (!fs5.existsSync(CLAUDE_CONFIG)) return false;
+  if (!fs6.existsSync(CLAUDE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(CLAUDE_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeGlobalConfig() {
-  if (!fs5.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  if (!fs6.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     return !!content["mcp.servers"]?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path6.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs5.existsSync(configPath)) return false;
+  const configPath = path7.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs6.existsSync(configPath)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
     return !!content.servers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkOpenCodeConfig() {
-  if (!fs5.existsSync(OPENCODE_CONFIG)) return false;
+  if (!fs6.existsSync(OPENCODE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(OPENCODE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(OPENCODE_CONFIG, "utf-8"));
     return !!content.mcp?.["rrce"];
   } catch {
     return false;
@@ -845,14 +933,14 @@ function installToConfig(target, workspacePath) {
   }
 }
 function installToAntigravity() {
-  const dir = path6.dirname(ANTIGRAVITY_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs5.existsSync(ANTIGRAVITY_CONFIG)) {
+  if (fs6.existsSync(ANTIGRAVITY_CONFIG)) {
     try {
-      config = JSON.parse(fs5.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -862,21 +950,21 @@ function installToAntigravity() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    fs6.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToClaude() {
-  const dir = path6.dirname(CLAUDE_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(CLAUDE_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs5.existsSync(CLAUDE_CONFIG)) {
+  if (fs6.existsSync(CLAUDE_CONFIG)) {
     try {
-      config = JSON.parse(fs5.readFileSync(CLAUDE_CONFIG, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(CLAUDE_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -886,21 +974,21 @@ function installToClaude() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    fs6.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeGlobal() {
-  const dir = path6.dirname(VSCODE_GLOBAL_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let settings = {};
-  if (fs5.existsSync(VSCODE_GLOBAL_CONFIG)) {
+  if (fs6.existsSync(VSCODE_GLOBAL_CONFIG)) {
     try {
-      settings = JSON.parse(fs5.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+      settings = JSON.parse(fs6.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -910,22 +998,22 @@ function installToVSCodeGlobal() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    fs6.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path6.join(workspacePath, ".vscode");
-  const configPath = path6.join(vscodeDir, "mcp.json");
-  if (!fs5.existsSync(vscodeDir)) {
-    fs5.mkdirSync(vscodeDir, { recursive: true });
+  const vscodeDir = path7.join(workspacePath, ".vscode");
+  const configPath = path7.join(vscodeDir, "mcp.json");
+  if (!fs6.existsSync(vscodeDir)) {
+    fs6.mkdirSync(vscodeDir, { recursive: true });
   }
   let config = { servers: {} };
-  if (fs5.existsSync(configPath)) {
+  if (fs6.existsSync(configPath)) {
     try {
-      config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
     } catch {
     }
   }
@@ -935,23 +1023,23 @@ function installToVSCodeWorkspace(workspacePath) {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs6.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToOpenCode() {
-  const dir = path6.dirname(OPENCODE_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(OPENCODE_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let config = {
     $schema: "https://opencode.ai/config.json"
   };
-  if (fs5.existsSync(OPENCODE_CONFIG)) {
+  if (fs6.existsSync(OPENCODE_CONFIG)) {
     try {
-      config = JSON.parse(fs5.readFileSync(OPENCODE_CONFIG, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(OPENCODE_CONFIG, "utf-8"));
     } catch (error) {
       console.error("Warning: Could not parse existing OpenCode config, creating fresh config");
     }
@@ -963,7 +1051,7 @@ function installToOpenCode() {
     enabled: true
   };
   try {
-    fs5.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
+    fs6.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
     return true;
   } catch (error) {
     console.error("Failed to write OpenCode config:", error instanceof Error ? error.message : String(error));
@@ -987,115 +1075,170 @@ function getTargetLabel(target) {
   }
 }
 function isOpenCodeInstalled() {
-  const configDir = path6.join(os.homedir(), ".config/opencode");
-  const configFile = path6.join(configDir, "opencode.json");
-  return fs5.existsSync(configDir) || fs5.existsSync(configFile);
+  const configDir = path7.join(os.homedir(), ".config/opencode");
+  const configFile = path7.join(configDir, "opencode.json");
+  return fs6.existsSync(configDir) || fs6.existsSync(configFile);
 }
 function isAntigravityInstalled() {
-  const configDir = path6.join(os.homedir(), ".gemini/antigravity");
-  return fs5.existsSync(configDir);
+  const configDir = path7.join(os.homedir(), ".gemini/antigravity");
+  return fs6.existsSync(configDir);
 }
 function isVSCodeInstalled() {
-  const configDir = path6.join(os.homedir(), ".config/Code/User");
-  return fs5.existsSync(configDir);
+  const configDir = path7.join(os.homedir(), ".config/Code/User");
+  return fs6.existsSync(configDir);
 }
 var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG, OPENCODE_CONFIG_DIR, OPENCODE_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path6.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path6.join(os.homedir(), ".config/claude/claude_desktop_config.json");
-    VSCODE_GLOBAL_CONFIG = path6.join(os.homedir(), ".config/Code/User/settings.json");
-    OPENCODE_CONFIG_DIR = path6.join(os.homedir(), ".config/opencode");
-    OPENCODE_CONFIG = path6.join(OPENCODE_CONFIG_DIR, "opencode.json");
+    ANTIGRAVITY_CONFIG = path7.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path7.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path7.join(os.homedir(), ".config/Code/User/settings.json");
+    OPENCODE_CONFIG_DIR = path7.join(os.homedir(), ".config/opencode");
+    OPENCODE_CONFIG = path7.join(OPENCODE_CONFIG_DIR, "opencode.json");
   }
 });
 
-// src/types/prompt.ts
-import { z } from "zod";
-var PromptArgSchema, AutoIdentitySchema, PromptFrontmatterSchema;
-var init_prompt = __esm({
-  "src/types/prompt.ts"() {
-    "use strict";
-    PromptArgSchema = z.object({
-      name: z.string(),
-      default: z.string().optional(),
-      prompt: z.string().optional()
-    });
-    AutoIdentitySchema = z.object({
-      user: z.string(),
-      model: z.string()
-    });
-    PromptFrontmatterSchema = z.object({
-      name: z.string(),
-      description: z.string(),
-      "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
-      tools: z.array(z.string()).optional(),
-      mode: z.enum(["primary", "subagent"]).optional(),
-      "required-args": z.array(PromptArgSchema).optional(),
-      "optional-args": z.array(PromptArgSchema).optional(),
-      "auto-identity": AutoIdentitySchema.optional()
-    });
+// src/commands/wizard/utils.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+import * as os2 from "os";
+import { stringify } from "yaml";
+function getOpenCodeConfigPath() {
+  return path8.join(os2.homedir(), ".config", "opencode", "opencode.json");
+}
+function copyPromptsToDir(prompts, targetDir, extension) {
+  for (const prompt of prompts) {
+    const baseName = path8.basename(prompt.filePath, ".md");
+    const targetName = baseName + extension;
+    const targetPath = path8.join(targetDir, targetName);
+    const content = fs7.readFileSync(prompt.filePath, "utf-8");
+    fs7.writeFileSync(targetPath, content);
+  }
+}
+function updateOpenCodeConfig(newAgents) {
+  const opencodePath = path8.join(os2.homedir(), ".config", "opencode", "opencode.json");
+  if (!fs7.existsSync(opencodePath)) {
+    return;
   }
-});
-
-// src/lib/prompts.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-function parsePromptFile(filePath) {
   try {
-    const fileContent = fs6.readFileSync(filePath, "utf-8");
-    const { data, content } = matter(fileContent);
-    const parsed = PromptFrontmatterSchema.safeParse(data);
-    if (!parsed.success) {
-      console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
-      return null;
+    const config = JSON.parse(fs7.readFileSync(opencodePath, "utf8"));
+    if (!config.agents) {
+      config.agents = {};
     }
-    return {
-      frontmatter: parsed.data,
-      content: content.trim(),
-      filePath
-    };
-  } catch (error) {
-    console.error(`Error reading prompt file ${filePath}:`, error);
-    return null;
+    const existingAgentKeys = Object.keys(config.agents);
+    const rrceKeys = existingAgentKeys.filter((key) => key.startsWith("rrce_"));
+    for (const key of rrceKeys) {
+      if (!newAgents[key]) {
+        delete config.agents[key];
+      }
+    }
+    for (const [key, value] of Object.entries(newAgents)) {
+      if (key.startsWith("rrce_")) {
+        config.agents[key] = value;
+      }
+    }
+    fs7.writeFileSync(opencodePath, JSON.stringify(config, null, 2));
+  } catch (e) {
+    console.error("Failed to update OpenCode config:", e);
   }
 }
-function loadPromptsFromDir(dirPath) {
-  if (!fs6.existsSync(dirPath)) {
-    return [];
+function convertToOpenCodeAgent(prompt, useFileReference = false, promptFilePath) {
+  const { frontmatter, content } = prompt;
+  const tools = {};
+  const hostTools = ["read", "write", "edit", "bash", "grep", "glob", "webfetch", "terminalLastCommand", "task"];
+  if (frontmatter.tools) {
+    for (const tool of frontmatter.tools) {
+      if (hostTools.includes(tool)) {
+        tools[tool] = true;
+      } else {
+        tools[`rrce_${tool}`] = true;
+      }
+    }
   }
-  const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
-  const prompts = [];
-  for (const file of files) {
-    const prompt = parsePromptFile(path7.join(dirPath, file));
-    if (prompt) {
-      prompts.push(prompt);
+  tools["webfetch"] = true;
+  const mode = frontmatter.mode || "subagent";
+  const invocationHint = mode === "primary" ? "" : " (Invoke via @rrce_*)";
+  return {
+    description: `${frontmatter.description}${invocationHint}`,
+    mode,
+    prompt: useFileReference && promptFilePath ? `{file:${promptFilePath}}` : content,
+    tools
+  };
+}
+function copyDirRecursive(src, dest) {
+  const entries = fs7.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path8.join(src, entry.name);
+    const destPath = path8.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      ensureDir(destPath);
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs7.copyFileSync(srcPath, destPath);
     }
   }
-  return prompts;
 }
-function getAgentCoreDir() {
-  if (__dirname.includes("/src/") || __dirname.includes("\\src\\")) {
-    if (fs6.existsSync(path7.join(process.cwd(), "agent-core"))) {
-      return path7.join(process.cwd(), "agent-core");
+function clearDirectory(dirPath) {
+  if (!fs7.existsSync(dirPath)) return;
+  const entries = fs7.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      fs7.unlinkSync(path8.join(dirPath, entry.name));
     }
-    return path7.resolve(__dirname, "../..", "agent-core");
   }
-  return path7.join(__dirname, "..", "agent-core");
 }
-function getAgentCorePromptsDir() {
-  return path7.join(getAgentCoreDir(), "prompts");
+function surgicalUpdateOpenCodeAgents(prompts, mode, dataPath) {
+  if (mode === "global") {
+    try {
+      const openCodeConfig = getOpenCodeConfigPath();
+      const promptsDir = path8.join(path8.dirname(openCodeConfig), "prompts");
+      ensureDir(promptsDir);
+      const newAgents = {};
+      for (const prompt of prompts) {
+        const baseName = path8.basename(prompt.filePath, ".md");
+        const agentId = `rrce_${baseName}`;
+        const promptFileName = `rrce-${baseName}.md`;
+        const promptFilePath = path8.join(promptsDir, promptFileName);
+        fs7.writeFileSync(promptFilePath, prompt.content);
+        const agentConfig = convertToOpenCodeAgent(prompt, true, `./prompts/${promptFileName}`);
+        newAgents[agentId] = agentConfig;
+      }
+      updateOpenCodeConfig(newAgents);
+      if (fs7.existsSync(openCodeConfig)) {
+        const config = JSON.parse(fs7.readFileSync(openCodeConfig, "utf8"));
+        if (!config.agents) config.agents = {};
+        if (!config.agents.plan) config.agents.plan = {};
+        config.agents.plan.disable = true;
+        fs7.writeFileSync(openCodeConfig, JSON.stringify(config, null, 2));
+      }
+    } catch (e) {
+      console.error("Failed to update global OpenCode config with agents:", e);
+      throw e;
+    }
+  } else {
+    const opencodeBaseDir = path8.join(dataPath, ".opencode", "agent");
+    ensureDir(opencodeBaseDir);
+    clearDirectory(opencodeBaseDir);
+    for (const prompt of prompts) {
+      const baseName = path8.basename(prompt.filePath, ".md");
+      const agentId = `rrce_${baseName}`;
+      const agentConfig = convertToOpenCodeAgent(prompt);
+      const content = `---
+${stringify({
+        description: agentConfig.description,
+        mode: agentConfig.mode,
+        tools: agentConfig.tools
+      })}---
+${agentConfig.prompt}`;
+      fs7.writeFileSync(path8.join(opencodeBaseDir, `${agentId}.md`), content);
+    }
+  }
 }
-var __filename, __dirname;
-var init_prompts = __esm({
-  "src/lib/prompts.ts"() {
+var init_utils = __esm({
+  "src/commands/wizard/utils.ts"() {
     "use strict";
-    init_prompt();
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path7.dirname(__filename);
+    init_paths();
   }
 });
 
@@ -3872,7 +4015,7 @@ 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 path24 = await import("path");
+  const path25 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -3895,7 +4038,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:
-${path24.join(resolvedPath, "mcp.yaml")}`,
+${path25.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -5364,12 +5507,359 @@ var init_mcp = __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 } from "@clack/prompts";
-import pc13 from "picocolors";
-import * as fs25 from "fs";
-
-// src/lib/git.ts
+// src/commands/wizard/update-flow.ts
+var update_flow_exports = {};
+__export(update_flow_exports, {
+  runSilentUpdate: () => runSilentUpdate,
+  runUpdateFlow: () => runUpdateFlow
+});
+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 { stringify as stringify2, parse } from "yaml";
+function backupFile(filePath) {
+  if (!fs21.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);
+    return backupPath;
+  } catch (e) {
+    console.error(`Failed to backup ${filePath}:`, e);
+    return null;
+  }
+}
+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;
+    }
+  } catch (e) {
+  }
+  return "0.0.0";
+}
+async function performUpdate(workspacePath, workspaceName, currentStorageMode, options = {}) {
+  const agentCoreDir = getAgentCoreDir();
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  const runningVersion = getPackageVersion2();
+  const mode = currentStorageMode || "global";
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
+  const configFilePath = getConfigPath(workspacePath);
+  let currentSyncedVersion;
+  if (fs21.existsSync(configFilePath)) {
+    try {
+      const content = fs21.readFileSync(configFilePath, "utf-8");
+      const config = parse(content);
+      currentSyncedVersion = config.last_synced_version;
+    } catch (e) {
+    }
+  }
+  const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
+  const ideTargets = [];
+  if (fs21.existsSync(configFilePath)) {
+    const configContent = fs21.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");
+  }
+  for (const dataPath of dataPaths) {
+    const dirs = ["templates", "prompts", "docs"];
+    const updatedFiles = [];
+    for (const dir of dirs) {
+      const srcDir = path22.join(agentCoreDir, dir);
+      if (!fs21.existsSync(srcDir)) continue;
+      const syncFiles = (src, rel) => {
+        const entries = fs21.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);
+          if (entry.isDirectory()) {
+            ensureDir(entryDest);
+            syncFiles(entrySrc, entryRel);
+          } else {
+            if (driftReport.modifiedFiles.includes(entryRel)) {
+              backupFile(entryDest);
+            }
+            fs21.copyFileSync(entrySrc, entryDest);
+            updatedFiles.push(entryRel);
+          }
+        }
+      };
+      syncFiles(srcDir, dir);
+    }
+    const manifest = DriftService.generateManifest(dataPath, updatedFiles);
+    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");
+    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) {
+        surgicalUpdateOpenCodeAgents(prompts, mode, primaryDataPath);
+      }
+    }
+    try {
+      const yaml = parse(configContent);
+      yaml.last_synced_version = runningVersion;
+      fs21.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)) {
+    try {
+      const content = fs21.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));
+        }
+      }
+    } catch (e) {
+      console.error("Failed to update mcp.yaml version:", e);
+    }
+  }
+  return {
+    success: true,
+    ideTargets,
+    modifiedFiles: driftReport.modifiedFiles
+  };
+}
+async function runSilentUpdate(workspacePath, workspaceName, currentStorageMode) {
+  const s = spinner2();
+  s.start("Applying updates...");
+  try {
+    await performUpdate(workspacePath, workspaceName, currentStorageMode, { silent: true });
+    s.stop("Updates applied");
+  } catch (error) {
+    s.stop("Update failed");
+    throw error;
+  }
+}
+async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
+  const s = spinner2();
+  s.start("Checking for updates");
+  try {
+    const agentCoreDir = getAgentCoreDir();
+    const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+    const runningVersion = getPackageVersion2();
+    const mode = currentStorageMode || "global";
+    const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+    const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
+    const configFilePath = getConfigPath(workspacePath);
+    let currentSyncedVersion;
+    if (fs21.existsSync(configFilePath)) {
+      try {
+        const content = fs21.readFileSync(configFilePath, "utf-8");
+        const config = parse(content);
+        currentSyncedVersion = config.last_synced_version;
+      } catch (e) {
+      }
+    }
+    const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
+    s.stop("Updates found");
+    if (driftReport.type === "version") {
+      note6(`New version available: ${pc8.green(runningVersion)} (Current synced: ${pc8.dim(currentSyncedVersion || "None")})`, "Update Available");
+    }
+    if (driftReport.modifiedFiles.length > 0) {
+      note6(
+        pc8.yellow(`The following files have been modified and will be backed up before updating:
+`) + driftReport.modifiedFiles.map((f) => `  \u2022 ${f}`).join("\n"),
+        "Modifications Detected"
+      );
+    }
+    const updateTargets = [
+      `  \u2022 prompts/ (${prompts.length} agent prompts)`,
+      `  \u2022 templates/ (output templates)`,
+      `  \u2022 docs/ (documentation)`
+    ];
+    const ideTargets = [];
+    if (fs21.existsSync(configFilePath)) {
+      const configContent = fs21.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(", ")}`);
+    }
+    note6(
+      `The following will be updated from the package:
+${updateTargets.join("\n")}
+
+Target locations:
+${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
+      "Update Preview"
+    );
+    const shouldUpdate = await confirm5({
+      message: "Proceed with update?",
+      initialValue: true
+    });
+    if (isCancel7(shouldUpdate) || !shouldUpdate) {
+      outro2("Update cancelled.");
+      return;
+    }
+    s.start("Updating from package");
+    for (const dataPath of dataPaths) {
+      const dirs = ["templates", "prompts", "docs"];
+      const updatedFiles = [];
+      for (const dir of dirs) {
+        const srcDir = path22.join(agentCoreDir, dir);
+        if (!fs21.existsSync(srcDir)) continue;
+        const syncFiles = (src, rel) => {
+          const entries = fs21.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);
+            if (entry.isDirectory()) {
+              ensureDir(entryDest);
+              syncFiles(entrySrc, entryRel);
+            } else {
+              if (driftReport.modifiedFiles.includes(entryRel)) {
+                backupFile(entryDest);
+              }
+              fs21.copyFileSync(entrySrc, entryDest);
+              updatedFiles.push(entryRel);
+            }
+          }
+        };
+        syncFiles(srcDir, dir);
+      }
+      const manifest = DriftService.generateManifest(dataPath, updatedFiles);
+      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");
+      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) {
+          surgicalUpdateOpenCodeAgents(prompts, mode, primaryDataPath);
+        }
+      }
+      try {
+        const yaml = parse(configContent);
+        yaml.last_synced_version = runningVersion;
+        fs21.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)) {
+      try {
+        const content = fs21.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));
+          }
+        }
+      } catch (e) {
+        console.error("Failed to update mcp.yaml version:", e);
+      }
+    }
+    s.stop("Update complete");
+    const summary = [
+      `Updated:`,
+      `  \u2713 ${prompts.length} agent prompts`,
+      `  \u2713 Output templates`,
+      `  \u2713 Documentation`
+    ];
+    if (ideTargets.length > 0) {
+      summary.push(`  \u2713 IDE integrations: ${ideTargets.join(", ")}`);
+    }
+    if (driftReport.modifiedFiles.length > 0) {
+      summary.push(`  \u2713 ${driftReport.modifiedFiles.length} modified files backed up`);
+    }
+    summary.push(
+      ``,
+      `Your configuration and knowledge files were preserved.`,
+      ``,
+      pc8.dim(`\u{1F4A1} If using OpenCode, you may need to reload for changes to take effect.`)
+    );
+    note6(summary.join("\n"), "Update Summary");
+    outro2(pc8.green("\u2713 Successfully updated from package!"));
+  } catch (error) {
+    s.stop("Error occurred");
+    cancel2(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
+  const globalPath = path22.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path22.join(workspaceRoot, ".rrce-workflow");
+  switch (mode) {
+    case "global":
+      return [globalPath];
+    case "workspace":
+      return [workspacePath];
+    default:
+      return [globalPath];
+  }
+}
+var init_update_flow = __esm({
+  "src/commands/wizard/update-flow.ts"() {
+    "use strict";
+    init_paths();
+    init_prompts();
+    init_utils();
+    init_drift_service();
+  }
+});
+
+// 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 { parse as parse2 } from "yaml";
+
+// src/lib/git.ts
 import { execSync } from "child_process";
 function getGitUser() {
   try {
@@ -5383,13 +5873,15 @@ function getGitUser() {
 // src/commands/wizard/index.ts
 init_paths();
 init_detection_service();
+init_prompts();
 
 // src/commands/wizard/setup-flow.ts
-import { spinner as spinner2, note as note6, outro as outro2, cancel as cancel2, isCancel as isCancel7, confirm as confirm5, select as select3 } from "@clack/prompts";
-import pc8 from "picocolors";
+import { spinner as spinner3, note as note7, outro as outro3, cancel as cancel3, isCancel as isCancel8, confirm as confirm6, select as select3 } from "@clack/prompts";
+import pc9 from "picocolors";
 init_detection();
 init_tui_utils();
 init_install();
+init_paths();
 
 // src/commands/wizard/setup-prompts.ts
 init_install();
@@ -5505,108 +5997,29 @@ async function promptConfirmation() {
 // src/commands/wizard/setup-actions.ts
 init_paths();
 init_prompts();
+init_utils();
 import * as fs10 from "fs";
 import * as path12 from "path";
 import pc4 from "picocolors";
 import { note as note2 } from "@clack/prompts";
-import { stringify as stringify2 } from "yaml";
 
-// src/commands/wizard/utils.ts
+// src/commands/wizard/vscode.ts
 init_paths();
-import * as fs7 from "fs";
-import * as path8 from "path";
-import * as os2 from "os";
-import "yaml";
-function copyPromptsToDir(prompts, targetDir, extension) {
-  for (const prompt of prompts) {
-    const baseName = path8.basename(prompt.filePath, ".md");
-    const targetName = baseName + extension;
-    const targetPath = path8.join(targetDir, targetName);
-    const content = fs7.readFileSync(prompt.filePath, "utf-8");
-    fs7.writeFileSync(targetPath, content);
-  }
-}
-function updateOpenCodeConfig(newAgents) {
-  const opencodePath = path8.join(os2.homedir(), ".config", "opencode", "opencode.json");
-  if (!fs7.existsSync(opencodePath)) {
-    return;
-  }
-  try {
-    const config = JSON.parse(fs7.readFileSync(opencodePath, "utf8"));
-    if (!config.agents) {
-      config.agents = {};
-    }
-    const existingAgentKeys = Object.keys(config.agents);
-    const rrceKeys = existingAgentKeys.filter((key) => key.startsWith("rrce_"));
-    for (const key of rrceKeys) {
-      if (!newAgents[key]) {
-        delete config.agents[key];
-      }
-    }
-    for (const [key, value] of Object.entries(newAgents)) {
-      if (key.startsWith("rrce_")) {
-        config.agents[key] = value;
-      }
-    }
-    fs7.writeFileSync(opencodePath, JSON.stringify(config, null, 2));
-  } catch (e) {
-    console.error("Failed to update OpenCode config:", e);
-  }
-}
-function convertToOpenCodeAgent(prompt, useFileReference = false, promptFilePath) {
-  const { frontmatter, content } = prompt;
-  const tools = {};
-  const hostTools = ["read", "write", "edit", "bash", "grep", "glob", "webfetch", "terminalLastCommand", "task"];
-  if (frontmatter.tools) {
-    for (const tool of frontmatter.tools) {
-      if (hostTools.includes(tool)) {
-        tools[tool] = true;
-      } else {
-        tools[`rrce_${tool}`] = true;
-      }
-    }
-  }
-  tools["webfetch"] = true;
-  const mode = frontmatter.mode || "subagent";
-  const invocationHint = mode === "primary" ? "" : " (Invoke via @rrce_*)";
-  return {
-    description: `${frontmatter.description}${invocationHint}`,
-    mode,
-    prompt: useFileReference && promptFilePath ? `{file:${promptFilePath}}` : content,
-    tools
-  };
-}
-function copyDirRecursive(src, dest) {
-  const entries = fs7.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path8.join(src, entry.name);
-    const destPath = path8.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs7.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-// src/commands/wizard/vscode.ts
-init_paths();
-init_detection();
-import * as fs8 from "fs";
-import * as path9 from "path";
-function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
-  const workspaceFilePath = path9.join(workspacePath, `${workspaceName}.code-workspace`);
-  let workspace;
-  if (fs8.existsSync(workspaceFilePath)) {
-    try {
-      const content = fs8.readFileSync(workspaceFilePath, "utf-8");
-      workspace = JSON.parse(content);
-    } catch {
-      workspace = { folders: [], settings: {} };
-    }
-  } else {
-    workspace = { folders: [], settings: {} };
+init_detection();
+import * as fs8 from "fs";
+import * as path9 from "path";
+function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
+  const workspaceFilePath = path9.join(workspacePath, `${workspaceName}.code-workspace`);
+  let workspace;
+  if (fs8.existsSync(workspaceFilePath)) {
+    try {
+      const content = fs8.readFileSync(workspaceFilePath, "utf-8");
+      workspace = JSON.parse(content);
+    } catch {
+      workspace = { folders: [], settings: {} };
+    }
+  } else {
+    workspace = { folders: [], settings: {} };
   }
   if (!workspace.settings) {
     workspace.settings = {};
@@ -5677,6 +6090,46 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
 
 // src/commands/wizard/setup-actions.ts
 init_install();
+function detectExistingProject(workspacePath, workspaceName, globalPath) {
+  const rrceHome = globalPath || getDefaultRRCEHome2();
+  const globalConfigPath = path12.join(rrceHome, "workspaces", workspaceName, "config.yaml");
+  const workspaceConfigPath = path12.join(workspacePath, ".rrce-workflow", "config.yaml");
+  const hasOpenCodeAgents = checkForRRCEAgents();
+  if (fs10.existsSync(globalConfigPath)) {
+    return {
+      isExisting: true,
+      currentMode: "global",
+      configPath: globalConfigPath
+    };
+  } else if (fs10.existsSync(workspaceConfigPath)) {
+    return {
+      isExisting: true,
+      currentMode: "workspace",
+      configPath: workspaceConfigPath
+    };
+  } else if (hasOpenCodeAgents) {
+    return {
+      isExisting: true,
+      currentMode: null,
+      configPath: null
+    };
+  }
+  return {
+    isExisting: false,
+    currentMode: null,
+    configPath: null
+  };
+}
+function checkForRRCEAgents() {
+  if (!fs10.existsSync(OPENCODE_CONFIG)) return false;
+  try {
+    const config = JSON.parse(fs10.readFileSync(OPENCODE_CONFIG, "utf8"));
+    const agentKeys = Object.keys(config.agent || config.agents || {});
+    return agentKeys.some((key) => key.startsWith("rrce_"));
+  } catch {
+    return false;
+  }
+}
 function createDirectoryStructure(dataPaths) {
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
@@ -5715,48 +6168,7 @@ async function installAgentPrompts(config, workspacePath, dataPaths) {
     if (config.tools.includes("opencode")) {
       const primaryDataPath = dataPaths[0];
       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"));
-            }
-            if (!opencodeConfig.agent) opencodeConfig.agent = {};
-            for (const prompt of prompts) {
-              const baseName = path12.basename(prompt.filePath, ".md");
-              const agentId = `rrce_${baseName}`;
-              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[agentId] = agentConfig;
-            }
-            if (!opencodeConfig.agent) opencodeConfig.agent = {};
-            if (!opencodeConfig.agent.plan) opencodeConfig.agent.plan = {};
-            opencodeConfig.agent.plan.disable = true;
-            fs10.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 = path12.join(primaryDataPath, ".opencode", "agent");
-          ensureDir(opencodeBaseDir);
-          for (const prompt of prompts) {
-            const baseName = path12.basename(prompt.filePath, ".md");
-            const agentId = `rrce_${baseName}`;
-            const agentConfig = convertToOpenCodeAgent(prompt);
-            const content = `---
-${stringify2({
-              description: agentConfig.description,
-              mode: agentConfig.mode,
-              tools: agentConfig.tools
-            })}---
-${agentConfig.prompt}`;
-            fs10.writeFileSync(path12.join(opencodeBaseDir, `${agentId}.md`), content);
-          }
-        }
+        surgicalUpdateOpenCodeAgents(prompts, config.storageMode, primaryDataPath);
       }
     }
   }
@@ -5882,8 +6294,8 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
     ],
     initialValue: "global"
   });
-  if (isCancel7(storageModeResult)) {
-    cancel2("Setup cancelled.");
+  if (isCancel8(storageModeResult)) {
+    cancel3("Setup cancelled.");
     process.exit(0);
   }
   const storageMode = storageModeResult;
@@ -5891,7 +6303,7 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
   if (storageMode === "global") {
     customGlobalPath = await resolveGlobalPath();
     if (!customGlobalPath) {
-      cancel2("Setup cancelled - no global path selected.");
+      cancel3("Setup cancelled - no global path selected.");
       process.exit(0);
     }
   }
@@ -5900,8 +6312,8 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
   if (isVSCodeInstalled()) toolsPreview.push("GitHub Copilot");
   if (isAntigravityInstalled()) toolsPreview.push("Antigravity");
   const toolsText = toolsPreview.length > 0 ? toolsPreview.join(", ") : "None detected";
-  note6(
-    `${pc8.bold("Express Setup will configure:")}
+  note7(
+    `${pc9.bold("Express Setup will configure:")}
 \u2022 Storage: ${storageMode === "global" ? "Global" : "Workspace"}
 \u2022 MCP Server: Enabled
 \u2022 Semantic Search (RAG): Enabled
@@ -5909,12 +6321,12 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
 ` : "") + `\u2022 AI Tools: ${toolsText}`,
     "Configuration Preview"
   );
-  const confirmed = await confirm5({
+  const confirmed = await confirm6({
     message: "Proceed with express setup?",
     initialValue: true
   });
-  if (isCancel7(confirmed) || !confirmed) {
-    cancel2("Setup cancelled.");
+  if (isCancel8(confirmed) || !confirmed) {
+    cancel3("Setup cancelled.");
     process.exit(0);
   }
   const defaultTools = [];
@@ -5935,19 +6347,63 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
     const { updateGitignore: updateGitignore2 } = await Promise.resolve().then(() => (init_gitignore(), gitignore_exports));
     updateGitignore2(workspacePath, config.storageMode, config.tools);
   }
-  const startMCP = await confirm5({
+  const startMCP = await confirm6({
     message: "Start MCP server now?",
     initialValue: true
   });
-  if (startMCP && !isCancel7(startMCP)) {
+  if (startMCP && !isCancel8(startMCP)) {
     const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
     await runMCP2();
   } else {
-    outro2(pc8.green(`\u2713 Express setup complete! Run ${pc8.cyan("npx rrce-workflow mcp")} to start the server.`));
+    outro3(pc9.green(`\u2713 Express setup complete! Run ${pc9.cyan("npx rrce-workflow mcp")} to start the server.`));
+  }
+}
+async function runSetupAsUpdate(workspacePath, workspaceName, currentMode) {
+  let mode = currentMode;
+  if (!mode) {
+    const modeResult = await select3({
+      message: "Storage mode not detected. Please confirm:",
+      options: [
+        { value: "global", label: "Global (~/.rrce-workflow/)" },
+        { value: "workspace", label: "Workspace (.rrce-workflow/)" }
+      ],
+      initialValue: "global"
+    });
+    if (isCancel8(modeResult)) {
+      cancel3("Setup cancelled.");
+      process.exit(0);
+    }
+    mode = modeResult;
+  }
+  const { runUpdateFlow: runUpdateFlow2 } = await Promise.resolve().then(() => (init_update_flow(), update_flow_exports));
+  await runUpdateFlow2(workspacePath, workspaceName, mode);
+  const startMCP = await confirm6({
+    message: "Start MCP server now?",
+    initialValue: true
+  });
+  if (startMCP && !isCancel8(startMCP)) {
+    const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+    await runMCP2();
+  } else {
+    outro3(pc9.green(`\u2713 Setup complete! Run ${pc9.cyan("npx rrce-workflow mcp")} to start the server.`));
   }
 }
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
-  const s = spinner2();
+  const customGlobalPath = getDefaultRRCEHome2();
+  const existingProjectInfo = detectExistingProject(workspacePath, workspaceName, customGlobalPath);
+  if (existingProjectInfo.isExisting) {
+    note7(
+      `${pc9.cyan("\u2139")} Existing RRCE installation detected.
+Running smart update to sync with latest version.`,
+      "Update Mode"
+    );
+    return runSetupAsUpdate(
+      workspacePath,
+      workspaceName,
+      existingProjectInfo.currentMode
+    );
+  }
+  const s = spinner3();
   const setupModeResult = await select3({
     message: "Setup mode:",
     options: [
@@ -5956,19 +6412,19 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     ],
     initialValue: "express"
   });
-  if (isCancel7(setupModeResult)) {
-    cancel2("Setup cancelled.");
+  if (isCancel8(setupModeResult)) {
+    cancel3("Setup cancelled.");
     process.exit(0);
   }
   if (setupModeResult === "express") {
     return runExpressSetup(workspacePath, workspaceName, existingProjects, s);
   }
   const storageMode = await promptStorageMode();
-  let customGlobalPath;
+  let resolvedGlobalPath;
   if (storageMode === "global") {
-    customGlobalPath = await resolveGlobalPath();
-    if (!customGlobalPath) {
-      cancel2("Setup cancelled - no global path selected.");
+    resolvedGlobalPath = await resolveGlobalPath();
+    if (!resolvedGlobalPath) {
+      cancel3("Setup cancelled - no global path selected.");
       process.exit(0);
     }
   }
@@ -5982,12 +6438,12 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const enableRAG = await promptRAG();
   const confirmed = await promptConfirmation();
   if (!confirmed) {
-    outro2("Setup cancelled by user.");
+    outro3("Setup cancelled by user.");
     process.exit(0);
   }
   const config = {
     storageMode,
-    globalPath: customGlobalPath,
+    globalPath: resolvedGlobalPath,
     tools,
     linkedProjects,
     addToGitignore,
@@ -6016,493 +6472,228 @@ async function executeSetup(config, workspacePath, workspaceName, allProjects, s
     if (needsVSCodeWorkspace) {
       const selectedProjects = allProjects.filter(
         (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
-      );
-      generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
-    }
-    await registerWithMCP(config, workspacePath, workspaceName);
-    const ideResults = installToSelectedIDEs(config.tools);
-    s.stop("Configuration generated");
-    const dataSummary = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
-    const summary = [
-      `${pc8.green("\u2713")} Data stored at: ${pc8.dim(dataSummary[0])}`,
-      config.tools.length > 0 ? `${pc8.green("\u2713")} Tools: ${config.tools.join(", ")}` : null,
-      config.exposeToMCP ? `${pc8.green("\u2713")} MCP server configured` : null,
-      config.enableRAG ? `${pc8.green("\u2713")} Semantic Search enabled` : null,
-      config.linkedProjects.length > 0 ? `${pc8.green("\u2713")} Linked ${config.linkedProjects.length} project(s)` : null,
-      ideResults.success.length > 0 ? `${pc8.green("\u2713")} RRCE installed to: ${ideResults.success.join(", ")}` : null,
-      ideResults.failed.length > 0 ? `${pc8.yellow("\u26A0")} Failed to install to: ${ideResults.failed.join(", ")}` : null
-    ].filter(Boolean);
-    if (ideResults.success.length > 0) {
-      summary.push("");
-      summary.push(pc8.dim("\u{1F4A1} You may need to restart your IDE or refresh MCP config for changes to take effect."));
-    }
-    note6(summary.join("\n"), "Setup Complete");
-  } catch (error) {
-    s.stop("Error occurred");
-    cancel2(
-      `Setup failed: ${error instanceof Error ? error.message : String(error)}
-
-${pc8.dim("Tip: You can re-run the wizard to try again.")}`
-    );
-    process.exit(1);
-  }
-}
-async function handlePostSetup(config, workspacePath, workspaceName, linkedProjects) {
-  if (config.exposeToMCP) {
-    const shouldConfigureMCP = await confirm5({
-      message: "Would you like to start the MCP server now?",
-      initialValue: true
-    });
-    if (shouldConfigureMCP && !isCancel7(shouldConfigureMCP)) {
-      const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-      await runMCP2();
-    } else {
-      if (linkedProjects.length > 0) {
-        outro2(pc8.green(`\u2713 Setup complete! Open ${pc8.bold(`${workspaceName}.code-workspace`)} in VSCode.`));
-      } else {
-        outro2(pc8.green(`\u2713 Setup complete! Run ${pc8.cyan("npx rrce-workflow mcp")} to start the server.`));
-      }
-    }
-  } else {
-    if (linkedProjects.length > 0) {
-      outro2(pc8.green(`\u2713 Setup complete! Open ${pc8.bold(`${workspaceName}.code-workspace`)} in VSCode.`));
-    } else {
-      outro2(pc8.green(`\u2713 Setup complete! Your agents are ready to use.`));
-    }
-  }
-}
-
-// src/commands/wizard/link-flow.ts
-init_paths();
-import { multiselect as multiselect4, spinner as spinner3, note as note7, outro as outro3, cancel as cancel3, isCancel as isCancel8, confirm as confirm6 } from "@clack/prompts";
-import pc9 from "picocolors";
-import * as fs21 from "fs";
-init_detection();
-async function runLinkProjectsFlow(workspacePath, workspaceName) {
-  const projects = scanForProjects({
-    excludeWorkspace: workspaceName,
-    workspacePath
-  });
-  if (projects.length === 0) {
-    outro3(pc9.yellow("No other projects found. Try setting up another project first."));
-    return;
-  }
-  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const linkedProjects = await multiselect4({
-    message: "Select projects to link:",
-    options: projects.map((project) => ({
-      value: `${project.name}:${project.source}`,
-      // Unique key
-      label: `${project.name} ${pc9.dim(`(${project.source})`)}`,
-      hint: pc9.dim(
-        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
-      )
-    })),
-    required: true
-  });
-  if (isCancel8(linkedProjects)) {
-    cancel3("Cancelled.");
-    process.exit(0);
-  }
-  const selectedKeys = linkedProjects;
-  if (selectedKeys.length === 0) {
-    outro3("No projects selected.");
-    return;
-  }
-  const selectedProjects = projects.filter(
-    (p) => selectedKeys.includes(`${p.name}:${p.source}`)
-  );
-  const s = spinner3();
-  s.start("Linking projects");
-  const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs21.readFileSync(configFilePath, "utf-8");
-  if (configContent.includes("linked_projects:")) {
-    const lines = configContent.split("\n");
-    const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
-    if (linkedIndex !== -1) {
-      let insertIndex = linkedIndex + 1;
-      while (insertIndex < lines.length && lines[insertIndex]?.startsWith("  - ")) {
-        insertIndex++;
-      }
-      for (const project of selectedProjects) {
-        const entry = `  - ${project.name}:${project.source}`;
-        if (!configContent.includes(entry)) {
-          lines.splice(insertIndex, 0, entry);
-          insertIndex++;
-        }
-      }
-      configContent = lines.join("\n");
-    }
-  } else {
-    configContent += `
-linked_projects:
-`;
-    selectedProjects.forEach((project) => {
-      configContent += `  - ${project.name}:${project.source}
-`;
-    });
-  }
-  fs21.writeFileSync(configFilePath, configContent);
-  generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
-  s.stop("Projects linked");
-  const workspaceFile = `${workspaceName}.code-workspace`;
-  const summary = [
-    `Linked projects:`,
-    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc9.dim(`(${p.source})`)}`),
-    ``,
-    `Workspace file: ${pc9.cyan(workspaceFile)}`
-  ];
-  note7(summary.join("\n"), "Link Summary");
-  outro3(pc9.green(`\u2713 Projects linked! Open ${pc9.bold(workspaceFile)} in VSCode to access linked data.`));
-  const shouldExpose = await confirm6({
-    message: "Also expose these linked projects to the MCP server (for Agent access)?",
-    initialValue: true
-  });
-  if (shouldExpose && !isCancel8(shouldExpose)) {
-    try {
-      const { loadMCPConfig: loadMCPConfig3, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-      const mcpConfig = loadMCPConfig3();
-      for (const project of selectedProjects) {
-        setProjectConfig2(mcpConfig, project.name, true, void 0, project.dataPath);
-      }
-      saveMCPConfig2(mcpConfig);
-      note7("Projects have been added to the global MCP configuration.", "MCP Updated");
-    } catch (err) {
-      note7(`Failed to update MCP config: ${err}`, "MCP Update Failed");
-    }
-  }
-}
-
-// src/commands/wizard/sync-flow.ts
-init_paths();
-import { confirm as confirm7, spinner as spinner4, note as note8, outro as outro4, cancel as cancel4, isCancel as isCancel9 } from "@clack/prompts";
-import pc10 from "picocolors";
-import * as fs22 from "fs";
-import * as path22 from "path";
-async function runSyncToGlobalFlow(workspacePath, workspaceName) {
-  const localPath = getLocalWorkspacePath(workspacePath);
-  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path22.join(customGlobalPath, "workspaces", workspaceName);
-  const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
-  const existingDirs = subdirs.filter(
-    (dir) => fs22.existsSync(path22.join(localPath, dir))
-  );
-  if (existingDirs.length === 0) {
-    outro4(pc10.yellow("No data found in workspace storage to sync."));
-    return;
-  }
-  note8(
-    `The following will be copied to global storage:
-${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
-
-Destination: ${pc10.cyan(globalPath)}`,
-    "Sync Preview"
-  );
-  const shouldSync = await confirm7({
-    message: "Proceed with sync to global storage?",
-    initialValue: true
-  });
-  if (isCancel9(shouldSync) || !shouldSync) {
-    outro4("Sync cancelled.");
-    return;
-  }
-  const s = spinner4();
-  s.start("Syncing to global storage");
-  try {
-    ensureDir(globalPath);
-    for (const dir of existingDirs) {
-      const srcDir = path22.join(localPath, dir);
-      const destDir = path22.join(globalPath, dir);
-      ensureDir(destDir);
-      copyDirRecursive(srcDir, destDir);
-    }
-    s.stop("Sync complete");
-    const summary = [
-      `Synced directories:`,
-      ...existingDirs.map((d) => `  \u2713 ${d}/`),
-      ``,
-      `Global path: ${pc10.cyan(globalPath)}`,
-      ``,
-      `Other projects can now link this knowledge!`
-    ];
-    note8(summary.join("\n"), "Sync Summary");
-    outro4(pc10.green("\u2713 Workspace knowledge synced to global storage!"));
-  } catch (error) {
-    s.stop("Error occurred");
-    cancel4(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
-}
-
-// src/commands/wizard/update-flow.ts
-init_paths();
-init_prompts();
-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 { stringify as stringify3, parse } from "yaml";
-init_install();
-init_drift_service();
-function backupFile(filePath) {
-  if (!fs23.existsSync(filePath)) return null;
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
-  const backupPath = `${filePath}.${timestamp}.bak`;
-  try {
-    fs23.copyFileSync(filePath, backupPath);
-    return backupPath;
-  } catch (e) {
-    console.error(`Failed to backup ${filePath}:`, e);
-    return null;
-  }
-}
-function getPackageVersion2() {
-  try {
-    const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path23.join(path23.dirname(agentCoreDir), "package.json");
-    if (fs23.existsSync(packageJsonPath)) {
-      return JSON.parse(fs23.readFileSync(packageJsonPath, "utf8")).version;
-    }
-  } catch (e) {
-  }
-  return "0.0.0";
-}
-async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
-  const s = spinner5();
-  s.start("Checking for updates");
-  try {
-    const agentCoreDir = getAgentCoreDir();
-    const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-    const runningVersion = getPackageVersion2();
-    const mode = currentStorageMode || "global";
-    const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-    const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
-    const configFilePath = getConfigPath(workspacePath);
-    let currentSyncedVersion;
-    if (fs23.existsSync(configFilePath)) {
-      try {
-        const content = fs23.readFileSync(configFilePath, "utf-8");
-        const config = parse(content);
-        currentSyncedVersion = config.last_synced_version;
-      } catch (e) {
-      }
-    }
-    const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
-    s.stop("Updates found");
-    if (driftReport.type === "version") {
-      note9(`New version available: ${pc11.green(runningVersion)} (Current synced: ${pc11.dim(currentSyncedVersion || "None")})`, "Update Available");
-    }
-    if (driftReport.modifiedFiles.length > 0) {
-      note9(
-        pc11.yellow(`The following files have been modified and will be backed up before updating:
-`) + driftReport.modifiedFiles.map((f) => `  \u2022 ${f}`).join("\n"),
-        "Modifications Detected"
-      );
-    }
-    const updateTargets = [
-      `  \u2022 prompts/ (${prompts.length} agent prompts)`,
-      `  \u2022 templates/ (output templates)`,
-      `  \u2022 docs/ (documentation)`
-    ];
-    const ideTargets = [];
-    if (fs23.existsSync(configFilePath)) {
-      const configContent = fs23.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(", ")}`);
-    }
-    note9(
-      `The following will be updated from the package:
-${updateTargets.join("\n")}
-
-Target locations:
-${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
-      "Update Preview"
-    );
-    const shouldUpdate = await confirm8({
-      message: "Proceed with update?",
-      initialValue: true
-    });
-    if (isCancel10(shouldUpdate) || !shouldUpdate) {
-      outro5("Update cancelled.");
-      return;
-    }
-    s.start("Updating from package");
-    for (const dataPath of dataPaths) {
-      const dirs = ["templates", "prompts", "docs"];
-      const updatedFiles = [];
-      for (const dir of dirs) {
-        const srcDir = path23.join(agentCoreDir, dir);
-        if (!fs23.existsSync(srcDir)) continue;
-        const syncFiles = (src, rel) => {
-          const entries = fs23.readdirSync(src, { withFileTypes: true });
-          for (const entry of entries) {
-            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);
-            } else {
-              if (driftReport.modifiedFiles.includes(entryRel)) {
-                backupFile(entryDest);
-              }
-              fs23.copyFileSync(entrySrc, entryDest);
-              updatedFiles.push(entryRel);
-            }
-          }
-        };
-        syncFiles(srcDir, dir);
-      }
-      const manifest = DriftService.generateManifest(dataPath, updatedFiles);
-      DriftService.saveManifest(dataPath, manifest);
-    }
-    const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-    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 (fs23.existsSync(configFilePath)) {
-      const configContent = fs23.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);
-        }
-      }
-      try {
-        const yaml = parse(configContent);
-        yaml.last_synced_version = runningVersion;
-        fs23.writeFileSync(configFilePath, stringify3(yaml));
-      } catch (e) {
-        console.error("Failed to update config.yaml version:", e);
-      }
-    }
-    const mcpPath = path23.join(rrceHome, "mcp.yaml");
-    if (fs23.existsSync(mcpPath)) {
-      try {
-        const content = fs23.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;
-            fs23.writeFileSync(mcpPath, stringify3(yaml));
-          }
-        }
-      } catch (e) {
-        console.error("Failed to update mcp.yaml version:", e);
-      }
-    }
-    s.stop("Update complete");
-    const summary = [
-      `Updated:`,
-      `  \u2713 ${prompts.length} agent prompts`,
-      `  \u2713 Output templates`,
-      `  \u2713 Documentation`
-    ];
-    if (ideTargets.length > 0) {
-      summary.push(`  \u2713 IDE integrations: ${ideTargets.join(", ")}`);
+      );
+      generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
     }
-    if (driftReport.modifiedFiles.length > 0) {
-      summary.push(`  \u2713 ${driftReport.modifiedFiles.length} modified files backed up`);
+    await registerWithMCP(config, workspacePath, workspaceName);
+    const ideResults = installToSelectedIDEs(config.tools);
+    s.stop("Configuration generated");
+    const dataSummary = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
+    const summary = [
+      `${pc9.green("\u2713")} Data stored at: ${pc9.dim(dataSummary[0])}`,
+      config.tools.length > 0 ? `${pc9.green("\u2713")} Tools: ${config.tools.join(", ")}` : null,
+      config.exposeToMCP ? `${pc9.green("\u2713")} MCP server configured` : null,
+      config.enableRAG ? `${pc9.green("\u2713")} Semantic Search enabled` : null,
+      config.linkedProjects.length > 0 ? `${pc9.green("\u2713")} Linked ${config.linkedProjects.length} project(s)` : null,
+      ideResults.success.length > 0 ? `${pc9.green("\u2713")} RRCE installed to: ${ideResults.success.join(", ")}` : null,
+      ideResults.failed.length > 0 ? `${pc9.yellow("\u26A0")} Failed to install to: ${ideResults.failed.join(", ")}` : null
+    ].filter(Boolean);
+    if (ideResults.success.length > 0) {
+      summary.push("");
+      summary.push(pc9.dim("\u{1F4A1} You may need to restart your IDE or refresh MCP config for changes to take effect."));
     }
-    summary.push(
-      ``,
-      `Your configuration and knowledge files were preserved.`,
-      ``,
-      pc11.dim(`\u{1F4A1} If using OpenCode, you may need to reload for changes to take effect.`)
-    );
-    note9(summary.join("\n"), "Update Summary");
-    outro5(pc11.green("\u2713 Successfully updated from package!"));
+    note7(summary.join("\n"), "Setup Complete");
   } catch (error) {
     s.stop("Error occurred");
-    cancel5(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
+    cancel3(
+      `Setup failed: ${error instanceof Error ? error.message : String(error)}
+
+${pc9.dim("Tip: You can re-run the wizard to try again.")}`
+    );
     process.exit(1);
   }
 }
-function updateOpenCodeAgents(prompts, mode, primaryDataPath) {
-  if (mode === "global") {
-    try {
-      const promptsDir = path23.join(path23.dirname(OPENCODE_CONFIG), "prompts");
-      ensureDir(promptsDir);
-      const newAgents = {};
-      for (const prompt of prompts) {
-        const baseName = path23.basename(prompt.filePath, ".md");
-        const agentId = `rrce_${baseName}`;
-        const promptFileName = `rrce-${baseName}.md`;
-        const promptFilePath = path23.join(promptsDir, promptFileName);
-        fs23.writeFileSync(promptFilePath, prompt.content);
-        const agentConfig = convertToOpenCodeAgent(prompt, true, `./prompts/${promptFileName}`);
-        newAgents[agentId] = agentConfig;
-      }
-      updateOpenCodeConfig(newAgents);
-      if (fs23.existsSync(OPENCODE_CONFIG)) {
-        const config = JSON.parse(fs23.readFileSync(OPENCODE_CONFIG, "utf8"));
-        if (!config.agents) config.agents = {};
-        if (!config.agents.plan) config.agents.plan = {};
-        config.agents.plan.disable = true;
-        fs23.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2));
+async function handlePostSetup(config, workspacePath, workspaceName, linkedProjects) {
+  if (config.exposeToMCP) {
+    const shouldConfigureMCP = await confirm6({
+      message: "Would you like to start the MCP server now?",
+      initialValue: true
+    });
+    if (shouldConfigureMCP && !isCancel8(shouldConfigureMCP)) {
+      const { runMCP: runMCP2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      await runMCP2();
+    } else {
+      if (linkedProjects.length > 0) {
+        outro3(pc9.green(`\u2713 Setup complete! Open ${pc9.bold(`${workspaceName}.code-workspace`)} in VSCode.`));
+      } else {
+        outro3(pc9.green(`\u2713 Setup complete! Run ${pc9.cyan("npx rrce-workflow mcp")} to start the server.`));
       }
-    } catch (e) {
-      console.error("Failed to update global OpenCode config with agents:", e);
     }
   } else {
-    const opencodeBaseDir = path23.join(primaryDataPath, ".opencode", "agent");
-    ensureDir(opencodeBaseDir);
-    clearDirectory(opencodeBaseDir);
-    for (const prompt of prompts) {
-      const baseName = path23.basename(prompt.filePath, ".md");
-      const agentId = `rrce_${baseName}`;
-      const agentConfig = convertToOpenCodeAgent(prompt);
-      const content = `---
-${stringify3({
-        description: agentConfig.description,
-        mode: agentConfig.mode,
-        tools: agentConfig.tools
-      })}---
-${agentConfig.prompt}`;
-      fs23.writeFileSync(path23.join(opencodeBaseDir, `${agentId}.md`), content);
+    if (linkedProjects.length > 0) {
+      outro3(pc9.green(`\u2713 Setup complete! Open ${pc9.bold(`${workspaceName}.code-workspace`)} in VSCode.`));
+    } else {
+      outro3(pc9.green(`\u2713 Setup complete! Your agents are ready to use.`));
     }
   }
 }
-function clearDirectory(dirPath) {
-  if (!fs23.existsSync(dirPath)) return;
-  const entries = fs23.readdirSync(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isFile()) {
-      fs23.unlinkSync(path23.join(dirPath, entry.name));
+
+// src/commands/wizard/link-flow.ts
+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";
+init_detection();
+async function runLinkProjectsFlow(workspacePath, workspaceName) {
+  const projects = scanForProjects({
+    excludeWorkspace: workspaceName,
+    workspacePath
+  });
+  if (projects.length === 0) {
+    outro4(pc10.yellow("No other projects found. Try setting up another project first."));
+    return;
+  }
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const linkedProjects = await multiselect4({
+    message: "Select projects to link:",
+    options: projects.map((project) => ({
+      value: `${project.name}:${project.source}`,
+      // Unique key
+      label: `${project.name} ${pc10.dim(`(${project.source})`)}`,
+      hint: pc10.dim(
+        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
+      )
+    })),
+    required: true
+  });
+  if (isCancel9(linkedProjects)) {
+    cancel4("Cancelled.");
+    process.exit(0);
+  }
+  const selectedKeys = linkedProjects;
+  if (selectedKeys.length === 0) {
+    outro4("No projects selected.");
+    return;
+  }
+  const selectedProjects = projects.filter(
+    (p) => selectedKeys.includes(`${p.name}:${p.source}`)
+  );
+  const s = spinner4();
+  s.start("Linking projects");
+  const configFilePath = getConfigPath(workspacePath);
+  let configContent = fs22.readFileSync(configFilePath, "utf-8");
+  if (configContent.includes("linked_projects:")) {
+    const lines = configContent.split("\n");
+    const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
+    if (linkedIndex !== -1) {
+      let insertIndex = linkedIndex + 1;
+      while (insertIndex < lines.length && lines[insertIndex]?.startsWith("  - ")) {
+        insertIndex++;
+      }
+      for (const project of selectedProjects) {
+        const entry = `  - ${project.name}:${project.source}`;
+        if (!configContent.includes(entry)) {
+          lines.splice(insertIndex, 0, entry);
+          insertIndex++;
+        }
+      }
+      configContent = lines.join("\n");
+    }
+  } else {
+    configContent += `
+linked_projects:
+`;
+    selectedProjects.forEach((project) => {
+      configContent += `  - ${project.name}:${project.source}
+`;
+    });
+  }
+  fs22.writeFileSync(configFilePath, configContent);
+  generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
+  s.stop("Projects linked");
+  const workspaceFile = `${workspaceName}.code-workspace`;
+  const summary = [
+    `Linked projects:`,
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc10.dim(`(${p.source})`)}`),
+    ``,
+    `Workspace file: ${pc10.cyan(workspaceFile)}`
+  ];
+  note8(summary.join("\n"), "Link Summary");
+  outro4(pc10.green(`\u2713 Projects linked! Open ${pc10.bold(workspaceFile)} in VSCode to access linked data.`));
+  const shouldExpose = await confirm7({
+    message: "Also expose these linked projects to the MCP server (for Agent access)?",
+    initialValue: true
+  });
+  if (shouldExpose && !isCancel9(shouldExpose)) {
+    try {
+      const { loadMCPConfig: loadMCPConfig3, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      const mcpConfig = loadMCPConfig3();
+      for (const project of selectedProjects) {
+        setProjectConfig2(mcpConfig, project.name, true, void 0, project.dataPath);
+      }
+      saveMCPConfig2(mcpConfig);
+      note8("Projects have been added to the global MCP configuration.", "MCP Updated");
+    } catch (err) {
+      note8(`Failed to update MCP config: ${err}`, "MCP Update Failed");
     }
   }
 }
-function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
+
+// src/commands/wizard/sync-flow.ts
+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";
+async function runSyncToGlobalFlow(workspacePath, workspaceName) {
+  const localPath = getLocalWorkspacePath(workspacePath);
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
   const globalPath = path23.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path23.join(workspaceRoot, ".rrce-workflow");
-  switch (mode) {
-    case "global":
-      return [globalPath];
-    case "workspace":
-      return [workspacePath];
-    default:
-      return [globalPath];
+  const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
+  const existingDirs = subdirs.filter(
+    (dir) => fs23.existsSync(path23.join(localPath, dir))
+  );
+  if (existingDirs.length === 0) {
+    outro5(pc11.yellow("No data found in workspace storage to sync."));
+    return;
+  }
+  note9(
+    `The following will be copied to global storage:
+${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
+
+Destination: ${pc11.cyan(globalPath)}`,
+    "Sync Preview"
+  );
+  const shouldSync = await confirm8({
+    message: "Proceed with sync to global storage?",
+    initialValue: true
+  });
+  if (isCancel10(shouldSync) || !shouldSync) {
+    outro5("Sync cancelled.");
+    return;
+  }
+  const s = spinner5();
+  s.start("Syncing to global storage");
+  try {
+    ensureDir(globalPath);
+    for (const dir of existingDirs) {
+      const srcDir = path23.join(localPath, dir);
+      const destDir = path23.join(globalPath, dir);
+      ensureDir(destDir);
+      copyDirRecursive(srcDir, destDir);
+    }
+    s.stop("Sync complete");
+    const summary = [
+      `Synced directories:`,
+      ...existingDirs.map((d) => `  \u2713 ${d}/`),
+      ``,
+      `Global path: ${pc11.cyan(globalPath)}`,
+      ``,
+      `Other projects can now link this knowledge!`
+    ];
+    note9(summary.join("\n"), "Sync Summary");
+    outro5(pc11.green("\u2713 Workspace knowledge synced to global storage!"));
+  } catch (error) {
+    s.stop("Error occurred");
+    cancel5(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
   }
 }
 
+// src/commands/wizard/index.ts
+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";
@@ -6570,6 +6761,76 @@ Are you sure?`,
 // src/commands/wizard/index.ts
 init_mcp();
 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;
+    }
+  } catch (e) {
+  }
+  return "0.0.0";
+}
+function getLastSyncedVersion(workspacePath, workspaceName) {
+  const configFilePath = getConfigPath(workspacePath);
+  if (fs25.existsSync(configFilePath)) {
+    try {
+      const content = fs25.readFileSync(configFilePath, "utf-8");
+      const config = parse2(content);
+      if (config.last_synced_version) {
+        return config.last_synced_version;
+      }
+    } catch (e) {
+    }
+  }
+  const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
+  const mcpPath = path24.join(rrceHome, "mcp.yaml");
+  if (fs25.existsSync(mcpPath)) {
+    try {
+      const content = fs25.readFileSync(mcpPath, "utf-8");
+      const config = parse2(content);
+      const project = config.projects?.find((p) => p.name === workspaceName);
+      if (project?.last_synced_version) {
+        return project.last_synced_version;
+      }
+    } catch (e) {
+    }
+  }
+  return void 0;
+}
+async function checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode) {
+  const runningVersion = getPackageVersion3();
+  const lastSyncedVersion = getLastSyncedVersion(workspacePath, workspaceName);
+  if (lastSyncedVersion === runningVersion) {
+    return true;
+  }
+  const versionInfo = lastSyncedVersion ? `${pc13.dim(lastSyncedVersion)} \u2192 ${pc13.green(runningVersion)}` : `${pc13.dim("unknown")} \u2192 ${pc13.green(runningVersion)}`;
+  note11(
+    `${pc13.bold(pc13.cyan("Update available!"))} ${versionInfo}
+
+New prompts, templates, and agent improvements are ready to install.
+Your custom knowledge and configuration will be preserved.`,
+    "\u{1F4E6} Version Update"
+  );
+  const shouldUpdate = await confirm10({
+    message: "Apply update now?",
+    initialValue: true
+  });
+  if (isCancel12(shouldUpdate)) {
+    return false;
+  }
+  if (shouldUpdate) {
+    await runSilentUpdate(workspacePath, workspaceName, currentStorageMode);
+    note11(
+      `${pc13.green("\u2713")} Updated to version ${pc13.bold(runningVersion)}
+
+All agent prompts, templates, and IDE integrations have been synced.`,
+      "Update Complete"
+    );
+  }
+  return true;
+}
 async function runWizard() {
   intro2(pc13.cyan(pc13.inverse(" RRCE-Workflow Setup ")));
   const s = spinner7();
@@ -6620,24 +6881,22 @@ Workspace: ${pc13.bold(workspaceName)}`,
   const localDataPath = getLocalWorkspacePath(workspacePath);
   const hasLocalData = fs25.existsSync(localDataPath);
   if (isAlreadyConfigured) {
+    const continueToMenu = await checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode);
+    if (!continueToMenu) {
+      outro7("Exited.");
+      process.exit(0);
+    }
     const menuOptions = [];
     menuOptions.push({
       value: "mcp",
-      label: "\u{1F50C} Configure MCP Server",
-      hint: "Expose projects to AI assistants (VSCode, Antigravity, Claude)"
+      label: "\u{1F50C} MCP Dashboard",
+      hint: "Manage projects & AI integrations"
     });
-    if (detectedProjects.some((p) => p.source === "global")) {
-      menuOptions.push({
-        value: "delete-global",
-        label: "\u{1F5D1}\uFE0F  Delete global project(s)",
-        hint: "Remove knowledge and configuration"
-      });
-    }
-    if (detectedProjects.length > 0) {
+    if (detectedProjects.some((p) => p.source === "global") || detectedProjects.length > 0) {
       menuOptions.push({
-        value: "link",
-        label: "\u{1F517} Link other project knowledge",
-        hint: `${detectedProjects.length} projects detected (global + sibling)`
+        value: "manage",
+        label: "\u{1F4C1} Manage Projects",
+        hint: "Link, delete, or sync projects"
       });
     }
     if (currentStorageMode === "workspace" && hasLocalData) {
@@ -6647,11 +6906,10 @@ Workspace: ${pc13.bold(workspaceName)}`,
         hint: "Share knowledge with other projects"
       });
     }
-    menuOptions.push({ value: "update", label: "\u{1F4E6} Update from package", hint: "Get latest prompts & templates" });
-    menuOptions.push({ value: "reconfigure", label: "\u{1F527} Reconfigure project", hint: "Change storage mode, tools, etc." });
+    menuOptions.push({ value: "advanced", label: "\u2699\uFE0F  Advanced", hint: "Update, reconfigure, or troubleshoot" });
     menuOptions.push({ value: "exit", label: "\u21A9  Exit" });
     const action = await select5({
-      message: "This workspace is already configured. What would you like to do?",
+      message: "What would you like to do?",
       options: menuOptions
     });
     if (isCancel12(action) || action === "exit") {
@@ -6662,23 +6920,62 @@ Workspace: ${pc13.bold(workspaceName)}`,
       await runMCP();
       return;
     }
-    if (action === "delete-global") {
-      await runDeleteGlobalProjectFlow(detectedProjects);
-      return;
-    }
-    if (action === "link") {
-      await runLinkProjectsFlow(workspacePath, workspaceName);
-      return;
+    if (action === "manage") {
+      const manageOptions = [];
+      if (detectedProjects.some((p) => p.source === "global")) {
+        manageOptions.push({
+          value: "delete-global",
+          label: "\u{1F5D1}\uFE0F  Delete global project(s)",
+          hint: "Remove knowledge and configuration"
+        });
+      }
+      if (detectedProjects.length > 0) {
+        manageOptions.push({
+          value: "link",
+          label: "\u{1F517} Link other project knowledge",
+          hint: `${detectedProjects.length} projects detected`
+        });
+      }
+      manageOptions.push({ value: "back", label: "\u21A9  Back to main menu" });
+      const manageAction = await select5({
+        message: "Project Management",
+        options: manageOptions
+      });
+      if (isCancel12(manageAction) || manageAction === "back") {
+        return runWizard();
+      }
+      if (manageAction === "delete-global") {
+        await runDeleteGlobalProjectFlow(detectedProjects);
+        return;
+      }
+      if (manageAction === "link") {
+        await runLinkProjectsFlow(workspacePath, workspaceName);
+        return;
+      }
     }
     if (action === "sync-global") {
       await runSyncToGlobalFlow(workspacePath, workspaceName);
       return;
     }
-    if (action === "update") {
-      await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
-      return;
-    }
-    if (action === "reconfigure") {
+    if (action === "advanced") {
+      const advancedOptions = [
+        { value: "update", label: "\u{1F4E6} Manual Update", hint: "Force update from package" },
+        { value: "reconfigure", label: "\u{1F527} Reconfigure Project", hint: "Change storage mode, tools, etc." },
+        { value: "back", label: "\u21A9  Back to main menu" }
+      ];
+      const advancedAction = await select5({
+        message: "Advanced Options",
+        options: advancedOptions
+      });
+      if (isCancel12(advancedAction) || advancedAction === "back") {
+        return runWizard();
+      }
+      if (advancedAction === "update") {
+        await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
+        return;
+      }
+      if (advancedAction === "reconfigure") {
+      }
     }
   }
   await runSetupFlow(workspacePath, workspaceName, detectedProjects);