@kaitranntt/ccs 3.0.2 → 3.1.1

package/README.md

@@ -92,6 +92,16 @@ $env:CCS_CLAUDE_PATH = "D:\Tools\Claude\claude.exe"   # Windows
 
 **See [Troubleshooting Guide](./docs/en/troubleshooting.md#claude-cli-in-non-standard-location) for detailed setup instructions.**
 
+### Windows Symlink Support (Developer Mode)
+
+**Windows users**: Enable Developer Mode for true symlinks (better performance, instant sync):
+
+1. Open **Settings** → **Privacy & Security** → **For developers**
+2. Enable **Developer Mode**
+3. Reinstall CCS: `npm install -g @kaitranntt/ccs`
+
+**Without Developer Mode**: CCS automatically falls back to copying directories (works but no instant sync across profiles).
+
 ---
 
 ### Your First Switch
@@ -153,6 +163,44 @@ ccs work-2        # Switch to second company account
 
 ---
 
+## 📁 Shared Data Architecture
+
+**v3.1 Shared Global Data**: Commands and skills are symlinked across all profiles via `~/.ccs/shared/`, eliminating duplication.
+
+**Directory Structure**:
+```
+~/.ccs/
+├── shared/                  # Shared across all profiles
+│   ├── commands/            # Custom slash commands
+│   └── skills/              # Claude Code skills
+├── instances/               # Profile-specific data
+│   ├── work/
+│   │   ├── commands@ → ~/.ccs/shared/commands/  # Symlink
+│   │   ├── skills@ → ~/.ccs/shared/skills/      # Symlink
+│   │   ├── settings.json    # Profile-specific config
+│   │   └── sessions/        # Profile-specific sessions
+│   └── personal/
+│       └── ...
+```
+
+**Benefits**:
+- No duplication of commands/skills across profiles
+- Single source of truth for shared resources
+- Automatic migration from v3.0 (runs on first use)
+- Windows fallback: copies if symlinks unavailable (enable Developer Mode for true symlinks)
+
+**What's Shared**:
+- `.claude/commands/` - Custom slash commands
+- `.claude/skills/` - Claude Code skills
+
+**What's Profile-Specific**:
+- `settings.json` - API keys, credentials
+- `sessions/` - Conversation history
+- `todolists/` - Task tracking
+- `logs/` - Profile-specific logs
+
+---
+
 ## 🏗️ Architecture Overview
 
 **v3.0 Login-Per-Profile Model**: Each profile is an isolated Claude instance where users login directly. No credential copying or vault encryption.

package/VERSION

@@ -1 +1 @@
-3.0.2
+3.1.1

package/bin/ccs.js

@@ -133,10 +133,20 @@ function handleHelpCommand() {
   // Configuration
   console.log(colored('Configuration:', 'cyan'));
   console.log('  Config File: ~/.ccs/config.json');
+  console.log('  Profiles:    ~/.ccs/profiles.json');
+  console.log('  Instances:   ~/.ccs/instances/');
   console.log('  Settings:    ~/.ccs/*.settings.json');
   console.log('  Environment: CCS_CONFIG (override config path)');
   console.log('');
 
+  // Shared Data
+  console.log(colored('Shared Data:', 'cyan'));
+  console.log('  Commands:    ~/.ccs/shared/commands/');
+  console.log('  Skills:      ~/.ccs/shared/skills/');
+  console.log('  Agents:      ~/.ccs/shared/agents/');
+  console.log('  Note: Commands, skills, and agents are symlinked across all profiles');
+  console.log('');
+
   // Uninstall
   console.log(colored('Uninstall:', 'yellow'));
   console.log('  npm:          npm uninstall -g @kaitranntt/ccs');

package/bin/instance-manager.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const SharedManager = require('./shared-manager');
 
 /**
  * Instance Manager (Simplified)
@@ -14,6 +15,7 @@ const os = require('os');
 class InstanceManager {
   constructor() {
     this.instancesDir = path.join(os.homedir(), '.ccs', 'instances');
+    this.sharedManager = new SharedManager();
   }
 
   /**
@@ -56,7 +58,7 @@ class InstanceManager {
       // Create base directory
       fs.mkdirSync(instancePath, { recursive: true, mode: 0o700 });
 
-      // Create Claude-expected subdirectories
+      // Create Claude-expected subdirectories (profile-specific only)
       const subdirs = [
         'session-env',
         'todos',
@@ -64,9 +66,7 @@ class InstanceManager {
         'file-history',
         'shell-snapshots',
         'debug',
-        '.anthropic',
-        'commands',
-        'skills'
+        '.anthropic'
       ];
 
       subdirs.forEach(dir => {
@@ -76,7 +76,10 @@ class InstanceManager {
         }
       });
 
-      // Copy global configs if exist
+      // Symlink shared directories (Phase 1: commands, skills)
+      this.sharedManager.linkSharedDirectories(instancePath);
+
+      // Copy global configs if exist (settings.json only)
       this._copyGlobalConfigs(instancePath);
     } catch (error) {
       throw new Error(`Failed to initialize instance for ${profileName}: ${error.message}`);
@@ -158,26 +161,12 @@ class InstanceManager {
   _copyGlobalConfigs(instancePath) {
     const globalConfigDir = path.join(os.homedir(), '.claude');
 
-    // Copy settings.json if exists
+    // Copy settings.json only (commands/skills are now symlinked to shared/)
     const globalSettings = path.join(globalConfigDir, 'settings.json');
     if (fs.existsSync(globalSettings)) {
       const instanceSettings = path.join(instancePath, 'settings.json');
       fs.copyFileSync(globalSettings, instanceSettings);
     }
-
-    // Copy commands directory if exists
-    const globalCommands = path.join(globalConfigDir, 'commands');
-    if (fs.existsSync(globalCommands)) {
-      const instanceCommands = path.join(instancePath, 'commands');
-      this._copyDirectory(globalCommands, instanceCommands);
-    }
-
-    // Copy skills directory if exists
-    const globalSkills = path.join(globalConfigDir, 'skills');
-    if (fs.existsSync(globalSkills)) {
-      const instanceSkills = path.join(instancePath, 'skills');
-      this._copyDirectory(globalSkills, instanceSkills);
-    }
   }
 
   /**

package/bin/shared-manager.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * SharedManager - Manages symlinked shared directories for CCS
+ * Phase 1: Shared Global Data via Symlinks
+ *
+ * Purpose: Eliminates duplication of commands/skills across profile instances
+ * by symlinking to a single ~/.ccs/shared/ directory.
+ */
+class SharedManager {
+  constructor() {
+    this.homeDir = os.homedir();
+    this.sharedDir = path.join(this.homeDir, '.ccs', 'shared');
+    this.instancesDir = path.join(this.homeDir, '.ccs', 'instances');
+    this.sharedDirs = ['commands', 'skills', 'agents'];
+  }
+
+  /**
+   * Ensure shared directories exist
+   */
+  ensureSharedDirectories() {
+    // Create shared directory
+    if (!fs.existsSync(this.sharedDir)) {
+      fs.mkdirSync(this.sharedDir, { recursive: true, mode: 0o700 });
+    }
+
+    // Create shared subdirectories
+    for (const dir of this.sharedDirs) {
+      const dirPath = path.join(this.sharedDir, dir);
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+      }
+    }
+  }
+
+  /**
+   * Link shared directories to instance
+   * @param {string} instancePath - Path to instance directory
+   */
+  linkSharedDirectories(instancePath) {
+    this.ensureSharedDirectories();
+
+    for (const dir of this.sharedDirs) {
+      const linkPath = path.join(instancePath, dir);
+      const targetPath = path.join(this.sharedDir, dir);
+
+      // Remove existing directory/link
+      if (fs.existsSync(linkPath)) {
+        fs.rmSync(linkPath, { recursive: true, force: true });
+      }
+
+      // Create symlink
+      try {
+        fs.symlinkSync(targetPath, linkPath, 'dir');
+      } catch (err) {
+        // Windows fallback: copy directory if symlink fails
+        if (process.platform === 'win32') {
+          this._copyDirectory(targetPath, linkPath);
+          console.log(`[!] Symlink failed for ${dir}, copied instead (enable Developer Mode)`);
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if migration is needed
+   * @returns {boolean}
+   * @private
+   */
+  _needsMigration() {
+    // If shared dir doesn't exist, migration needed
+    if (!fs.existsSync(this.sharedDir)) {
+      return true;
+    }
+
+    // Check if ALL shared directories are empty
+    const allEmpty = this.sharedDirs.every(dir => {
+      const dirPath = path.join(this.sharedDir, dir);
+      if (!fs.existsSync(dirPath)) return true;
+      try {
+        const files = fs.readdirSync(dirPath);
+        return files.length === 0;
+      } catch (err) {
+        return true; // If can't read, assume empty
+      }
+    });
+
+    return allEmpty;
+  }
+
+  /**
+   * Perform migration from ~/.claude/ to ~/.ccs/shared/
+   * @returns {object} { commands: N, skills: N, agents: N }
+   * @private
+   */
+  _performMigration() {
+    const stats = { commands: 0, skills: 0, agents: 0 };
+    const claudeDir = path.join(this.homeDir, '.claude');
+
+    if (!fs.existsSync(claudeDir)) {
+      return stats; // No content to migrate
+    }
+
+    // Migrate commands
+    const commandsPath = path.join(claudeDir, 'commands');
+    if (fs.existsSync(commandsPath)) {
+      const result = this._copyDirectory(commandsPath, path.join(this.sharedDir, 'commands'));
+      stats.commands = result.copied;
+    }
+
+    // Migrate skills
+    const skillsPath = path.join(claudeDir, 'skills');
+    if (fs.existsSync(skillsPath)) {
+      const result = this._copyDirectory(skillsPath, path.join(this.sharedDir, 'skills'));
+      stats.skills = result.copied;
+    }
+
+    // Migrate agents
+    const agentsPath = path.join(claudeDir, 'agents');
+    if (fs.existsSync(agentsPath)) {
+      const result = this._copyDirectory(agentsPath, path.join(this.sharedDir, 'agents'));
+      stats.agents = result.copied;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Migrate existing instances to shared structure
+   * Idempotent: Safe to run multiple times
+   */
+  migrateToSharedStructure() {
+    console.log('[i] Checking for content migration...');
+
+    // Check if migration is needed
+    if (!this._needsMigration()) {
+      console.log('[OK] Migration not needed (shared dirs have content)');
+      return;
+    }
+
+    console.log('[i] Migrating ~/.claude/ content to ~/.ccs/shared/...');
+
+    // Create shared directories
+    this.ensureSharedDirectories();
+
+    // Perform migration
+    const stats = this._performMigration();
+
+    // Show results
+    const total = stats.commands + stats.skills + stats.agents;
+    if (total === 0) {
+      console.log('[OK] No content to migrate (empty ~/.claude/)');
+    } else {
+      const parts = [];
+      if (stats.commands > 0) parts.push(`${stats.commands} commands`);
+      if (stats.skills > 0) parts.push(`${stats.skills} skills`);
+      if (stats.agents > 0) parts.push(`${stats.agents} agents`);
+      console.log(`[OK] Migrated ${parts.join(', ')}`);
+    }
+
+    // Update all instances to use symlinks
+    if (fs.existsSync(this.instancesDir)) {
+      const instances = fs.readdirSync(this.instancesDir);
+
+      for (const instance of instances) {
+        const instancePath = path.join(this.instancesDir, instance);
+        if (fs.statSync(instancePath).isDirectory()) {
+          this.linkSharedDirectories(instancePath);
+        }
+      }
+    }
+  }
+
+  /**
+   * Copy directory recursively (SAFE: preserves existing files)
+   * @param {string} src - Source directory
+   * @param {string} dest - Destination directory
+   * @returns {object} { copied: N, skipped: N }
+   * @private
+   */
+  _copyDirectory(src, dest) {
+    if (!fs.existsSync(src)) {
+      return { copied: 0, skipped: 0 };
+    }
+
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    let copied = 0;
+    let skipped = 0;
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      // SAFETY: Skip if destination exists (preserve user modifications)
+      if (fs.existsSync(destPath)) {
+        skipped++;
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        const stats = this._copyDirectory(srcPath, destPath);
+        copied += stats.copied;
+        skipped += stats.skipped;
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+        copied++;
+      }
+    }
+
+    return { copied, skipped };
+  }
+}
+
+module.exports = SharedManager;

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.0.2"
+CCS_VERSION="3.1.1"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"
@@ -67,9 +67,15 @@ show_help() {
   echo -e "  ${YELLOW}-v, --version${RESET}               Show version and installation info"
   echo ""
   echo -e "${CYAN}Configuration:${RESET}"
-  echo -e "  Config:   ~/.ccs/config.json"
-  echo -e "  Profiles: ~/.ccs/profiles.json"
-  echo -e "  Settings: ~/.ccs/*.settings.json"
+  echo -e "  Config:    ~/.ccs/config.json"
+  echo -e "  Profiles:  ~/.ccs/profiles.json"
+  echo -e "  Instances: ~/.ccs/instances/"
+  echo -e "  Settings:  ~/.ccs/*.settings.json"
+  echo ""
+  echo -e "${CYAN}Shared Data:${RESET}"
+  echo -e "  Commands:  ~/.ccs/shared/commands/"
+  echo -e "  Skills:    ~/.ccs/shared/skills/"
+  echo -e "  Note: Commands, skills, and agents are symlinked across all profiles"
   echo ""
   echo -e "${CYAN}Documentation:${RESET}"
   echo -e "  GitHub:  ${CYAN}https://github.com/kaitranntt/ccs${RESET}"
@@ -493,6 +499,73 @@ sanitize_profile_name() {
   echo "$name" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9_-]/-/g'
 }
 
+# Link shared directories (Phase 1: Shared Global Data)
+link_shared_directories() {
+  local instance_path="$1"
+  local shared_dir="$HOME/.ccs/shared"
+
+  # Ensure shared directories exist
+  mkdir -p "$shared_dir"/{commands,skills,agents}
+
+  # Create symlinks (remove existing first if present)
+  for dir in commands skills agents; do
+    local link_path="$instance_path/$dir"
+    local target_path="$shared_dir/$dir"
+
+    # Remove existing directory/link
+    [[ -e "$link_path" ]] && rm -rf "$link_path"
+
+    # Create symlink
+    ln -sf "$target_path" "$link_path"
+  done
+}
+
+# Migrate to shared structure (Phase 1: Auto-migration)
+migrate_to_shared_structure() {
+  local shared_dir="$HOME/.ccs/shared"
+
+  # Check if migration is needed (shared dirs exist but are empty)
+  if [[ -d "$shared_dir" ]]; then
+    local needs_migration=false
+    for dir in commands skills agents; do
+      if [[ ! -d "$shared_dir/$dir" ]] || [[ -z "$(ls -A "$shared_dir/$dir" 2>/dev/null)" ]]; then
+        needs_migration=true
+        break
+      fi
+    done
+
+    [[ "$needs_migration" == "false" ]] && return 0
+  fi
+
+  # Create shared directory
+  mkdir -p "$shared_dir"/{commands,skills,agents}
+
+  # Copy from ~/.claude/ (actual Claude CLI directory)
+  local claude_dir="$HOME/.claude"
+
+  if [[ -d "$claude_dir" ]]; then
+    # Copy commands to shared (if exists)
+    [[ -d "$claude_dir/commands" ]] && \
+      cp -r "$claude_dir/commands"/* "$shared_dir/commands/" 2>/dev/null || true
+
+    # Copy skills to shared (if exists)
+    [[ -d "$claude_dir/skills" ]] && \
+      cp -r "$claude_dir/skills"/* "$shared_dir/skills/" 2>/dev/null || true
+
+    # Copy agents to shared (if exists)
+    [[ -d "$claude_dir/agents" ]] && \
+      cp -r "$claude_dir/agents"/* "$shared_dir/agents/" 2>/dev/null || true
+  fi
+
+  # Update all instances to use symlinks
+  for instance_path in "$INSTANCES_DIR"/*; do
+    [[ -d "$instance_path" ]] || continue
+    link_shared_directories "$instance_path"
+  done
+
+  echo "[OK] Migrated to shared structure"
+}
+
 # Initialize new instance directory
 initialize_instance() {
   local instance_path="$1"
@@ -500,12 +573,15 @@ initialize_instance() {
   # Create base directory
   mkdir -m 0700 -p "$instance_path"
 
-  # Create subdirectories
-  local subdirs=(session-env todos logs file-history shell-snapshots debug .anthropic commands skills)
+  # Create subdirectories (profile-specific only)
+  local subdirs=(session-env todos logs file-history shell-snapshots debug .anthropic)
   for dir in "${subdirs[@]}"; do
     mkdir -m 0700 -p "$instance_path/$dir"
   done
 
+  # Symlink shared directories
+  link_shared_directories "$instance_path"
+
   # Copy global configs (optional)
   copy_global_configs "$instance_path"
 }
@@ -527,17 +603,9 @@ copy_global_configs() {
   local instance_path="$1"
   local global_claude="$HOME/.claude"
 
-  # Copy settings.json
+  # Copy settings.json only (commands/skills are now symlinked to shared/)
   [[ -f "$global_claude/settings.json" ]] && \
     cp "$global_claude/settings.json" "$instance_path/settings.json" 2>/dev/null || true
-
-  # Copy commands/
-  [[ -d "$global_claude/commands" ]] && \
-    cp -r "$global_claude/commands" "$instance_path/" 2>/dev/null || true
-
-  # Copy skills/
-  [[ -d "$global_claude/skills" ]] && \
-    cp -r "$global_claude/skills" "$instance_path/" 2>/dev/null || true
 }
 
 # Ensure instance exists (lazy initialization)

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "3.0.2"
+$CcsVersion = "3.1.1"
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ConfigFile = if ($env:CCS_CONFIG) { $env:CCS_CONFIG } else { "$env:USERPROFILE\.ccs\config.json" }
 $ProfilesJson = "$env:USERPROFILE\.ccs\profiles.json"
@@ -123,9 +123,15 @@ function Show-Help {
     Write-ColorLine "  -v, --version               Show version and installation info" "Yellow"
     Write-Host ""
     Write-ColorLine "Configuration:" "Cyan"
-    Write-Host "  Config:   ~/.ccs/config.json"
-    Write-Host "  Profiles: ~/.ccs/profiles.json"
-    Write-Host "  Settings: ~/.ccs/*.settings.json"
+    Write-Host "  Config:    ~/.ccs/config.json"
+    Write-Host "  Profiles:  ~/.ccs/profiles.json"
+    Write-Host "  Instances: ~/.ccs/instances/"
+    Write-Host "  Settings:  ~/.ccs/*.settings.json"
+    Write-Host ""
+    Write-ColorLine "Shared Data:" "Cyan"
+    Write-Host "  Commands:  ~/.ccs/shared/commands/"
+    Write-Host "  Skills:    ~/.ccs/shared/skills/"
+    Write-Host "  Note: Commands, skills, and agents are symlinked across all profiles"
     Write-Host ""
     Write-ColorLine "Documentation:" "Cyan"
     Write-Host "  GitHub:  https://github.com/kaitranntt/ccs"
@@ -422,28 +428,106 @@ function Set-InstancePermissions {
     Set-Acl -Path $Path -AclObject $Acl
 }
 
+function Link-SharedDirectories {
+    param([string]$InstancePath)
+
+    $SharedDir = "$env:USERPROFILE\.ccs\shared"
+
+    # Ensure shared directories exist
+    @('commands', 'skills', 'agents') | ForEach-Object {
+        $Dir = Join-Path $SharedDir $_
+        if (-not (Test-Path $Dir)) {
+            New-Item -ItemType Directory -Path $Dir -Force | Out-Null
+        }
+    }
+
+    # Create symlinks (requires Windows Developer Mode or admin)
+    @('commands', 'skills', 'agents') | ForEach-Object {
+        $LinkPath = Join-Path $InstancePath $_
+        $TargetPath = Join-Path $SharedDir $_
+
+        # Remove existing directory/link
+        if (Test-Path $LinkPath) {
+            Remove-Item $LinkPath -Recurse -Force
+        }
+
+        # Try creating symlink (requires privileges)
+        try {
+            New-Item -ItemType SymbolicLink -Path $LinkPath -Target $TargetPath -Force | Out-Null
+        } catch {
+            # Fallback: Copy directory instead (suboptimal but functional)
+            Copy-Item $TargetPath -Destination $LinkPath -Recurse -Force
+            Write-Host "[!] Symlink failed for $_, copied instead (enable Developer Mode)" -ForegroundColor Yellow
+        }
+    }
+}
+
+function Migrate-SharedStructure {
+    $SharedDir = "$env:USERPROFILE\.ccs\shared"
+
+    # Check if migration is needed (shared dirs exist but are empty)
+    if (Test-Path $SharedDir) {
+        $NeedsMigration = $false
+        foreach ($Dir in @('commands', 'skills', 'agents')) {
+            $DirPath = Join-Path $SharedDir $Dir
+            if (-not (Test-Path $DirPath) -or (Get-ChildItem $DirPath -ErrorAction SilentlyContinue).Count -eq 0) {
+                $NeedsMigration = $true
+                break
+            }
+        }
+
+        if (-not $NeedsMigration) { return }
+    }
+
+    # Create shared directory
+    @('commands', 'skills', 'agents') | ForEach-Object {
+        $Dir = Join-Path $SharedDir $_
+        New-Item -ItemType Directory -Path $Dir -Force | Out-Null
+    }
+
+    # Copy from ~/.claude/ (actual Claude CLI directory)
+    $ClaudeDir = "$env:USERPROFILE\.claude"
+
+    if (Test-Path $ClaudeDir) {
+        # Copy commands to shared (if exists)
+        $CommandsPath = Join-Path $ClaudeDir "commands"
+        if (Test-Path $CommandsPath) {
+            Copy-Item "$CommandsPath\*" -Destination "$SharedDir\commands\" -Recurse -ErrorAction SilentlyContinue
+        }
+
+        # Copy skills to shared (if exists)
+        $SkillsPath = Join-Path $ClaudeDir "skills"
+        if (Test-Path $SkillsPath) {
+            Copy-Item "$SkillsPath\*" -Destination "$SharedDir\skills\" -Recurse -ErrorAction SilentlyContinue
+        }
+
+        # Copy agents to shared (if exists)
+        $AgentsPath = Join-Path $ClaudeDir "agents"
+        if (Test-Path $AgentsPath) {
+            Copy-Item "$AgentsPath\*" -Destination "$SharedDir\agents\" -Recurse -ErrorAction SilentlyContinue
+        }
+    }
+
+    # Update all instances to use symlinks
+    if (Test-Path $InstancesDir) {
+        Get-ChildItem $InstancesDir -Directory | ForEach-Object {
+            Link-SharedDirectories $_.FullName
+        }
+    }
+
+    Write-Host "[OK] Migrated to shared structure"
+}
+
 function Copy-GlobalConfigs {
     param([string]$InstancePath)
 
     $GlobalClaude = "$env:USERPROFILE\.claude"
 
-    # Copy settings.json
+    # Copy settings.json only (commands/skills are now symlinked to shared/)
     $GlobalSettings = Join-Path $GlobalClaude "settings.json"
     if (Test-Path $GlobalSettings) {
         Copy-Item $GlobalSettings -Destination (Join-Path $InstancePath "settings.json") -ErrorAction SilentlyContinue
     }
-
-    # Copy commands/
-    $GlobalCommands = Join-Path $GlobalClaude "commands"
-    if (Test-Path $GlobalCommands) {
-        Copy-Item $GlobalCommands -Destination $InstancePath -Recurse -ErrorAction SilentlyContinue
-    }
-
-    # Copy skills/
-    $GlobalSkills = Join-Path $GlobalClaude "skills"
-    if (Test-Path $GlobalSkills) {
-        Copy-Item $GlobalSkills -Destination $InstancePath -Recurse -ErrorAction SilentlyContinue
-    }
 }
 
 function Initialize-Instance {
@@ -453,15 +537,18 @@ function Initialize-Instance {
     New-Item -ItemType Directory -Path $InstancePath -Force | Out-Null
     Set-InstancePermissions $InstancePath
 
-    # Create subdirectories
+    # Create subdirectories (profile-specific only)
     $Subdirs = @('session-env', 'todos', 'logs', 'file-history',
-                  'shell-snapshots', 'debug', '.anthropic', 'commands', 'skills')
+                  'shell-snapshots', 'debug', '.anthropic')
 
     foreach ($Dir in $Subdirs) {
         $DirPath = Join-Path $InstancePath $Dir
         New-Item -ItemType Directory -Path $DirPath -Force | Out-Null
     }
 
+    # Symlink shared directories
+    Link-SharedDirectories $InstancePath
+
     # Copy global configs
     Copy-GlobalConfigs $InstancePath
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "3.0.2",
+  "version": "3.1.1",
   "description": "Claude Code Switch - Instant profile switching between Claude Sonnet 4.5 and GLM 4.6",
   "keywords": [
     "cli",

package/scripts/postinstall.js

@@ -72,6 +72,35 @@ function createConfigFiles() {
       console.log('[OK] Created directory: ~/.ccs/');
     }
 
+    // Create ~/.ccs/shared/ directory structure (Phase 1)
+    const sharedDir = path.join(ccsDir, 'shared');
+    if (!fs.existsSync(sharedDir)) {
+      fs.mkdirSync(sharedDir, { recursive: true, mode: 0o755 });
+      console.log('[OK] Created directory: ~/.ccs/shared/');
+    }
+
+    // Create shared subdirectories
+    const sharedSubdirs = ['commands', 'skills', 'agents'];
+    for (const subdir of sharedSubdirs) {
+      const subdirPath = path.join(sharedDir, subdir);
+      if (!fs.existsSync(subdirPath)) {
+        fs.mkdirSync(subdirPath, { recursive: true, mode: 0o755 });
+        console.log(`[OK] Created directory: ~/.ccs/shared/${subdir}/`);
+      }
+    }
+
+    // Migrate from ~/.claude/ to ~/.ccs/shared/ (v3.1.1)
+    console.log('');
+    try {
+      const SharedManager = require('../bin/shared-manager');
+      const sharedManager = new SharedManager();
+      sharedManager.migrateToSharedStructure();
+    } catch (err) {
+      console.warn('[!] Migration warning:', err.message);
+      console.warn('    You can manually copy files from ~/.claude/ to ~/.ccs/shared/');
+    }
+    console.log('');
+
     // Create config.json if missing
     const configPath = path.join(ccsDir, 'config.json');
     if (!fs.existsSync(configPath)) {