rrce-workflow 0.2.16 → 0.2.18

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 isCancel6 } from "@clack/prompts";
-import pc6 from "picocolors";
-import * as fs11 from "fs";
+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";
 
 // src/lib/git.ts
 import { execSync } from "child_process";
@@ -247,47 +247,12 @@ function parseWorkspaceConfig(configPath) {
     return null;
   }
 }
-function getProjectDisplayLabel(project) {
-  switch (project.source) {
-    case "global":
-      return `global: ~/.rrce-workflow/workspaces/${project.name}`;
-    case "sibling":
-      return `sibling: ${project.path}/.rrce-workflow`;
-    default:
-      return project.dataPath;
-  }
-}
-function getProjectFolders(project) {
-  const folders = [];
-  if (project.knowledgePath) {
-    folders.push({
-      path: project.knowledgePath,
-      type: "knowledge",
-      displayName: `\u{1F4DA} ${project.name} (knowledge)`
-    });
-  }
-  if (project.refsPath) {
-    folders.push({
-      path: project.refsPath,
-      type: "refs",
-      displayName: `\u{1F4CE} ${project.name} (refs)`
-    });
-  }
-  if (project.tasksPath) {
-    folders.push({
-      path: project.tasksPath,
-      type: "tasks",
-      displayName: `\u{1F4CB} ${project.name} (tasks)`
-    });
-  }
-  return folders;
-}
 
 // src/commands/wizard/setup-flow.ts
-import { group, select, multiselect, confirm, spinner, note, outro, cancel, isCancel as isCancel2 } from "@clack/prompts";
-import pc2 from "picocolors";
-import * as fs7 from "fs";
-import * as path7 from "path";
+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";
 
 // src/lib/prompts.ts
 import * as fs3 from "fs";
@@ -388,7 +353,6 @@ function copyDirRecursive(src, dest) {
 // src/commands/wizard/vscode.ts
 import * as fs5 from "fs";
 import * as path5 from "path";
-var REFERENCE_GROUP_PREFIX = "\u{1F4C1} References";
 function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
   const workspaceFilePath = path5.join(workspacePath, `${workspaceName}.code-workspace`);
   let workspace;
@@ -405,60 +369,47 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
   if (!workspace.settings) {
     workspace.settings = {};
   }
-  const existingNonReferencesFolders = workspace.folders.filter(
-    (f) => f.path === "." || !f.name?.includes(REFERENCE_GROUP_PREFIX) && !f.name?.startsWith("\u{1F4DA}") && !f.name?.startsWith("\u{1F4CE}") && !f.name?.startsWith("\u{1F4CB}")
+  workspace.folders = workspace.folders.filter(
+    (f) => f.path === "." || !f.name?.startsWith("\u{1F4C1}") && !f.name?.startsWith("\u{1F4DA}") && !f.name?.startsWith("\u{1F4CE}") && !f.name?.startsWith("\u{1F4CB}")
   );
-  workspace.folders = [];
-  const mainFolder = {
-    path: ".",
-    name: `\u{1F3E0} ${workspaceName} (workspace)`
-  };
-  workspace.folders.push(mainFolder);
-  for (const folder of existingNonReferencesFolders) {
-    if (folder.path !== ".") {
-      workspace.folders.push(folder);
-    }
+  const mainFolderIndex = workspace.folders.findIndex((f) => f.path === ".");
+  if (mainFolderIndex === -1) {
+    workspace.folders.unshift({
+      path: ".",
+      name: `\u{1F3E0} ${workspaceName} (workspace)`
+    });
+  } else {
+    workspace.folders[mainFolderIndex] = {
+      path: ".",
+      name: `\u{1F3E0} ${workspaceName} (workspace)`
+    };
   }
   const referenceFolderPaths = [];
   const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === "object";
   if (isDetectedProjects) {
     const projects = linkedProjects;
     for (const project of projects) {
-      const folders = getProjectFolders(project);
       const sourceLabel = project.source === "global" ? "global" : "local";
-      for (const folder of folders) {
-        referenceFolderPaths.push(folder.path);
-        const existingIndex = workspace.folders.findIndex((f) => f.path === folder.path);
-        if (existingIndex === -1) {
-          workspace.folders.push({
-            path: folder.path,
-            name: `${folder.displayName} [${sourceLabel}]`
-          });
-        }
+      const folderPath = project.dataPath;
+      if (fs5.existsSync(folderPath)) {
+        referenceFolderPaths.push(folderPath);
+        workspace.folders.push({
+          path: folderPath,
+          name: `\u{1F4C1} ${project.name} [${sourceLabel}]`
+        });
       }
     }
   } else {
     const projectNames = linkedProjects;
     const rrceHome = customGlobalPath || getRRCEHome();
     for (const projectName of projectNames) {
-      const projectDataPath = path5.join(rrceHome, "workspaces", projectName);
-      const folderTypes = [
-        { subpath: "knowledge", icon: "\u{1F4DA}", type: "knowledge" },
-        { subpath: "refs", icon: "\u{1F4CE}", type: "refs" },
-        { subpath: "tasks", icon: "\u{1F4CB}", type: "tasks" }
-      ];
-      for (const { subpath, icon, type } of folderTypes) {
-        const folderPath = path5.join(projectDataPath, subpath);
-        if (fs5.existsSync(folderPath)) {
-          referenceFolderPaths.push(folderPath);
-          const existingIndex = workspace.folders.findIndex((f) => f.path === folderPath);
-          if (existingIndex === -1) {
-            workspace.folders.push({
-              path: folderPath,
-              name: `${icon} ${projectName} (${type}) [global]`
-            });
-          }
-        }
+      const folderPath = path5.join(rrceHome, "workspaces", projectName);
+      if (fs5.existsSync(folderPath)) {
+        referenceFolderPaths.push(folderPath);
+        workspace.folders.push({
+          path: folderPath,
+          name: `\u{1F4C1} ${projectName} [global]`
+        });
       }
     }
   }
@@ -468,143 +419,20 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
       readonlyPatterns[`${folderPath}/**`] = true;
     }
     const existingReadonly = workspace.settings["files.readonlyInclude"] || {};
+    const cleanedReadonly = {};
+    for (const [pattern, value] of Object.entries(existingReadonly)) {
+      if (!pattern.includes(".rrce-workflow") && !pattern.includes("rrce-workflow/workspaces")) {
+        cleanedReadonly[pattern] = value;
+      }
+    }
     workspace.settings["files.readonlyInclude"] = {
-      ...existingReadonly,
+      ...cleanedReadonly,
       ...readonlyPatterns
     };
   }
-  workspace.settings["explorer.sortOrder"] = workspace.settings["explorer.sortOrder"] || "default";
   fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
 
-// src/lib/autocomplete-prompt.ts
-import { TextPrompt, isCancel } from "@clack/core";
-import * as fs6 from "fs";
-import * as path6 from "path";
-import pc from "picocolors";
-async function directoryAutocomplete(opts) {
-  let completions = [];
-  let completionIndex = 0;
-  let lastTabValue = "";
-  const prompt = new TextPrompt({
-    initialValue: opts.initialValue,
-    validate: opts.validate,
-    render() {
-      const title = `${pc.cyan("\u25C6")}  ${opts.message}`;
-      const hintText = opts.hint ? pc.dim(` (${opts.hint})`) : "";
-      let inputLine;
-      if (this.state === "error") {
-        inputLine = `${pc.yellow("\u25B2")}  ${this.valueWithCursor}`;
-      } else if (this.state === "submit") {
-        inputLine = `${pc.green("\u2713")}  ${pc.dim(String(this.value || ""))}`;
-      } else {
-        inputLine = `${pc.cyan("\u2502")}  ${this.valueWithCursor || pc.dim(opts.placeholder || "")}`;
-      }
-      let result2 = `${title}${hintText}
-${inputLine}`;
-      if (this.state === "error" && this.error) {
-        result2 += `
-${pc.yellow("\u2502")}  ${pc.yellow(this.error)}`;
-      }
-      if (completions.length > 1 && this.state === "active") {
-        const remaining = completions.length - 1;
-        result2 += `
-${pc.dim("\u2502")}  ${pc.dim(`+${remaining} more, press Tab again to cycle`)}`;
-      }
-      return result2;
-    }
-  });
-  prompt.on("key", (key) => {
-    if (key === "	" || key === "tab") {
-      handleTabCompletion(prompt);
-    } else {
-      completions = [];
-      completionIndex = 0;
-      lastTabValue = "";
-    }
-  });
-  function handleTabCompletion(p) {
-    const input = String(p.value || "");
-    const expanded = input.startsWith("~") ? input.replace(/^~/, process.env.HOME || "") : input;
-    if (lastTabValue === input && completions.length > 1) {
-      completionIndex = (completionIndex + 1) % completions.length;
-      const completion = completions[completionIndex] || "";
-      setPromptValue(p, completion);
-      return;
-    }
-    completions = getDirectoryCompletions(expanded);
-    completionIndex = 0;
-    lastTabValue = input;
-    if (completions.length === 1) {
-      const completion = completions[0] || "";
-      setPromptValue(p, completion.endsWith("/") ? completion : completion + "/");
-      completions = [];
-      lastTabValue = "";
-    } else if (completions.length > 1) {
-      const commonPrefix = getCommonPrefix(completions);
-      if (commonPrefix.length > expanded.length) {
-        setPromptValue(p, commonPrefix);
-        lastTabValue = formatForDisplay(commonPrefix);
-      } else {
-        setPromptValue(p, completions[0] || "");
-      }
-    }
-  }
-  function setPromptValue(p, value2) {
-    const displayValue = formatForDisplay(value2);
-    p.value = displayValue;
-  }
-  function formatForDisplay(value2) {
-    const home = process.env.HOME || "";
-    return value2.startsWith(home) ? value2.replace(home, "~") : value2;
-  }
-  function getDirectoryCompletions(inputPath) {
-    try {
-      let dirToScan;
-      let prefix;
-      if (inputPath === "" || inputPath === "/") {
-        dirToScan = inputPath || "/";
-        prefix = "";
-      } else if (inputPath.endsWith("/")) {
-        dirToScan = inputPath;
-        prefix = "";
-      } else {
-        dirToScan = path6.dirname(inputPath);
-        prefix = path6.basename(inputPath).toLowerCase();
-      }
-      if (!fs6.existsSync(dirToScan)) {
-        return [];
-      }
-      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) => path6.join(dirToScan, entry.name)).sort();
-      return entries;
-    } catch {
-      return [];
-    }
-  }
-  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;
-  }
-  const result = await prompt.prompt();
-  if (isCancel(result)) {
-    return result;
-  }
-  const value = String(result || "");
-  return value.startsWith("~") ? value.replace(/^~/, process.env.HOME || "") : value;
-}
-
 // src/commands/wizard/setup-flow.ts
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const s = spinner();
@@ -634,9 +462,12 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
         return multiselect({
           message: "Link knowledge from other projects?",
           options: existingProjects.map((project) => ({
-            value: project.name,
-            label: project.name,
-            hint: pc2.dim(getProjectDisplayLabel(project))
+            value: `${project.name}:${project.source}`,
+            // Unique key
+            label: `${project.name} ${pc.dim(`(${project.source})`)}`,
+            hint: pc.dim(
+              project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
+            )
           })),
           required: false
         });
@@ -684,7 +515,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       `Storage: ${config.storageMode === "both" ? "global + workspace" : config.storageMode}`
     ];
     if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc2.cyan(customGlobalPath)}`);
+      summary.push(`Global path: ${pc.cyan(customGlobalPath)}`);
     }
     if (dataPaths.length > 0) {
       summary.push(`Data paths:`);
@@ -697,13 +528,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: ${pc2.cyan(`${workspaceName}.code-workspace`)}`);
+      summary.push(`Workspace file: ${pc.cyan(`${workspaceName}.code-workspace`)}`);
     }
     note(summary.join("\n"), "Setup Summary");
     if (linkedProjects.length > 0) {
-      outro(pc2.green(`\u2713 Setup complete! Open ${pc2.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+      outro(pc.green(`\u2713 Setup complete! Open ${pc.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
     } else {
-      outro(pc2.green(`\u2713 Setup complete! Your agents are ready to use.`));
+      outro(pc.green(`\u2713 Setup complete! Your agents are ready to use.`));
     }
   } catch (error) {
     s.stop("Error occurred");
@@ -718,7 +549,7 @@ async function resolveGlobalPath() {
   options.push({
     value: "default",
     label: `Default (${defaultPath})`,
-    hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
+    hint: isDefaultWritable ? pc.green("\u2713 writable") : pc.red("\u2717 not writable")
   });
   options.push({
     value: "custom",
@@ -730,14 +561,14 @@ async function resolveGlobalPath() {
     options,
     initialValue: isDefaultWritable ? "default" : "custom"
   });
-  if (isCancel2(choice)) {
+  if (isCancel(choice)) {
     return void 0;
   }
   if (choice === "default") {
     if (!isDefaultWritable) {
       note(
-        `${pc2.yellow("\u26A0")} Cannot write to default path:
-  ${pc2.dim(defaultPath)}
+        `${pc.yellow("\u26A0")} Cannot write to default path:
+  ${pc.dim(defaultPath)}
 
 This can happen when running via npx/bunx in restricted environments.
 Please choose a custom path instead.`,
@@ -747,18 +578,18 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
-  const customPath = await directoryAutocomplete({
+  const suggestedPath = path6.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const customPath = await text({
     message: "Enter custom global path:",
-    initialValue: suggestedPath,
-    hint: "Tab to autocomplete",
+    defaultValue: suggestedPath,
+    placeholder: suggestedPath,
     validate: (value) => {
       if (!value.trim()) {
         return "Path cannot be empty";
       }
-      const expandedPath = value.startsWith("~") ? value.replace("~", process.env.HOME || "") : value;
-      if (!checkWriteAccess(expandedPath)) {
-        return `Cannot write to ${expandedPath}. Please choose a writable path.`;
+      const expandedPath2 = value.startsWith("~") ? value.replace("~", process.env.HOME || "") : value;
+      if (!checkWriteAccess(expandedPath2)) {
+        return `Cannot write to ${expandedPath2}. Please choose a writable path.`;
       }
       return void 0;
     }
@@ -766,20 +597,24 @@ Please choose a custom path instead.`,
   if (isCancel(customPath)) {
     return void 0;
   }
-  return customPath;
+  let expandedPath = customPath.startsWith("~") ? customPath.replace("~", process.env.HOME || "") : customPath;
+  if (!expandedPath.endsWith(".rrce-workflow")) {
+    expandedPath = path6.join(expandedPath, ".rrce-workflow");
+  }
+  return expandedPath;
 }
 async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path7.join(dataPath, "knowledge"));
-    ensureDir(path7.join(dataPath, "refs"));
-    ensureDir(path7.join(dataPath, "tasks"));
-    ensureDir(path7.join(dataPath, "templates"));
+    ensureDir(path6.join(dataPath, "knowledge"));
+    ensureDir(path6.join(dataPath, "refs"));
+    ensureDir(path6.join(dataPath, "tasks"));
+    ensureDir(path6.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path7.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path6.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (config.tools.includes("copilot")) {
     const copilotPath = getAgentPromptPath(workspacePath, "copilot");
@@ -791,8 +626,8 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
     ensureDir(antigravityPath);
     copyPromptsToDir(prompts, antigravityPath, ".md");
   }
-  const workspaceConfigPath = path7.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path7.dirname(workspaceConfigPath));
+  const workspaceConfigPath = path6.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path6.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -820,15 +655,17 @@ linked_projects:
 `;
     });
   }
-  fs7.writeFileSync(workspaceConfigPath, configContent);
+  fs6.writeFileSync(workspaceConfigPath, configContent);
   if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
-    const selectedProjects = allProjects.filter((p) => config.linkedProjects.includes(p.name));
+    const selectedProjects = allProjects.filter(
+      (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
+    );
     generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path7.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path7.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path6.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path6.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -842,9 +679,9 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
 }
 
 // src/commands/wizard/link-flow.ts
-import { multiselect as multiselect2, spinner as spinner2, note as note2, outro as outro2, cancel as cancel2, isCancel as isCancel3 } from "@clack/prompts";
-import pc3 from "picocolors";
-import * as fs8 from "fs";
+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";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
@@ -852,33 +689,38 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     scanSiblings: true
   });
   if (projects.length === 0) {
-    outro2(pc3.yellow("No other projects found. Try setting up another project first."));
+    outro2(pc2.yellow("No other projects found. Try setting up another project first."));
     return;
   }
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
   const linkedProjects = await multiselect2({
     message: "Select projects to link:",
     options: projects.map((project) => ({
-      value: project.name,
-      label: project.name,
-      hint: pc3.dim(getProjectDisplayLabel(project))
+      value: `${project.name}:${project.source}`,
+      // Unique key
+      label: `${project.name} ${pc2.dim(`(${project.source})`)}`,
+      hint: pc2.dim(
+        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
+      )
     })),
     required: true
   });
-  if (isCancel3(linkedProjects)) {
+  if (isCancel2(linkedProjects)) {
     cancel2("Cancelled.");
     process.exit(0);
   }
-  const selectedProjectNames = linkedProjects;
-  if (selectedProjectNames.length === 0) {
+  const selectedKeys = linkedProjects;
+  if (selectedKeys.length === 0) {
     outro2("No projects selected.");
     return;
   }
-  const selectedProjects = projects.filter((p) => selectedProjectNames.includes(p.name));
+  const selectedProjects = projects.filter(
+    (p) => selectedKeys.includes(`${p.name}:${p.source}`)
+  );
   const s = spinner2();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs8.readFileSync(configFilePath, "utf-8");
+  let configContent = fs7.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -887,9 +729,10 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
       while (insertIndex < lines.length && lines[insertIndex]?.startsWith("  - ")) {
         insertIndex++;
       }
-      for (const name of selectedProjectNames) {
-        if (!configContent.includes(`  - ${name}`)) {
-          lines.splice(insertIndex, 0, `  - ${name}`);
+      for (const project of selectedProjects) {
+        const entry = `  - ${project.name}:${project.source}`;
+        if (!configContent.includes(entry)) {
+          lines.splice(insertIndex, 0, entry);
           insertIndex++;
         }
       }
@@ -899,56 +742,54 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     configContent += `
 linked_projects:
 `;
-    selectedProjectNames.forEach((name) => {
-      configContent += `  - ${name}
+    selectedProjects.forEach((project) => {
+      configContent += `  - ${project.name}:${project.source}
 `;
     });
   }
-  fs8.writeFileSync(configFilePath, configContent);
+  fs7.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} ${pc3.dim(`(${p.source})`)}`),
-    ``,
-    `Workspace file: ${pc3.cyan(workspaceFile)}`,
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc2.dim(`(${p.source})`)}`),
     ``,
-    pc3.dim("Includes: knowledge, refs, tasks folders")
+    `Workspace file: ${pc2.cyan(workspaceFile)}`
   ];
   note2(summary.join("\n"), "Link Summary");
-  outro2(pc3.green(`\u2713 Projects linked! Open ${pc3.bold(workspaceFile)} in VSCode to access linked knowledge.`));
+  outro2(pc2.green(`\u2713 Projects linked! Open ${pc2.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 isCancel4 } from "@clack/prompts";
-import pc4 from "picocolors";
-import * as fs9 from "fs";
-import * as path8 from "path";
+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";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path7.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs9.existsSync(path8.join(localPath, dir))
+    (dir) => fs8.existsSync(path7.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
-    outro3(pc4.yellow("No data found in workspace storage to sync."));
+    outro3(pc3.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: ${pc4.cyan(globalPath)}`,
+Destination: ${pc3.cyan(globalPath)}`,
     "Sync Preview"
   );
   const shouldSync = await confirm2({
     message: "Proceed with sync to global storage?",
     initialValue: true
   });
-  if (isCancel4(shouldSync) || !shouldSync) {
+  if (isCancel3(shouldSync) || !shouldSync) {
     outro3("Sync cancelled.");
     return;
   }
@@ -957,27 +798,27 @@ Destination: ${pc4.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path8.join(localPath, dir);
-      const destDir = path8.join(globalPath, dir);
+      const srcDir = path7.join(localPath, dir);
+      const destDir = path7.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
     const configFilePath = getConfigPath(workspacePath);
-    let configContent = fs9.readFileSync(configFilePath, "utf-8");
+    let configContent = fs8.readFileSync(configFilePath, "utf-8");
     configContent = configContent.replace(/mode:\s*workspace/, "mode: both");
-    fs9.writeFileSync(configFilePath, configContent);
+    fs8.writeFileSync(configFilePath, configContent);
     s.stop("Sync complete");
     const summary = [
       `Synced directories:`,
       ...existingDirs.map((d) => `  \u2713 ${d}/`),
       ``,
-      `Global path: ${pc4.cyan(globalPath)}`,
-      `Storage mode updated to: ${pc4.bold("both")}`,
+      `Global path: ${pc3.cyan(globalPath)}`,
+      `Storage mode updated to: ${pc3.bold("both")}`,
       ``,
       `Other projects can now link this knowledge!`
     ];
     note3(summary.join("\n"), "Sync Summary");
-    outro3(pc4.green("\u2713 Workspace knowledge synced to global storage!"));
+    outro3(pc3.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)}`);
@@ -986,10 +827,10 @@ Destination: ${pc4.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 isCancel5 } from "@clack/prompts";
-import pc5 from "picocolors";
-import * as fs10 from "fs";
-import * as path9 from "path";
+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";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner4();
   s.start("Checking for updates");
@@ -1013,16 +854,16 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       message: "Proceed with update?",
       initialValue: true
     });
-    if (isCancel5(shouldUpdate) || !shouldUpdate) {
+    if (isCancel4(shouldUpdate) || !shouldUpdate) {
       outro4("Update cancelled.");
       return;
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path9.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs10.readFileSync(configFilePath, "utf-8");
+    const configContent = fs9.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -1042,7 +883,7 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       `Your configuration and knowledge files were preserved.`
     ];
     note4(summary.join("\n"), "Update Summary");
-    outro4(pc5.green("\u2713 Successfully updated from package!"));
+    outro4(pc4.green("\u2713 Successfully updated from package!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
@@ -1050,8 +891,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path9.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -1066,7 +907,7 @@ function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot,
 
 // src/commands/wizard/index.ts
 async function runWizard() {
-  intro(pc6.cyan(pc6.inverse(" RRCE-Workflow Setup ")));
+  intro(pc5.cyan(pc5.inverse(" RRCE-Workflow Setup ")));
   const s = spinner5();
   s.start("Detecting environment");
   const workspacePath = detectWorkspaceRoot();
@@ -1075,8 +916,8 @@ async function runWizard() {
   await new Promise((r) => setTimeout(r, 800));
   s.stop("Environment detected");
   note5(
-    `Git User:  ${pc6.bold(gitUser || "(not found)")}
-Workspace: ${pc6.bold(workspaceName)}`,
+    `Git User:  ${pc5.bold(gitUser || "(not found)")}
+Workspace: ${pc5.bold(workspaceName)}`,
     "Context"
   );
   const detectedProjects = scanForProjects({
@@ -1085,18 +926,18 @@ Workspace: ${pc6.bold(workspaceName)}`,
     scanSiblings: true
   });
   const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs11.existsSync(configFilePath);
+  const isAlreadyConfigured = fs10.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs11.readFileSync(configFilePath, "utf-8");
+      const configContent = fs10.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace|both)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs11.existsSync(localDataPath);
+  const hasLocalData = fs10.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     if (detectedProjects.length > 0) {
@@ -1119,7 +960,7 @@ Workspace: ${pc6.bold(workspaceName)}`,
       message: "This workspace is already configured. What would you like to do?",
       options: menuOptions
     });
-    if (isCancel6(action) || action === "exit") {
+    if (isCancel5(action) || action === "exit") {
       outro5("Exited.");
       process.exit(0);
     }
@@ -1140,12 +981,12 @@ Workspace: ${pc6.bold(workspaceName)}`,
 }
 
 // src/commands/selector.ts
-import { intro as intro2, select as select3, note as note6, cancel as cancel6, isCancel as isCancel7, outro as outro6 } from "@clack/prompts";
-import pc7 from "picocolors";
-import * as path10 from "path";
+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";
 async function runSelector() {
-  const workspaceName = path10.basename(process.cwd());
-  intro2(pc7.cyan(pc7.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const workspaceName = path9.basename(process.cwd());
+  intro2(pc6.cyan(pc6.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {
     cancel6("No agents found. Run `rrce-workflow` to set up.");
@@ -1159,14 +1000,14 @@ async function runSelector() {
       hint: p.frontmatter.description
     }))
   });
-  if (isCancel7(selection)) {
+  if (isCancel6(selection)) {
     cancel6("Selection cancelled.");
     process.exit(0);
   }
   const prompt = selection;
   note6(
     `Use this agent in your IDE by invoking:
-${pc7.bold(pc7.cyan(`@${prompt.frontmatter.name}`))}`,
+${pc6.bold(pc6.cyan(`@${prompt.frontmatter.name}`))}`,
     "Agent Selected"
   );
   outro6("Done");

package/package.json

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