rrce-workflow 0.2.15 → 0.2.17

package/dist/index.js

@@ -49,18 +49,6 @@ function getWorkspaceName(workspaceRoot) {
 function getRRCEHome() {
   return RRCE_HOME;
 }
-function listGlobalProjects(excludeWorkspace) {
-  const workspacesDir = path.join(RRCE_HOME, "workspaces");
-  if (!fs.existsSync(workspacesDir)) {
-    return [];
-  }
-  try {
-    const entries = fs.readdirSync(workspacesDir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory() && entry.name !== excludeWorkspace).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
 function getLocalWorkspacePath(workspaceRoot) {
   return path.join(workspaceRoot, ".rrce-workflow");
 }
@@ -145,115 +133,9 @@ function getEffectiveRRCEHome(workspaceRoot) {
   return getDefaultRRCEHome();
 }
 
-// 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";
-
-// src/lib/prompts.ts
+// src/lib/detection.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-
-// src/types/prompt.ts
-import { z } from "zod";
-var PromptArgSchema = z.object({
-  name: z.string(),
-  default: z.string().optional(),
-  prompt: z.string().optional()
-});
-var AutoIdentitySchema = z.object({
-  user: z.string(),
-  model: z.string()
-});
-var 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(),
-  "required-args": z.array(PromptArgSchema).optional(),
-  "optional-args": z.array(PromptArgSchema).optional(),
-  "auto-identity": AutoIdentitySchema.optional()
-});
-
-// src/lib/prompts.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
-function parsePromptFile(filePath) {
-  try {
-    const fileContent = fs2.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 (!fs2.existsSync(dirPath)) {
-    return [];
-  }
-  const files = fs2.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
-  const prompts = [];
-  for (const file of files) {
-    const prompt = parsePromptFile(path2.join(dirPath, file));
-    if (prompt) {
-      prompts.push(prompt);
-    }
-  }
-  return prompts;
-}
-function getAgentCoreDir() {
-  return path2.join(__dirname, "..", "..", "agent-core");
-}
-function getAgentCorePromptsDir() {
-  return path2.join(getAgentCoreDir(), "prompts");
-}
-
-// src/commands/wizard/utils.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-function copyPromptsToDir(prompts, targetDir, extension) {
-  for (const prompt of prompts) {
-    const baseName = path3.basename(prompt.filePath, ".md");
-    const targetName = baseName + extension;
-    const targetPath = path3.join(targetDir, targetName);
-    const content = fs3.readFileSync(prompt.filePath, "utf-8");
-    fs3.writeFileSync(targetPath, content);
-  }
-}
-function copyDirRecursive(src, dest) {
-  const entries = fs3.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs3.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-// src/commands/wizard/vscode.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-
-// src/lib/detection.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
 function scanForProjects(options = {}) {
   const { excludeWorkspace, workspacePath, scanSiblings = true } = options;
   const projects = [];
@@ -278,29 +160,29 @@ function scanForProjects(options = {}) {
 }
 function scanGlobalStorage(excludeWorkspace) {
   const rrceHome = getDefaultRRCEHome();
-  const workspacesDir = path4.join(rrceHome, "workspaces");
+  const workspacesDir = path2.join(rrceHome, "workspaces");
   const projects = [];
-  if (!fs4.existsSync(workspacesDir)) {
+  if (!fs2.existsSync(workspacesDir)) {
     return projects;
   }
   try {
-    const entries = fs4.readdirSync(workspacesDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(workspacesDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === excludeWorkspace) continue;
-      const projectDataPath = path4.join(workspacesDir, entry.name);
-      const knowledgePath = path4.join(projectDataPath, "knowledge");
-      const refsPath = path4.join(projectDataPath, "refs");
-      const tasksPath = path4.join(projectDataPath, "tasks");
+      const projectDataPath = path2.join(workspacesDir, entry.name);
+      const knowledgePath = path2.join(projectDataPath, "knowledge");
+      const refsPath = path2.join(projectDataPath, "refs");
+      const tasksPath = path2.join(projectDataPath, "tasks");
       projects.push({
         name: entry.name,
         path: projectDataPath,
         // For global projects, path is the data path
         dataPath: projectDataPath,
         source: "global",
-        knowledgePath: fs4.existsSync(knowledgePath) ? knowledgePath : void 0,
-        refsPath: fs4.existsSync(refsPath) ? refsPath : void 0,
-        tasksPath: fs4.existsSync(tasksPath) ? tasksPath : void 0
+        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
       });
     }
   } catch {
@@ -308,32 +190,32 @@ function scanGlobalStorage(excludeWorkspace) {
   return projects;
 }
 function scanSiblingDirectories(workspacePath, excludeWorkspace) {
-  const parentDir = path4.dirname(workspacePath);
+  const parentDir = path2.dirname(workspacePath);
   const projects = [];
   try {
-    const entries = fs4.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const projectPath = path4.join(parentDir, entry.name);
+      const projectPath = path2.join(parentDir, entry.name);
       if (projectPath === workspacePath) continue;
       if (entry.name === excludeWorkspace) continue;
-      const configPath = path4.join(projectPath, ".rrce-workflow", "config.yaml");
-      if (!fs4.existsSync(configPath)) continue;
+      const configPath = path2.join(projectPath, ".rrce-workflow", "config.yaml");
+      if (!fs2.existsSync(configPath)) continue;
       const config = parseWorkspaceConfig(configPath);
       if (!config) continue;
-      const dataPath = path4.join(projectPath, ".rrce-workflow");
-      const knowledgePath = path4.join(dataPath, "knowledge");
-      const refsPath = path4.join(dataPath, "refs");
-      const tasksPath = path4.join(dataPath, "tasks");
+      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: fs4.existsSync(knowledgePath) ? knowledgePath : void 0,
-        refsPath: fs4.existsSync(refsPath) ? refsPath : void 0,
-        tasksPath: fs4.existsSync(tasksPath) ? tasksPath : void 0
+        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
       });
     }
   } catch {
@@ -342,7 +224,7 @@ function scanSiblingDirectories(workspacePath, excludeWorkspace) {
 }
 function parseWorkspaceConfig(configPath) {
   try {
-    const content = fs4.readFileSync(configPath, "utf-8");
+    const content = fs2.readFileSync(configPath, "utf-8");
     const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
     const modeMatch = content.match(/mode:\s*(global|workspace|both)/);
     const linkedProjects = [];
@@ -357,7 +239,7 @@ function parseWorkspaceConfig(configPath) {
       }
     }
     return {
-      name: nameMatch?.[1]?.trim() || path4.basename(path4.dirname(path4.dirname(configPath))),
+      name: nameMatch?.[1]?.trim() || path2.basename(path2.dirname(path2.dirname(configPath))),
       storageMode: modeMatch?.[1] || "global",
       linkedProjects: linkedProjects.length > 0 ? linkedProjects : void 0
     };
@@ -365,44 +247,112 @@ 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;
+
+// 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";
+
+// src/lib/prompts.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+
+// src/types/prompt.ts
+import { z } from "zod";
+var PromptArgSchema = z.object({
+  name: z.string(),
+  default: z.string().optional(),
+  prompt: z.string().optional()
+});
+var AutoIdentitySchema = z.object({
+  user: z.string(),
+  model: z.string()
+});
+var 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(),
+  "required-args": z.array(PromptArgSchema).optional(),
+  "optional-args": z.array(PromptArgSchema).optional(),
+  "auto-identity": AutoIdentitySchema.optional()
+});
+
+// src/lib/prompts.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+function parsePromptFile(filePath) {
+  try {
+    const fileContent = fs3.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 getProjectFolders(project) {
-  const folders = [];
-  if (project.knowledgePath) {
-    folders.push({
-      path: project.knowledgePath,
-      type: "knowledge",
-      displayName: `\u{1F4DA} ${project.name} (knowledge)`
-    });
+function loadPromptsFromDir(dirPath) {
+  if (!fs3.existsSync(dirPath)) {
+    return [];
   }
-  if (project.refsPath) {
-    folders.push({
-      path: project.refsPath,
-      type: "refs",
-      displayName: `\u{1F4CE} ${project.name} (refs)`
-    });
+  const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
+  const prompts = [];
+  for (const file of files) {
+    const prompt = parsePromptFile(path3.join(dirPath, file));
+    if (prompt) {
+      prompts.push(prompt);
+    }
   }
-  if (project.tasksPath) {
-    folders.push({
-      path: project.tasksPath,
-      type: "tasks",
-      displayName: `\u{1F4CB} ${project.name} (tasks)`
-    });
+  return prompts;
+}
+function getAgentCoreDir() {
+  return path3.join(__dirname, "..", "..", "agent-core");
+}
+function getAgentCorePromptsDir() {
+  return path3.join(getAgentCoreDir(), "prompts");
+}
+
+// src/commands/wizard/utils.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function copyPromptsToDir(prompts, targetDir, extension) {
+  for (const prompt of prompts) {
+    const baseName = path4.basename(prompt.filePath, ".md");
+    const targetName = baseName + extension;
+    const targetPath = path4.join(targetDir, targetName);
+    const content = fs4.readFileSync(prompt.filePath, "utf-8");
+    fs4.writeFileSync(targetPath, content);
+  }
+}
+function copyDirRecursive(src, dest) {
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      ensureDir(destPath);
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs4.copyFileSync(srcPath, destPath);
+    }
   }
-  return folders;
 }
 
 // src/commands/wizard/vscode.ts
-var REFERENCE_GROUP_PREFIX = "\u{1F4C1} References";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
   const workspaceFilePath = path5.join(workspacePath, `${workspaceName}.code-workspace`);
   let workspace;
@@ -419,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]`
+        });
       }
     }
   }
@@ -482,12 +419,17 @@ 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));
 }
 
@@ -647,10 +589,13 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
         }
         return multiselect({
           message: "Link knowledge from other projects?",
-          options: existingProjects.map((name) => ({
-            value: name,
-            label: name,
-            hint: `~/.rrce-workflow/workspaces/${name}/knowledge`
+          options: existingProjects.map((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: false
         });
@@ -686,7 +631,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       globalPath: customGlobalPath,
       tools: config.tools,
       linkedProjects: config.linkedProjects
-    }, workspacePath, workspaceName);
+    }, workspacePath, workspaceName, existingProjects);
     s.stop("Configuration generated");
     const dataPaths = getDataPaths(
       config.storageMode,
@@ -782,7 +727,7 @@ Please choose a custom path instead.`,
   }
   return customPath;
 }
-async function generateConfiguration(config, workspacePath, workspaceName) {
+async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
@@ -836,7 +781,10 @@ linked_projects:
   }
   fs7.writeFileSync(workspaceConfigPath, configContent);
   if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
-    generateVSCodeWorkspace(workspacePath, workspaceName, config.linkedProjects, config.globalPath);
+    const selectedProjects = allProjects.filter(
+      (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
+    );
+    generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
@@ -858,13 +806,12 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
 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";
-async function runLinkProjectsFlow(workspacePath, workspaceName, existingProjects) {
-  const detectedProjects = scanForProjects({
+async function runLinkProjectsFlow(workspacePath, workspaceName) {
+  const projects = scanForProjects({
     excludeWorkspace: workspaceName,
     workspacePath,
     scanSiblings: true
   });
-  const projects = existingProjects ? existingProjects.map((name) => ({ name, source: "global" })) : detectedProjects;
   if (projects.length === 0) {
     outro2(pc3.yellow("No other projects found. Try setting up another project first."));
     return;
@@ -873,9 +820,12 @@ async function runLinkProjectsFlow(workspacePath, workspaceName, existingProject
   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} ${pc3.dim(`(${project.source})`)}`,
+      hint: pc3.dim(
+        project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
+      )
     })),
     required: true
   });
@@ -883,12 +833,14 @@ async function runLinkProjectsFlow(workspacePath, workspaceName, existingProject
     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);
@@ -901,9 +853,10 @@ async function runLinkProjectsFlow(workspacePath, workspaceName, existingProject
       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++;
         }
       }
@@ -913,8 +866,8 @@ async function runLinkProjectsFlow(workspacePath, workspaceName, existingProject
     configContent += `
 linked_projects:
 `;
-    selectedProjectNames.forEach((name) => {
-      configContent += `  - ${name}
+    selectedProjects.forEach((project) => {
+      configContent += `  - ${project.name}:${project.source}
 `;
     });
   }
@@ -926,12 +879,10 @@ linked_projects:
     `Linked projects:`,
     ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc3.dim(`(${p.source})`)}`),
     ``,
-    `Workspace file: ${pc3.cyan(workspaceFile)}`,
-    ``,
-    pc3.dim("Includes: knowledge, refs, tasks folders")
+    `Workspace file: ${pc3.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(pc3.green(`\u2713 Projects linked! Open ${pc3.bold(workspaceFile)} in VSCode to access linked data.`));
 }
 
 // src/commands/wizard/sync-flow.ts
@@ -1093,7 +1044,11 @@ async function runWizard() {
 Workspace: ${pc6.bold(workspaceName)}`,
     "Context"
   );
-  const existingProjects = listGlobalProjects(workspaceName);
+  const detectedProjects = scanForProjects({
+    excludeWorkspace: workspaceName,
+    workspacePath,
+    scanSiblings: true
+  });
   const configFilePath = getConfigPath(workspacePath);
   const isAlreadyConfigured = fs11.existsSync(configFilePath);
   let currentStorageMode = null;
@@ -1109,11 +1064,11 @@ Workspace: ${pc6.bold(workspaceName)}`,
   const hasLocalData = fs11.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
-    if (existingProjects.length > 0) {
+    if (detectedProjects.length > 0) {
       menuOptions.push({
         value: "link",
         label: "Link other project knowledge",
-        hint: `${existingProjects.length} projects available`
+        hint: `${detectedProjects.length} projects detected (global + sibling)`
       });
     }
     if (currentStorageMode === "workspace" && hasLocalData) {
@@ -1134,7 +1089,7 @@ Workspace: ${pc6.bold(workspaceName)}`,
       process.exit(0);
     }
     if (action === "link") {
-      await runLinkProjectsFlow(workspacePath, workspaceName, existingProjects);
+      await runLinkProjectsFlow(workspacePath, workspaceName);
       return;
     }
     if (action === "sync-global") {
@@ -1146,7 +1101,7 @@ Workspace: ${pc6.bold(workspaceName)}`,
       return;
     }
   }
-  await runSetupFlow(workspacePath, workspaceName, existingProjects);
+  await runSetupFlow(workspacePath, workspaceName, detectedProjects);
 }
 
 // src/commands/selector.ts

package/package.json

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