rrce-workflow 0.1.2 → 0.1.4

package/README.md

@@ -66,9 +66,23 @@ project:
 
 | Mode | Location | Use Case |
 |------|----------|----------|
-| `global` | `~/.rrce-workflow/workspaces/<name>/` | Non-intrusive |
-| `workspace` | `.rrce-workflow/` | Portable with repo |
-| `both` | Both locations | Redundancy |
+| `global` | `~/.rrce-workflow/workspaces/<name>/` | Non-intrusive, cross-project access |
+| `workspace` | `.rrce-workflow/` | Portable with repo, team sharing |
+| `both` | Both locations (synced) | Redundancy + cross-project access |
+
+When `both` is selected, data is stored in **both** locations simultaneously:
+- Primary (for reads): `<workspace>/.rrce-workflow/`
+- Secondary (auto-synced): `~/.rrce-workflow/workspaces/<name>/`
+
+Each storage location contains:
+```
+<storage-path>/
+├── knowledge/      # Project context and domain knowledge
+├── prompts/        # Agent prompt files
+├── refs/           # External references
+├── tasks/          # Task artifacts and metadata
+└── templates/      # Output templates
+```
 
 ## Requirements
 

package/agent-core/prompts/documentation.md

@@ -39,8 +39,11 @@ Path Resolution
 - Storage mode: Determined by `.rrce-workflow.yaml` → global config → default (`global`)
   - `global`: Data in `~/.rrce-workflow/workspaces/<workspace-name>/`
   - `workspace`: Data in `<workspace>/.rrce-workflow/`
-  - `both`: Dual storage with sync
-- Data path: `{{RRCE_DATA}}` (resolves based on storage mode)
+  - `both`: **Dual storage** - data stored in BOTH locations simultaneously
+    - Primary (for reads): `<workspace>/.rrce-workflow/`
+    - Secondary (auto-synced): `~/.rrce-workflow/workspaces/<workspace-name>/`
+    - When writing, always write to `{{RRCE_DATA}}` - the system ensures both locations stay in sync
+- Data path: `{{RRCE_DATA}}` (resolves to primary storage based on mode)
 - Global home: `{{RRCE_HOME}}` (always `~/.rrce-workflow`)
 - Workspace root: `{{WORKSPACE_ROOT}}` (auto-detected or via `$RRCE_WORKSPACE`)
 - Workspace name: `{{WORKSPACE_NAME}}` (from config or directory name)

package/agent-core/prompts/executor.md

@@ -35,8 +35,11 @@ Path Resolution
 - Storage mode: Determined by `.rrce-workflow.yaml` → global config → default (`global`)
   - `global`: Data in `~/.rrce-workflow/workspaces/<workspace-name>/`
   - `workspace`: Data in `<workspace>/.rrce-workflow/`
-  - `both`: Dual storage with sync
-- Data path: `{{RRCE_DATA}}` (resolves based on storage mode)
+  - `both`: **Dual storage** - data stored in BOTH locations simultaneously
+    - Primary (for reads): `<workspace>/.rrce-workflow/`
+    - Secondary (auto-synced): `~/.rrce-workflow/workspaces/<workspace-name>/`
+    - When writing, always write to `{{RRCE_DATA}}` - the system ensures both locations stay in sync
+- Data path: `{{RRCE_DATA}}` (resolves to primary storage based on mode)
 - Global home: `{{RRCE_HOME}}` (always `~/.rrce-workflow`)
 - Workspace root: `{{WORKSPACE_ROOT}}` (auto-detected or via `$RRCE_WORKSPACE`)
 - Workspace name: `{{WORKSPACE_NAME}}` (from config or directory name)

package/agent-core/prompts/init.md

@@ -32,8 +32,11 @@ Path Resolution
 - Storage mode: Determined by `.rrce-workflow.yaml` → global config → default (`global`)
   - `global`: Data stored in `~/.rrce-workflow/workspaces/<workspace-name>/`
   - `workspace`: Data stored in `<workspace>/.rrce-workflow/`
-  - `both`: Dual storage with sync
-- Data path: `{{RRCE_DATA}}` (resolves based on storage mode)
+  - `both`: **Dual storage** - data stored in BOTH locations simultaneously
+    - Primary (for reads): `<workspace>/.rrce-workflow/`
+    - Secondary (auto-synced): `~/.rrce-workflow/workspaces/<workspace-name>/`
+    - When writing, always write to `{{RRCE_DATA}}` - the system ensures both locations stay in sync
+- Data path: `{{RRCE_DATA}}` (resolves to primary storage based on mode)
 - Global home: `{{RRCE_HOME}}` (always `~/.rrce-workflow`)
 - Workspace root: `{{WORKSPACE_ROOT}}` (auto-detected or via `$RRCE_WORKSPACE`)
 - Workspace name: `{{WORKSPACE_NAME}}` (from config or directory name)

package/agent-core/prompts/planning_orchestrator.md

@@ -32,8 +32,11 @@ Path Resolution
 - Storage mode: Determined by `.rrce-workflow.yaml` → global config → default (`global`)
   - `global`: Data in `~/.rrce-workflow/workspaces/<workspace-name>/`
   - `workspace`: Data in `<workspace>/.rrce-workflow/`
-  - `both`: Dual storage with sync
-- Data path: `{{RRCE_DATA}}` (resolves based on storage mode)
+  - `both`: **Dual storage** - data stored in BOTH locations simultaneously
+    - Primary (for reads): `<workspace>/.rrce-workflow/`
+    - Secondary (auto-synced): `~/.rrce-workflow/workspaces/<workspace-name>/`
+    - When writing, always write to `{{RRCE_DATA}}` - the system ensures both locations stay in sync
+- Data path: `{{RRCE_DATA}}` (resolves to primary storage based on mode)
 - Global home: `{{RRCE_HOME}}` (always `~/.rrce-workflow`)
 - Workspace root: `{{WORKSPACE_ROOT}}` (auto-detected or via `$RRCE_WORKSPACE`)
 - Workspace name: `{{WORKSPACE_NAME}}` (from config or directory name)

package/agent-core/prompts/research_discussion.md

@@ -39,8 +39,11 @@ Path Resolution
 - Storage mode: Determined by `.rrce-workflow.yaml` → global config → default (`global`)
   - `global`: Data in `~/.rrce-workflow/workspaces/<workspace-name>/`
   - `workspace`: Data in `<workspace>/.rrce-workflow/`
-  - `both`: Dual storage with sync
-- Data path: `{{RRCE_DATA}}` (resolves based on storage mode)
+  - `both`: **Dual storage** - data stored in BOTH locations simultaneously
+    - Primary (for reads): `<workspace>/.rrce-workflow/`
+    - Secondary (auto-synced): `~/.rrce-workflow/workspaces/<workspace-name>/`
+    - When writing, always write to `{{RRCE_DATA}}` - the system ensures both locations stay in sync
+- Data path: `{{RRCE_DATA}}` (resolves to primary storage based on mode)
 - Global home: `{{RRCE_HOME}}` (always `~/.rrce-workflow`)
 - Workspace root: `{{WORKSPACE_ROOT}}` (auto-detected or via `$RRCE_WORKSPACE`)
 - Workspace name: `{{WORKSPACE_NAME}}` (from config or directory name)

package/agent-core/prompts/sync.md

@@ -32,8 +32,11 @@ Path Resolution
 - Storage mode: Determined by `.rrce-workflow.yaml` → global config → default (`global`)
   - `global`: Data in `~/.rrce-workflow/workspaces/<workspace-name>/`
   - `workspace`: Data in `<workspace>/.rrce-workflow/`
-  - `both`: Dual storage with sync
-- Data path: `{{RRCE_DATA}}` (resolves based on storage mode)
+  - `both`: **Dual storage** - data stored in BOTH locations simultaneously
+    - Primary (for reads): `<workspace>/.rrce-workflow/`
+    - Secondary (auto-synced): `~/.rrce-workflow/workspaces/<workspace-name>/`
+    - When writing, always write to `{{RRCE_DATA}}` - the system ensures both locations stay in sync
+- Data path: `{{RRCE_DATA}}` (resolves to primary storage based on mode)
 - Global home: `{{RRCE_HOME}}` (always `~/.rrce-workflow`)
 - Workspace root: `{{WORKSPACE_ROOT}}` (auto-detected or via `$RRCE_WORKSPACE`)
 - Workspace name: `{{WORKSPACE_NAME}}` (from config or directory name)

package/agent-core/templates/documentation_output.md

@@ -1,3 +1,13 @@
+<!--
+  RRCE Template Variables:
+  - {{RRCE_DATA}}: Primary storage path (resolves based on storage mode in .rrce-workflow.yaml)
+      - global: ~/.rrce-workflow/workspaces/<workspace-name>/
+      - workspace: <workspace>/.rrce-workflow/
+      - both: <workspace>/.rrce-workflow/ (primary, auto-synced to global)
+  - {{RRCE_HOME}}: Always ~/.rrce-workflow
+  - {{WORKSPACE_ROOT}}: Workspace root directory
+  - {{WORKSPACE_NAME}}: Workspace name from config or directory name
+-->
 # Handover Note – {{task_title}}
 
 - Task ID: `{{task_id}}`

package/agent-core/templates/executor_output.md

@@ -1,3 +1,13 @@
+<!--
+  RRCE Template Variables:
+  - {{RRCE_DATA}}: Primary storage path (resolves based on storage mode in .rrce-workflow.yaml)
+      - global: ~/.rrce-workflow/workspaces/<workspace-name>/
+      - workspace: <workspace>/.rrce-workflow/
+      - both: <workspace>/.rrce-workflow/ (primary, auto-synced to global)
+  - {{RRCE_HOME}}: Always ~/.rrce-workflow
+  - {{WORKSPACE_ROOT}}: Workspace root directory
+  - {{WORKSPACE_NAME}}: Workspace name from config or directory name
+-->
 # Execution Log – {{task_title}}
 
 - Task ID: `{{task_id}}`

package/agent-core/templates/init_output.md

@@ -1,3 +1,13 @@
+<!--
+  RRCE Template Variables:
+  - {{RRCE_DATA}}: Primary storage path (resolves based on storage mode in .rrce-workflow.yaml)
+      - global: ~/.rrce-workflow/workspaces/<workspace-name>/
+      - workspace: <workspace>/.rrce-workflow/
+      - both: <workspace>/.rrce-workflow/ (primary, auto-synced to global)
+  - {{RRCE_HOME}}: Always ~/.rrce-workflow
+  - {{WORKSPACE_ROOT}}: Workspace root directory
+  - {{WORKSPACE_NAME}}: Workspace name from config or directory name
+-->
 # Project Context – {{project_name}}
 
 - Initialized: `{{date}}`

package/agent-core/templates/planning_output.md

@@ -1,3 +1,13 @@
+<!--
+  RRCE Template Variables:
+  - {{RRCE_DATA}}: Primary storage path (resolves based on storage mode in .rrce-workflow.yaml)
+      - global: ~/.rrce-workflow/workspaces/<workspace-name>/
+      - workspace: <workspace>/.rrce-workflow/
+      - both: <workspace>/.rrce-workflow/ (primary, auto-synced to global)
+  - {{RRCE_HOME}}: Always ~/.rrce-workflow
+  - {{WORKSPACE_ROOT}}: Workspace root directory
+  - {{WORKSPACE_NAME}}: Workspace name from config or directory name
+-->
 # Execution Plan – {{task_title}}
 
 - Task ID: `{{task_id}}`

package/agent-core/templates/research_output.md

@@ -1,3 +1,13 @@
+<!--
+  RRCE Template Variables:
+  - {{RRCE_DATA}}: Primary storage path (resolves based on storage mode in .rrce-workflow.yaml)
+      - global: ~/.rrce-workflow/workspaces/<workspace-name>/
+      - workspace: <workspace>/.rrce-workflow/
+      - both: <workspace>/.rrce-workflow/ (primary, auto-synced to global)
+  - {{RRCE_HOME}}: Always ~/.rrce-workflow
+  - {{WORKSPACE_ROOT}}: Workspace root directory
+  - {{WORKSPACE_NAME}}: Workspace name from config or directory name
+-->
 # Research Brief – {{task_title}}
 
 - Task ID: `{{task_id}}`

package/bin/rrce-workflow.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env bun
-import "../src/index.tsx";
+import "../src/index.ts";

package/package.json

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

package/src/commands/wizard.ts

@@ -3,9 +3,9 @@ import pc from 'picocolors';
 import * as fs from 'fs';
 import * as path from 'path';
 import { getGitUser } from '../lib/git';
-import { detectWorkspaceRoot, getWorkspaceName, resolveDataPath, ensureDir, getAgentPromptPath } from '../lib/paths';
+import { detectWorkspaceRoot, getWorkspaceName, resolveAllDataPaths, ensureDir, getAgentPromptPath, syncMetadataToAll, copyDirToAllStoragePaths, listGlobalProjects, getGlobalProjectKnowledgePath, getRRCEHome } from '../lib/paths';
 import type { StorageMode } from '../types/prompt';
-import { loadPromptsFromDir, getAgentCorePromptsDir } from '../lib/prompts';
+import { loadPromptsFromDir, getAgentCorePromptsDir, getAgentCoreDir } from '../lib/prompts';
 
 import type { ParsedPrompt } from '../types/prompt';
 
@@ -28,6 +28,38 @@ Workspace: ${pc.bold(workspaceName)}`,
     'Context'
   );
 
+  // Check for existing projects in global storage
+  const existingProjects = listGlobalProjects(workspaceName);
+  
+  // Check if already configured
+  const configFilePath = path.join(workspacePath, '.rrce-workflow.yaml');
+  const isAlreadyConfigured = fs.existsSync(configFilePath);
+
+  // If already configured and there are other projects, show menu
+  if (isAlreadyConfigured && existingProjects.length > 0) {
+    const action = await select({
+      message: 'This workspace is already configured. What would you like to do?',
+      options: [
+        { value: 'link', label: 'Link other project knowledge', hint: `${existingProjects.length} projects available` },
+        { value: 'reconfigure', label: 'Reconfigure from scratch' },
+        { value: 'exit', label: 'Exit' },
+      ],
+    });
+
+    if (isCancel(action) || action === 'exit') {
+      outro('Exited.');
+      process.exit(0);
+    }
+
+    if (action === 'link') {
+      // Link-only flow
+      await runLinkProjectsFlow(workspacePath, workspaceName, existingProjects);
+      return;
+    }
+    // Otherwise continue to full reconfigure flow
+  }
+
+  // Full setup flow
   const config = await group(
     {
       storageMode: () =>
@@ -49,6 +81,21 @@ Workspace: ${pc.bold(workspaceName)}`,
           ],
           required: false,
         }),
+      linkedProjects: () => {
+        // Only show if there are other projects to link
+        if (existingProjects.length === 0) {
+          return Promise.resolve([]);
+        }
+        return multiselect({
+          message: 'Link knowledge from other projects?',
+          options: existingProjects.map(name => ({
+            value: name,
+            label: name,
+            hint: `~/.rrce-workflow/workspaces/${name}/knowledge`
+          })),
+          required: false,
+        });
+      },
       confirm: () =>
         confirm({
           message: 'Create configuration?',
@@ -71,14 +118,39 @@ Workspace: ${pc.bold(workspaceName)}`,
   s.start('Generating configuration');
 
   try {
-     // Create config file
-    const dataPath = resolveDataPath(config.storageMode as StorageMode, workspaceName, workspacePath);
-    ensureDir(dataPath);
+    // Create data directories in all storage locations
+    const dataPaths = resolveAllDataPaths(config.storageMode as StorageMode, workspaceName, workspacePath);
+    
+    for (const dataPath of dataPaths) {
+      ensureDir(dataPath);
+      // Create agent metadata subdirectories
+      ensureDir(path.join(dataPath, 'knowledge'));
+      ensureDir(path.join(dataPath, 'refs'));
+      ensureDir(path.join(dataPath, 'tasks'));
+      ensureDir(path.join(dataPath, 'templates'));
+      ensureDir(path.join(dataPath, 'prompts'));
+    }
+
+    // Get the agent-core directory path
+    const agentCoreDir = getAgentCoreDir();
+    
+    // Sync metadata (knowledge, refs, tasks) from agent-core to all storage locations
+    syncMetadataToAll(agentCoreDir, dataPaths);
+    
+    // Also copy templates to all storage locations
+    copyDirToAllStoragePaths(path.join(agentCoreDir, 'templates'), 'templates', dataPaths);
 
     // Load prompts
     const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
 
-    // Copy prompts
+    // Copy prompts to all storage locations (for cross-project access)
+    for (const dataPath of dataPaths) {
+      const promptsDir = path.join(dataPath, 'prompts');
+      ensureDir(promptsDir);
+      copyPromptsToDir(prompts, promptsDir, '.md');
+    }
+
+    // Copy prompts to tool-specific locations (for IDE integration)
     const selectedTools = config.tools as string[];
     
     if (selectedTools.includes('copilot')) {
@@ -94,8 +166,9 @@ Workspace: ${pc.bold(workspaceName)}`,
     }
 
     // Create workspace config
+    const linkedProjects = config.linkedProjects as string[];
     const workspaceConfigPath = path.join(workspacePath, '.rrce-workflow.yaml');
-    const configContent = `# RRCE-Workflow Configuration
+    let configContent = `# RRCE-Workflow Configuration
 version: 1
 
 storage:
@@ -103,12 +176,50 @@ storage:
 
 project:
   name: "${workspaceName}"
+
+tools:
+  copilot: ${selectedTools.includes('copilot')}
+  antigravity: ${selectedTools.includes('antigravity')}
 `;
+
+    // Add linked projects if any
+    if (linkedProjects.length > 0) {
+      configContent += `\nlinked_projects:\n`;
+      linkedProjects.forEach(name => {
+        configContent += `  - ${name}\n`;
+      });
+    }
+
     fs.writeFileSync(workspaceConfigPath, configContent);
 
+    // Generate VSCode workspace file if using copilot or has linked projects
+    if (selectedTools.includes('copilot') || linkedProjects.length > 0) {
+      generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects);
+    }
+
     s.stop('Configuration generated');
     
-    outro(pc.green(`✓ Setup complete! You can now run "rrce-workflow select" to start using agents.`));
+    // Show summary
+    const summary = [
+      `Storage: ${config.storageMode === 'both' ? 'global + workspace' : config.storageMode}`,
+    ];
+    
+    if (dataPaths.length > 0) {
+      summary.push(`Data paths:`);
+      dataPaths.forEach(p => summary.push(`  - ${p}`));
+    }
+    
+    if (selectedTools.length > 0) {
+      summary.push(`Tools: ${selectedTools.join(', ')}`);
+    }
+
+    if (linkedProjects.length > 0) {
+      summary.push(`Linked projects: ${linkedProjects.join(', ')}`);
+    }
+    
+    note(summary.join('\n'), 'Setup Summary');
+    
+    outro(pc.green(`✓ Setup complete! Your agents are ready to use.`));
 
   } catch (error) {
     s.stop('Error occurred');
@@ -128,3 +239,142 @@ function copyPromptsToDir(prompts: ParsedPrompt[], targetDir: string, extension:
     fs.writeFileSync(targetPath, content);
   }
 }
+
+interface VSCodeWorkspaceFolder {
+  path: string;
+  name?: string;
+}
+
+interface VSCodeWorkspace {
+  folders: VSCodeWorkspaceFolder[];
+  settings?: Record<string, unknown>;
+}
+
+/**
+ * Generate or update VSCode workspace file with linked project knowledge folders
+ */
+function generateVSCodeWorkspace(workspacePath: string, workspaceName: string, linkedProjects: string[]) {
+  const workspaceFilePath = path.join(workspacePath, `${workspaceName}.code-workspace`);
+  
+  let workspace: VSCodeWorkspace;
+  
+  // Check if workspace file already exists
+  if (fs.existsSync(workspaceFilePath)) {
+    try {
+      const content = fs.readFileSync(workspaceFilePath, 'utf-8');
+      workspace = JSON.parse(content);
+    } catch {
+      // If parse fails, create new
+      workspace = { folders: [] };
+    }
+  } else {
+    workspace = { folders: [] };
+  }
+
+  // Ensure main workspace folder is first
+  const mainFolder: VSCodeWorkspaceFolder = { path: '.' };
+  const existingMainIndex = workspace.folders.findIndex(f => f.path === '.');
+  if (existingMainIndex === -1) {
+    workspace.folders.unshift(mainFolder);
+  }
+
+  // Add linked project knowledge folders
+  const rrceHome = getRRCEHome();
+  for (const projectName of linkedProjects) {
+    const knowledgePath = path.join(rrceHome, 'workspaces', projectName, 'knowledge');
+    const folderEntry: VSCodeWorkspaceFolder = {
+      path: knowledgePath,
+      name: `📚 ${projectName} (knowledge)`
+    };
+
+    // Check if already exists
+    const existingIndex = workspace.folders.findIndex(f => f.path === knowledgePath);
+    if (existingIndex === -1) {
+      workspace.folders.push(folderEntry);
+    }
+  }
+
+  // Write workspace file
+  fs.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
+}
+
+/**
+ * Run the link-only flow for adding other project knowledge to an existing workspace
+ */
+async function runLinkProjectsFlow(workspacePath: string, workspaceName: string, existingProjects: string[]) {
+  const linkedProjects = await multiselect({
+    message: 'Select projects to link:',
+    options: existingProjects.map(name => ({
+      value: name,
+      label: name,
+      hint: `~/.rrce-workflow/workspaces/${name}/knowledge`
+    })),
+    required: true,
+  });
+
+  if (isCancel(linkedProjects)) {
+    cancel('Cancelled.');
+    process.exit(0);
+  }
+
+  const selectedProjects = linkedProjects as string[];
+
+  if (selectedProjects.length === 0) {
+    outro('No projects selected.');
+    return;
+  }
+
+  const s = spinner();
+  s.start('Linking projects');
+
+  // Update .rrce-workflow.yaml with linked projects
+  const configFilePath = path.join(workspacePath, '.rrce-workflow.yaml');
+  let configContent = fs.readFileSync(configFilePath, 'utf-8');
+
+  // Check if linked_projects section exists
+  if (configContent.includes('linked_projects:')) {
+    // Append to existing section - find and update
+    const lines = configContent.split('\n');
+    const linkedIndex = lines.findIndex(l => l.trim() === 'linked_projects:');
+    if (linkedIndex !== -1) {
+      // Find where to insert new projects (after existing ones)
+      let insertIndex = linkedIndex + 1;
+      while (insertIndex < lines.length && lines[insertIndex]?.startsWith('  - ')) {
+        insertIndex++;
+      }
+      // Add new projects that aren't already there
+      for (const name of selectedProjects) {
+        if (!configContent.includes(`  - ${name}`)) {
+          lines.splice(insertIndex, 0, `  - ${name}`);
+          insertIndex++;
+        }
+      }
+      configContent = lines.join('\n');
+    }
+  } else {
+    // Add new linked_projects section
+    configContent += `\nlinked_projects:\n`;
+    selectedProjects.forEach(name => {
+      configContent += `  - ${name}\n`;
+    });
+  }
+
+  fs.writeFileSync(configFilePath, configContent);
+
+  // Update VSCode workspace file
+  generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects);
+
+  s.stop('Projects linked');
+
+  // Show summary
+  const summary = [
+    `Linked projects:`,
+    ...selectedProjects.map(p => `  ✓ ${p}`),
+    ``,
+    `VSCode workspace file updated: ${workspaceName}.code-workspace`,
+  ];
+
+  note(summary.join('\n'), 'Link Summary');
+
+  outro(pc.green('✓ Projects linked successfully!'));
+}

package/src/lib/paths.ts

@@ -38,7 +38,8 @@ export function getWorkspaceName(workspaceRoot: string): string {
 }
 
 /**
- * Resolve data path based on storage mode
+ * Resolve primary data path based on storage mode
+ * Note: For 'both' mode, use resolveAllDataPaths() to get all paths
  */
 export function resolveDataPath(mode: StorageMode, workspaceName: string, workspaceRoot: string): string {
   switch (mode) {
@@ -54,6 +55,29 @@ export function resolveDataPath(mode: StorageMode, workspaceName: string, worksp
   }
 }
 
+/**
+ * Resolve ALL data paths based on storage mode
+ * Returns array of paths where data should be stored:
+ * - 'global': [~/.rrce-workflow/workspaces/<name>]
+ * - 'workspace': [<workspace>/.rrce-workflow]
+ * - 'both': [<workspace>/.rrce-workflow, ~/.rrce-workflow/workspaces/<name>]
+ */
+export function resolveAllDataPaths(mode: StorageMode, workspaceName: string, workspaceRoot: string): string[] {
+  const globalPath = path.join(RRCE_HOME, 'workspaces', workspaceName);
+  const workspacePath = path.join(workspaceRoot, '.rrce-workflow');
+  
+  switch (mode) {
+    case 'global':
+      return [globalPath];
+    case 'workspace':
+      return [workspacePath];
+    case 'both':
+      return [workspacePath, globalPath];
+    default:
+      return [globalPath];
+  }
+}
+
 /**
  * Get RRCE home directory
  */
@@ -61,6 +85,35 @@ export function getRRCEHome(): string {
   return RRCE_HOME;
 }
 
+/**
+ * List all projects in global storage
+ * @param excludeWorkspace - Workspace name to exclude from the list (typically current workspace)
+ * @returns Array of project names found in ~/.rrce-workflow/workspaces/
+ */
+export function listGlobalProjects(excludeWorkspace?: string): string[] {
+  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 [];
+  }
+}
+
+/**
+ * Get the knowledge path for a global project
+ */
+export function getGlobalProjectKnowledgePath(projectName: string): string {
+  return path.join(RRCE_HOME, 'workspaces', projectName, 'knowledge');
+}
+
 /**
  * Ensure directory exists
  */
@@ -80,3 +133,71 @@ export function getAgentPromptPath(workspaceRoot: string, tool: 'copilot' | 'ant
     return path.join(workspaceRoot, '.agent', 'workflows');
   }
 }
+
+/**
+ * Copy a file to all storage paths
+ * @param sourceFile - Absolute path to source file
+ * @param relativePath - Relative path within the data directory (e.g., 'knowledge/context.md')
+ * @param dataPaths - Array of data paths from resolveAllDataPaths()
+ */
+export function copyToAllStoragePaths(sourceFile: string, relativePath: string, dataPaths: string[]): void {
+  const content = fs.readFileSync(sourceFile);
+  
+  for (const dataPath of dataPaths) {
+    const targetPath = path.join(dataPath, relativePath);
+    ensureDir(path.dirname(targetPath));
+    fs.writeFileSync(targetPath, content);
+  }
+}
+
+/**
+ * Write content to a file in all storage paths
+ * @param content - Content to write
+ * @param relativePath - Relative path within the data directory
+ * @param dataPaths - Array of data paths from resolveAllDataPaths()
+ */
+export function writeToAllStoragePaths(content: string | Buffer, relativePath: string, dataPaths: string[]): void {
+  for (const dataPath of dataPaths) {
+    const targetPath = path.join(dataPath, relativePath);
+    ensureDir(path.dirname(targetPath));
+    fs.writeFileSync(targetPath, content);
+  }
+}
+
+/**
+ * Copy a directory recursively to all storage paths
+ * @param sourceDir - Absolute path to source directory
+ * @param relativeDir - Relative directory path within the data directory
+ * @param dataPaths - Array of data paths from resolveAllDataPaths()
+ */
+export function copyDirToAllStoragePaths(sourceDir: string, relativeDir: string, dataPaths: string[]): void {
+  if (!fs.existsSync(sourceDir)) {
+    return;
+  }
+
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const relativePath = path.join(relativeDir, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyDirToAllStoragePaths(sourcePath, relativePath, dataPaths);
+    } else {
+      copyToAllStoragePaths(sourcePath, relativePath, dataPaths);
+    }
+  }
+}
+
+/**
+ * Sync metadata subdirectories (knowledge, refs, tasks) to all storage paths
+ * Copies from agent-core to all configured storage locations
+ */
+export function syncMetadataToAll(agentCorePath: string, dataPaths: string[]): void {
+  const metadataDirs = ['knowledge', 'refs', 'tasks'];
+  
+  for (const dir of metadataDirs) {
+    const sourceDir = path.join(agentCorePath, dir);
+    copyDirToAllStoragePaths(sourceDir, dir, dataPaths);
+  }
+}

package/src/lib/prompts.ts

@@ -50,10 +50,17 @@ export function loadPromptsFromDir(dirPath: string): ParsedPrompt[] {
   return prompts;
 }
 
+/**
+ * Get the agent-core root directory
+ */
+export function getAgentCoreDir(): string {
+  // Relative to the package root
+  return path.join(import.meta.dir, '..', '..', 'agent-core');
+}
+
 /**
  * Get the agent-core prompts directory
  */
 export function getAgentCorePromptsDir(): string {
-  // Relative to the package root
-  return path.join(import.meta.dir, '..', '..', 'agent-core', 'prompts');
+  return path.join(getAgentCoreDir(), 'prompts');
 }