rrce-workflow 0.2.18 → 0.2.20

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/commands/wizard/index.ts
 import { intro, select as select2, spinner as spinner5, note as note5, outro as outro5, isCancel as isCancel5 } from "@clack/prompts";
-import pc5 from "picocolors";
-import * as fs10 from "fs";
+import pc6 from "picocolors";
+import * as fs11 from "fs";
 
 // src/lib/git.ts
 import { execSync } from "child_process";
@@ -136,24 +136,42 @@ function getEffectiveRRCEHome(workspaceRoot) {
 // src/lib/detection.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".cache",
+  ".npm",
+  ".yarn",
+  ".pnpm",
+  ".local",
+  ".config",
+  ".vscode",
+  ".vscode-server",
+  "Library",
+  "Applications",
+  ".Trash",
+  "snap",
+  ".cargo",
+  ".rustup",
+  ".go",
+  ".docker"
+]);
 function scanForProjects(options = {}) {
-  const { excludeWorkspace, workspacePath, scanSiblings = true } = options;
+  const { excludeWorkspace, workspacePath } = options;
   const projects = [];
   const seenPaths = /* @__PURE__ */ new Set();
   const globalProjects = scanGlobalStorage(excludeWorkspace);
   for (const project of globalProjects) {
-    if (!seenPaths.has(project.path)) {
-      seenPaths.add(project.path);
+    if (!seenPaths.has(project.dataPath)) {
+      seenPaths.add(project.dataPath);
       projects.push(project);
     }
   }
-  if (scanSiblings && workspacePath) {
-    const siblingProjects = scanSiblingDirectories(workspacePath, excludeWorkspace);
-    for (const project of siblingProjects) {
-      if (!seenPaths.has(project.path)) {
-        seenPaths.add(project.path);
-        projects.push(project);
-      }
+  const homeProjects = scanHomeDirectory(workspacePath);
+  for (const project of homeProjects) {
+    if (!seenPaths.has(project.dataPath)) {
+      seenPaths.add(project.dataPath);
+      projects.push(project);
     }
   }
   return projects;
@@ -189,44 +207,56 @@ function scanGlobalStorage(excludeWorkspace) {
   }
   return projects;
 }
-function scanSiblingDirectories(workspacePath, excludeWorkspace) {
-  const parentDir = path2.dirname(workspacePath);
+function scanHomeDirectory(excludePath) {
+  const home = process.env.HOME;
+  if (!home) return [];
   const projects = [];
-  try {
-    const entries = fs2.readdirSync(parentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const projectPath = path2.join(parentDir, entry.name);
-      if (projectPath === workspacePath) continue;
-      if (entry.name === excludeWorkspace) continue;
-      const configPath = path2.join(projectPath, ".rrce-workflow", "config.yaml");
-      if (!fs2.existsSync(configPath)) continue;
-      const config = parseWorkspaceConfig(configPath);
-      if (!config) continue;
-      const dataPath = path2.join(projectPath, ".rrce-workflow");
-      const knowledgePath = path2.join(dataPath, "knowledge");
-      const refsPath = path2.join(dataPath, "refs");
-      const tasksPath = path2.join(dataPath, "tasks");
-      projects.push({
-        name: config.name || entry.name,
-        path: projectPath,
-        dataPath,
-        source: "sibling",
-        storageMode: config.storageMode,
-        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
-        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
-        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
-      });
+  const maxDepth = 5;
+  function scanDir(dirPath, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const fullPath = path2.join(dirPath, entry.name);
+        if (excludePath && fullPath === excludePath) continue;
+        if (entry.name === ".rrce-workflow") {
+          const configPath = path2.join(fullPath, "config.yaml");
+          if (fs2.existsSync(configPath)) {
+            const projectPath = dirPath;
+            const projectName = path2.basename(projectPath);
+            const config = parseWorkspaceConfig(configPath);
+            const knowledgePath = path2.join(fullPath, "knowledge");
+            const refsPath = path2.join(fullPath, "refs");
+            const tasksPath = path2.join(fullPath, "tasks");
+            projects.push({
+              name: config?.name || projectName,
+              path: projectPath,
+              dataPath: fullPath,
+              source: "local",
+              storageMode: config?.storageMode,
+              knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+              refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+              tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
+            });
+          }
+          continue;
+        }
+        if (SKIP_DIRECTORIES.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && entry.name !== ".rrce-workflow") continue;
+        scanDir(fullPath, depth + 1);
+      }
+    } catch {
     }
-  } catch {
   }
+  scanDir(home, 0);
   return projects;
 }
 function parseWorkspaceConfig(configPath) {
   try {
     const content = fs2.readFileSync(configPath, "utf-8");
     const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
-    const modeMatch = content.match(/mode:\s*(global|workspace|both)/);
+    const modeMatch = content.match(/mode:\s*(global|workspace)/);
     const linkedProjects = [];
     const linkedMatch = content.match(/linked_projects:\s*\n((?:\s+-\s+[^\n]+\n?)+)/);
     if (linkedMatch && linkedMatch[1]) {
@@ -249,10 +279,10 @@ function parseWorkspaceConfig(configPath) {
 }
 
 // src/commands/wizard/setup-flow.ts
-import { group, text, select, multiselect, confirm, spinner, note, outro, cancel, isCancel } from "@clack/prompts";
-import pc from "picocolors";
-import * as fs6 from "fs";
-import * as path6 from "path";
+import { group, select, multiselect, confirm, spinner, note, outro, cancel, isCancel } from "@clack/prompts";
+import pc2 from "picocolors";
+import * as fs7 from "fs";
+import * as path7 from "path";
 
 // src/lib/prompts.ts
 import * as fs3 from "fs";
@@ -433,6 +463,113 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
   fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
 
+// src/lib/autocomplete-prompt.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as readline from "readline";
+import pc from "picocolors";
+function directoryPrompt(opts) {
+  return new Promise((resolve) => {
+    process.stdout.write(`${pc.cyan("\u25C6")}  ${opts.message}
+`);
+    process.stdout.write(`${pc.cyan("\u2502")}  `);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      completer: completeDirectory,
+      terminal: true
+    });
+    if (opts.defaultValue) {
+      rl.write(opts.defaultValue);
+    }
+    rl.on("line", (input) => {
+      const value = input.trim();
+      const expandedPath = value.startsWith("~") ? value.replace(/^~/, process.env.HOME || "") : value;
+      if (opts.validate) {
+        const error = opts.validate(expandedPath);
+        if (error) {
+          process.stdout.write(`${pc.yellow("\u2502")}  ${pc.yellow(error)}
+`);
+          process.stdout.write(`${pc.cyan("\u2502")}  `);
+          rl.write(value);
+          return;
+        }
+      }
+      rl.close();
+      process.stdout.write(`${pc.green("\u2713")}  ${pc.dim(expandedPath)}
+`);
+      resolve(expandedPath);
+    });
+    rl.on("close", () => {
+    });
+    rl.on("SIGINT", () => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve(/* @__PURE__ */ Symbol("cancel"));
+    });
+  });
+}
+function completeDirectory(line) {
+  const expanded = line.startsWith("~") ? line.replace(/^~/, process.env.HOME || "") : line;
+  try {
+    let dirToScan;
+    let prefix;
+    let basePath;
+    if (expanded === "" || expanded === "/") {
+      dirToScan = expanded || "/";
+      prefix = "";
+      basePath = expanded;
+    } else if (expanded.endsWith("/")) {
+      dirToScan = expanded;
+      prefix = "";
+      basePath = expanded;
+    } else {
+      dirToScan = path6.dirname(expanded);
+      prefix = path6.basename(expanded).toLowerCase();
+      basePath = dirToScan === "/" ? "/" : dirToScan + "/";
+    }
+    if (!fs6.existsSync(dirToScan)) {
+      return [[], line];
+    }
+    const entries = fs6.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 = path6.join(dirToScan, entry.name);
+      const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
+      return displayPath + "/";
+    }).sort();
+    if (entries.length === 1) {
+      return [entries, line];
+    }
+    if (entries.length > 1) {
+      const commonPrefix = getCommonPrefix(entries);
+      if (commonPrefix.length > line.length) {
+        return [[commonPrefix], line];
+      }
+    }
+    return [entries, line];
+  } catch {
+    return [[], line];
+  }
+}
+function getCommonPrefix(strings) {
+  if (strings.length === 0) return "";
+  if (strings.length === 1) return strings[0] || "";
+  let prefix = strings[0] || "";
+  for (let i = 1; i < strings.length; i++) {
+    const str = strings[i] || "";
+    while (prefix.length > 0 && !str.startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+    }
+  }
+  return prefix;
+}
+function isCancelled(value) {
+  return typeof value === "symbol";
+}
+
 // src/commands/wizard/setup-flow.ts
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const s = spinner();
@@ -441,9 +578,8 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       storageMode: () => select({
         message: "Where should workflow data be stored?",
         options: [
-          { value: "global", label: "Global (~/.rrce-workflow/)" },
-          { value: "workspace", label: "Workspace (.rrce-workflow/)" },
-          { value: "both", label: "Both" }
+          { value: "global", label: "Global (~/.rrce-workflow/)", hint: "Cross-project access, clean workspace" },
+          { value: "workspace", label: "Workspace (.rrce-workflow/)", hint: "Self-contained, version with repo" }
         ],
         initialValue: "global"
       }),
@@ -464,14 +600,18 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
           options: existingProjects.map((project) => ({
             value: `${project.name}:${project.source}`,
             // Unique key
-            label: `${project.name} ${pc.dim(`(${project.source})`)}`,
-            hint: pc.dim(
+            label: `${project.name} ${pc2.dim(`(${project.source})`)}`,
+            hint: pc2.dim(
               project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
             )
           })),
           required: false
         });
       },
+      addToGitignore: () => confirm({
+        message: "Add generated folders to .gitignore?",
+        initialValue: true
+      }),
       confirm: () => confirm({
         message: "Create configuration?",
         initialValue: true
@@ -489,7 +629,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     process.exit(0);
   }
   let customGlobalPath;
-  if (config.storageMode === "global" || config.storageMode === "both") {
+  if (config.storageMode === "global") {
     customGlobalPath = await resolveGlobalPath();
     if (!customGlobalPath) {
       cancel("Setup cancelled - no writable global path available.");
@@ -502,7 +642,8 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       storageMode: config.storageMode,
       globalPath: customGlobalPath,
       tools: config.tools,
-      linkedProjects: config.linkedProjects
+      linkedProjects: config.linkedProjects,
+      addToGitignore: config.addToGitignore
     }, workspacePath, workspaceName, existingProjects);
     s.stop("Configuration generated");
     const dataPaths = getDataPaths(
@@ -512,10 +653,10 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       customGlobalPath
     );
     const summary = [
-      `Storage: ${config.storageMode === "both" ? "global + workspace" : config.storageMode}`
+      `Storage: ${config.storageMode}`
     ];
     if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc.cyan(customGlobalPath)}`);
+      summary.push(`Global path: ${pc2.cyan(customGlobalPath)}`);
     }
     if (dataPaths.length > 0) {
       summary.push(`Data paths:`);
@@ -528,13 +669,13 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     const linkedProjects = config.linkedProjects;
     if (linkedProjects.length > 0) {
       summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
-      summary.push(`Workspace file: ${pc.cyan(`${workspaceName}.code-workspace`)}`);
+      summary.push(`Workspace file: ${pc2.cyan(`${workspaceName}.code-workspace`)}`);
     }
     note(summary.join("\n"), "Setup Summary");
     if (linkedProjects.length > 0) {
-      outro(pc.green(`\u2713 Setup complete! Open ${pc.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+      outro(pc2.green(`\u2713 Setup complete! Open ${pc2.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
     } else {
-      outro(pc.green(`\u2713 Setup complete! Your agents are ready to use.`));
+      outro(pc2.green(`\u2713 Setup complete! Your agents are ready to use.`));
     }
   } catch (error) {
     s.stop("Error occurred");
@@ -549,7 +690,7 @@ async function resolveGlobalPath() {
   options.push({
     value: "default",
     label: `Default (${defaultPath})`,
-    hint: isDefaultWritable ? pc.green("\u2713 writable") : pc.red("\u2717 not writable")
+    hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
   });
   options.push({
     value: "custom",
@@ -567,8 +708,8 @@ async function resolveGlobalPath() {
   if (choice === "default") {
     if (!isDefaultWritable) {
       note(
-        `${pc.yellow("\u26A0")} Cannot write to default path:
-  ${pc.dim(defaultPath)}
+        `${pc2.yellow("\u26A0")} Cannot write to default path:
+  ${pc2.dim(defaultPath)}
 
 This can happen when running via npx/bunx in restricted environments.
 Please choose a custom path instead.`,
@@ -578,28 +719,26 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path6.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
-  const customPath = await text({
-    message: "Enter custom global path:",
+  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const customPath = await directoryPrompt({
+    message: "Enter custom global path (Tab to autocomplete):",
     defaultValue: suggestedPath,
-    placeholder: suggestedPath,
     validate: (value) => {
       if (!value.trim()) {
         return "Path cannot be empty";
       }
-      const expandedPath2 = value.startsWith("~") ? value.replace("~", process.env.HOME || "") : value;
-      if (!checkWriteAccess(expandedPath2)) {
-        return `Cannot write to ${expandedPath2}. Please choose a writable path.`;
+      if (!checkWriteAccess(value)) {
+        return `Cannot write to ${value}. Please choose a writable path.`;
       }
       return void 0;
     }
   });
-  if (isCancel(customPath)) {
+  if (isCancelled(customPath)) {
     return void 0;
   }
-  let expandedPath = customPath.startsWith("~") ? customPath.replace("~", process.env.HOME || "") : customPath;
+  let expandedPath = customPath;
   if (!expandedPath.endsWith(".rrce-workflow")) {
-    expandedPath = path6.join(expandedPath, ".rrce-workflow");
+    expandedPath = path7.join(expandedPath, ".rrce-workflow");
   }
   return expandedPath;
 }
@@ -607,14 +746,14 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path6.join(dataPath, "knowledge"));
-    ensureDir(path6.join(dataPath, "refs"));
-    ensureDir(path6.join(dataPath, "tasks"));
-    ensureDir(path6.join(dataPath, "templates"));
+    ensureDir(path7.join(dataPath, "knowledge"));
+    ensureDir(path7.join(dataPath, "refs"));
+    ensureDir(path7.join(dataPath, "tasks"));
+    ensureDir(path7.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path6.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path7.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (config.tools.includes("copilot")) {
     const copilotPath = getAgentPromptPath(workspacePath, "copilot");
@@ -626,8 +765,8 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
     ensureDir(antigravityPath);
     copyPromptsToDir(prompts, antigravityPath, ".md");
   }
-  const workspaceConfigPath = path6.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path6.dirname(workspaceConfigPath));
+  const workspaceConfigPath = path7.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path7.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -655,7 +794,10 @@ linked_projects:
 `;
     });
   }
-  fs6.writeFileSync(workspaceConfigPath, configContent);
+  fs7.writeFileSync(workspaceConfigPath, configContent);
+  if (config.addToGitignore) {
+    updateGitignore(workspacePath, config.storageMode, config.tools);
+  }
   if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
     const selectedProjects = allProjects.filter(
       (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
@@ -664,32 +806,74 @@ linked_projects:
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path6.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path6.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path7.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path7.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
     case "workspace":
       return [workspacePath];
-    case "both":
-      return [workspacePath, globalPath];
     default:
       return [globalPath];
   }
 }
+function updateGitignore(workspacePath, storageMode, tools) {
+  const gitignorePath = path7.join(workspacePath, ".gitignore");
+  const entries = [];
+  if (storageMode === "workspace") {
+    entries.push(".rrce-workflow/");
+  }
+  if (tools.includes("copilot")) {
+    entries.push(".github/agents/");
+  }
+  if (tools.includes("antigravity")) {
+    entries.push(".agent/");
+  }
+  if (entries.length === 0) {
+    return false;
+  }
+  try {
+    let content = "";
+    if (fs7.existsSync(gitignorePath)) {
+      content = fs7.readFileSync(gitignorePath, "utf-8");
+    }
+    const lines = content.split("\n").map((line) => line.trim());
+    const newEntries = [];
+    for (const entry of entries) {
+      const entryWithoutSlash = entry.replace(/\/$/, "");
+      if (!lines.some((line) => line === entry || line === entryWithoutSlash)) {
+        newEntries.push(entry);
+      }
+    }
+    if (newEntries.length === 0) {
+      return false;
+    }
+    let newContent = content;
+    if (!newContent.endsWith("\n") && newContent !== "") {
+      newContent += "\n";
+    }
+    if (newContent === "" || !content.includes("# rrce-workflow")) {
+      newContent += "\n# rrce-workflow generated folders\n";
+    }
+    newContent += newEntries.join("\n") + "\n";
+    fs7.writeFileSync(gitignorePath, newContent);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/commands/wizard/link-flow.ts
 import { multiselect as multiselect2, spinner as spinner2, note as note2, outro as outro2, cancel as cancel2, isCancel as isCancel2 } from "@clack/prompts";
-import pc2 from "picocolors";
-import * as fs7 from "fs";
+import pc3 from "picocolors";
+import * as fs8 from "fs";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
-    workspacePath,
-    scanSiblings: true
+    workspacePath
   });
   if (projects.length === 0) {
-    outro2(pc2.yellow("No other projects found. Try setting up another project first."));
+    outro2(pc3.yellow("No other projects found. Try setting up another project first."));
     return;
   }
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
@@ -698,8 +882,8 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     options: projects.map((project) => ({
       value: `${project.name}:${project.source}`,
       // Unique key
-      label: `${project.name} ${pc2.dim(`(${project.source})`)}`,
-      hint: pc2.dim(
+      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
+      hint: pc3.dim(
         project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
       )
     })),
@@ -720,7 +904,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner2();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs7.readFileSync(configFilePath, "utf-8");
+  let configContent = fs8.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -747,42 +931,42 @@ linked_projects:
 `;
     });
   }
-  fs7.writeFileSync(configFilePath, configContent);
+  fs8.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} ${pc2.dim(`(${p.source})`)}`),
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc3.dim(`(${p.source})`)}`),
     ``,
-    `Workspace file: ${pc2.cyan(workspaceFile)}`
+    `Workspace file: ${pc3.cyan(workspaceFile)}`
   ];
   note2(summary.join("\n"), "Link Summary");
-  outro2(pc2.green(`\u2713 Projects linked! Open ${pc2.bold(workspaceFile)} in VSCode to access linked data.`));
+  outro2(pc3.green(`\u2713 Projects linked! Open ${pc3.bold(workspaceFile)} in VSCode to access linked data.`));
 }
 
 // src/commands/wizard/sync-flow.ts
 import { confirm as confirm2, spinner as spinner3, note as note3, outro as outro3, cancel as cancel3, isCancel as isCancel3 } from "@clack/prompts";
-import pc3 from "picocolors";
-import * as fs8 from "fs";
-import * as path7 from "path";
+import pc4 from "picocolors";
+import * as fs9 from "fs";
+import * as path8 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path7.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs8.existsSync(path7.join(localPath, dir))
+    (dir) => fs9.existsSync(path8.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
-    outro3(pc3.yellow("No data found in workspace storage to sync."));
+    outro3(pc4.yellow("No data found in workspace storage to sync."));
     return;
   }
   note3(
     `The following will be copied to global storage:
 ${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 
-Destination: ${pc3.cyan(globalPath)}`,
+Destination: ${pc4.cyan(globalPath)}`,
     "Sync Preview"
   );
   const shouldSync = await confirm2({
@@ -798,27 +982,22 @@ Destination: ${pc3.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path7.join(localPath, dir);
-      const destDir = path7.join(globalPath, dir);
+      const srcDir = path8.join(localPath, dir);
+      const destDir = path8.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
-    const configFilePath = getConfigPath(workspacePath);
-    let configContent = fs8.readFileSync(configFilePath, "utf-8");
-    configContent = configContent.replace(/mode:\s*workspace/, "mode: both");
-    fs8.writeFileSync(configFilePath, configContent);
     s.stop("Sync complete");
     const summary = [
       `Synced directories:`,
       ...existingDirs.map((d) => `  \u2713 ${d}/`),
       ``,
-      `Global path: ${pc3.cyan(globalPath)}`,
-      `Storage mode updated to: ${pc3.bold("both")}`,
+      `Global path: ${pc4.cyan(globalPath)}`,
       ``,
       `Other projects can now link this knowledge!`
     ];
     note3(summary.join("\n"), "Sync Summary");
-    outro3(pc3.green("\u2713 Workspace knowledge synced to global storage!"));
+    outro3(pc4.green("\u2713 Workspace knowledge synced to global storage!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel3(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
@@ -828,9 +1007,9 @@ Destination: ${pc3.cyan(globalPath)}`,
 
 // src/commands/wizard/update-flow.ts
 import { confirm as confirm3, spinner as spinner4, note as note4, outro as outro4, cancel as cancel4, isCancel as isCancel4 } from "@clack/prompts";
-import pc4 from "picocolors";
-import * as fs9 from "fs";
-import * as path8 from "path";
+import pc5 from "picocolors";
+import * as fs10 from "fs";
+import * as path9 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner4();
   s.start("Checking for updates");
@@ -860,10 +1039,10 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path9.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs9.readFileSync(configFilePath, "utf-8");
+    const configContent = fs10.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -883,7 +1062,7 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       `Your configuration and knowledge files were preserved.`
     ];
     note4(summary.join("\n"), "Update Summary");
-    outro4(pc4.green("\u2713 Successfully updated from package!"));
+    outro4(pc5.green("\u2713 Successfully updated from package!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
@@ -891,15 +1070,13 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path9.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
     case "workspace":
       return [workspacePath];
-    case "both":
-      return [workspacePath, globalPath];
     default:
       return [globalPath];
   }
@@ -907,7 +1084,7 @@ function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot,
 
 // src/commands/wizard/index.ts
 async function runWizard() {
-  intro(pc5.cyan(pc5.inverse(" RRCE-Workflow Setup ")));
+  intro(pc6.cyan(pc6.inverse(" RRCE-Workflow Setup ")));
   const s = spinner5();
   s.start("Detecting environment");
   const workspacePath = detectWorkspaceRoot();
@@ -916,28 +1093,27 @@ async function runWizard() {
   await new Promise((r) => setTimeout(r, 800));
   s.stop("Environment detected");
   note5(
-    `Git User:  ${pc5.bold(gitUser || "(not found)")}
-Workspace: ${pc5.bold(workspaceName)}`,
+    `Git User:  ${pc6.bold(gitUser || "(not found)")}
+Workspace: ${pc6.bold(workspaceName)}`,
     "Context"
   );
   const detectedProjects = scanForProjects({
     excludeWorkspace: workspaceName,
-    workspacePath,
-    scanSiblings: true
+    workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs10.existsSync(configFilePath);
+  const isAlreadyConfigured = fs11.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs10.readFileSync(configFilePath, "utf-8");
-      const modeMatch = configContent.match(/mode:\s*(global|workspace|both)/);
+      const configContent = fs11.readFileSync(configFilePath, "utf-8");
+      const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs10.existsSync(localDataPath);
+  const hasLocalData = fs11.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     if (detectedProjects.length > 0) {
@@ -982,11 +1158,11 @@ Workspace: ${pc5.bold(workspaceName)}`,
 
 // src/commands/selector.ts
 import { intro as intro2, select as select3, note as note6, cancel as cancel6, isCancel as isCancel6, outro as outro6 } from "@clack/prompts";
-import pc6 from "picocolors";
-import * as path9 from "path";
+import pc7 from "picocolors";
+import * as path10 from "path";
 async function runSelector() {
-  const workspaceName = path9.basename(process.cwd());
-  intro2(pc6.cyan(pc6.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const workspaceName = path10.basename(process.cwd());
+  intro2(pc7.cyan(pc7.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {
     cancel6("No agents found. Run `rrce-workflow` to set up.");
@@ -1007,7 +1183,7 @@ async function runSelector() {
   const prompt = selection;
   note6(
     `Use this agent in your IDE by invoking:
-${pc6.bold(pc6.cyan(`@${prompt.frontmatter.name}`))}`,
+${pc7.bold(pc7.cyan(`@${prompt.frontmatter.name}`))}`,
     "Agent Selected"
   );
   outro6("Done");

package/package.json

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