@kaitranntt/ccs 3.0.1 → 3.1.0

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.1
+3.1.0

package/bin/auth-commands.js

@@ -39,12 +39,18 @@ class AuthCommands {
     console.log('');
     console.log(colored('Examples:', 'cyan'));
     console.log(`  ${colored('ccs auth create work', 'yellow')}                     # Create & login to work profile`);
+    console.log(`  ${colored('ccs auth default work', 'yellow')}                    # Set work as default`);
     console.log(`  ${colored('ccs auth list', 'yellow')}                            # List all profiles`);
     console.log(`  ${colored('ccs work "review code"', 'yellow')}                   # Use work profile`);
+    console.log(`  ${colored('ccs "review code"', 'yellow')}                        # Use default profile`);
     console.log('');
     console.log(colored('Options:', 'cyan'));
     console.log(`  ${colored('--force', 'yellow')}                   Allow overwriting existing profile`);
     console.log('');
+    console.log(colored('Note:', 'cyan'));
+    console.log(`  By default, ${colored('ccs', 'yellow')} uses Claude CLI defaults from ~/.claude/`);
+    console.log(`  Use ${colored('ccs auth default <profile>', 'yellow')} to change the default profile.`);
+    console.log('');
   }
 
   /**
@@ -119,7 +125,10 @@ class AuthCommands {
           console.log(`  Instance: ${instancePath}`);
           console.log('');
           console.log('Usage:');
-          console.log(`  ${colored(`ccs ${profileName} "your prompt here"`, 'yellow')}`);
+          console.log(`  ${colored(`ccs ${profileName} "your prompt here"`, 'yellow')}        # Use this specific profile`);
+          console.log('');
+          console.log('To set as default (so you can use just "ccs"):');
+          console.log(`  ${colored(`ccs auth default ${profileName}`, 'yellow')}`);
           console.log('');
           process.exit(0);
         } else {

package/bin/ccs.js

@@ -114,14 +114,9 @@ function handleHelpCommand() {
 
   // Account Management
   console.log(colored('Account Management:', 'cyan'));
-  console.log(`  ${colored('ccs auth create <profile>', 'yellow')}   Create new profile and login`);
-  console.log(`  ${colored('ccs auth list', 'yellow')}               List all saved profiles`);
-  console.log(`  ${colored('ccs auth show <profile>', 'yellow')}     Show profile details`);
-  console.log(`  ${colored('ccs auth remove <profile>', 'yellow')}   Remove profile (requires --force)`);
-  console.log(`  ${colored('ccs auth default <profile>', 'yellow')}  Set default profile`);
+  console.log(`  ${colored('ccs auth --help', 'yellow')}             Manage multiple Claude accounts`);
   console.log(`  ${colored('ccs work', 'yellow')}                    Switch to work account`);
   console.log(`  ${colored('ccs personal', 'yellow')}                Switch to personal account`);
-  console.log(`  ${colored('ccs work', 'yellow')} "review code"      Run command with work account`);
   console.log('');
 
   // Diagnostics
@@ -138,28 +133,18 @@ 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('');
 
-  // Examples
-  console.log(colored('Examples:', 'cyan'));
-  console.log('  # Try without installing');
-  console.log(`  ${colored('npx @kaitranntt/ccs glm', 'yellow')} "write tests"`);
-  console.log(`  ${colored('npx @kaitranntt/ccs kimi', 'yellow')} "write tests"`);
-  console.log('');
-  console.log('  # Use default Claude subscription');
-  console.log(`  ${colored('ccs', 'yellow')} "Review this architecture"`);
-  console.log('');
-  console.log('  # Switch to GLM for cost-effective tasks');
-  console.log(`  ${colored('ccs glm', 'yellow')} "Write unit tests"`);
-  console.log('');
-  console.log('  # Switch to Kimi for alternative option');
-  console.log(`  ${colored('ccs kimi', 'yellow')} "Write integration tests"`);
-  console.log('');
-  console.log('  # Use with verbose output');
-  console.log(`  ${colored('ccs glm', 'yellow')} --verbose "Debug error"`);
-  console.log(`  ${colored('ccs kimi', 'yellow')} --verbose "Review code"`);
+  // 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
@@ -277,6 +262,11 @@ async function main() {
     recovery.showRecoveryHints();
   }
 
+  // Run migration to shared structure (Phase 1: idempotent)
+  const SharedManager = require('./shared-manager');
+  const sharedManager = new SharedManager();
+  sharedManager.migrateToSharedStructure();
+
   // Detect profile
   const { profile, remainingArgs } = detectProfile(args);
 

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/profile-registry.js

@@ -94,10 +94,9 @@ class ProfileRegistry {
       last_used: null
     };
 
-    // Set as default if no default exists
-    if (!data.default) {
-      data.default = name;
-    }
+    // Note: No longer auto-set as default
+    // Users must explicitly run: ccs auth default <profile>
+    // Default always stays on implicit 'default' profile (uses ~/.claude/)
 
     this._write(data);
   }

package/bin/shared-manager.js

@@ -0,0 +1,164 @@
+'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;
+        }
+      }
+    }
+  }
+
+  /**
+   * Migrate existing instances to shared structure
+   * Idempotent: Safe to run multiple times
+   */
+  migrateToSharedStructure() {
+    // Check if migration is needed (shared dirs exist but are empty)
+    const needsMigration = !fs.existsSync(this.sharedDir) ||
+      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; // Empty directory needs migration
+        } catch (err) {
+          return true; // If we can't read it, assume it needs migration
+        }
+      });
+
+    if (!needsMigration) {
+      return; // Already migrated with content
+    }
+
+    // Create shared directories
+    this.ensureSharedDirectories();
+
+    // Copy from ~/.claude/ (actual Claude CLI directory)
+    const claudeDir = path.join(this.homeDir, '.claude');
+
+    if (fs.existsSync(claudeDir)) {
+      // Copy commands to shared (if exists)
+      const commandsPath = path.join(claudeDir, 'commands');
+      if (fs.existsSync(commandsPath)) {
+        this._copyDirectory(commandsPath, path.join(this.sharedDir, 'commands'));
+      }
+
+      // Copy skills to shared (if exists)
+      const skillsPath = path.join(claudeDir, 'skills');
+      if (fs.existsSync(skillsPath)) {
+        this._copyDirectory(skillsPath, path.join(this.sharedDir, 'skills'));
+      }
+
+      // Copy agents to shared (if exists)
+      const agentsPath = path.join(claudeDir, 'agents');
+      if (fs.existsSync(agentsPath)) {
+        this._copyDirectory(agentsPath, path.join(this.sharedDir, 'agents'));
+      }
+    }
+
+    // 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);
+        }
+      }
+    }
+
+    console.log('[OK] Migrated to shared structure');
+  }
+
+  /**
+   * Copy directory recursively (fallback for Windows)
+   * @param {string} src - Source directory
+   * @param {string} dest - Destination directory
+   * @private
+   */
+  _copyDirectory(src, dest) {
+    if (!fs.existsSync(src)) {
+      return;
+    }
+
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this._copyDirectory(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+
+module.exports = SharedManager;

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.0.1"
+CCS_VERSION="3.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"
@@ -55,14 +55,9 @@ show_help() {
   echo -e "  ${YELLOW}ccs glm${RESET} \"debug this code\"   Use GLM and run command"
   echo ""
   echo -e "${CYAN}Account Management:${RESET}"
-  echo -e "  ${YELLOW}ccs auth create <profile>${RESET}   Create new account profile"
-  echo -e "  ${YELLOW}ccs auth list${RESET}               List all profiles"
-  echo -e "  ${YELLOW}ccs auth show <profile>${RESET}     Show profile details"
-  echo -e "  ${YELLOW}ccs auth remove <profile>${RESET}   Remove profile (requires --force)"
-  echo -e "  ${YELLOW}ccs auth default <profile>${RESET}  Set default profile"
+  echo -e "  ${YELLOW}ccs auth --help${RESET}             Manage multiple Claude accounts"
   echo -e "  ${YELLOW}ccs work${RESET}                    Switch to work account"
   echo -e "  ${YELLOW}ccs personal${RESET}                Switch to personal account"
-  echo -e "  ${YELLOW}ccs work${RESET} \"review code\"      Run command with work account"
   echo ""
   echo -e "${CYAN}Diagnostics:${RESET}"
   echo -e "  ${YELLOW}ccs doctor${RESET}                  Run health check and diagnostics"
@@ -72,19 +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}Examples:${RESET}"
-  echo -e "  # Create work account profile"
-  echo -e "  ${YELLOW}ccs auth create work${RESET}"
-  echo ""
-  echo -e "  # Use work account"
-  echo -e "  ${YELLOW}ccs work${RESET} \"Review architecture\""
-  echo ""
-  echo -e "  # Switch to GLM for cost-effective tasks"
-  echo -e "  ${YELLOW}ccs glm${RESET} \"Write unit tests\""
+  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}"
@@ -428,11 +419,9 @@ register_profile() {
       "last_used": null
     }')
 
-  # Set as default if none exists
-  local has_default=$(echo "$data" | jq -r '.default // empty')
-  if [[ -z "$has_default" ]]; then
-    data=$(echo "$data" | jq --arg name "$profile_name" '.default = $name')
-  fi
+  # Note: No longer auto-set as default
+  # Users must explicitly run: ccs auth default <profile>
+  # Default always stays on implicit 'default' profile (uses ~/.claude/)
 
   write_profiles_json "$data"
 }
@@ -510,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"
@@ -517,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"
 }
@@ -544,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)
@@ -687,9 +738,15 @@ auth_help() {
   echo -e "  ${YELLOW}default <profile>${RESET}      Set default profile"
   echo ""
   echo -e "${CYAN}Examples:${RESET}"
-  echo -e "  ${YELLOW}ccs auth create work${RESET}"
-  echo -e "  ${YELLOW}ccs auth list${RESET}"
-  echo -e "  ${YELLOW}ccs auth remove work --force${RESET}"
+  echo -e "  ${YELLOW}ccs auth create work${RESET}                     # Create & login to work profile"
+  echo -e "  ${YELLOW}ccs auth default work${RESET}                    # Set work as default"
+  echo -e "  ${YELLOW}ccs auth list${RESET}                            # List all profiles"
+  echo -e "  ${YELLOW}ccs work \"review code\"${RESET}                   # Use work profile"
+  echo -e "  ${YELLOW}ccs \"review code\"${RESET}                        # Use default profile"
+  echo ""
+  echo -e "${CYAN}Note:${RESET}"
+  echo -e "  By default, ${YELLOW}ccs${RESET} uses Claude CLI defaults from ~/.claude/"
+  echo -e "  Use ${YELLOW}ccs auth default <profile>${RESET} to change the default profile."
   echo ""
 }
 
@@ -749,7 +806,10 @@ auth_create() {
   echo "  Instance: $instance_path"
   echo ""
   echo "Usage:"
-  echo "  ${YELLOW}ccs $profile_name \"your prompt here\"${RESET}"
+  echo "  ${YELLOW}ccs $profile_name \"your prompt here\"${RESET}        # Use this specific profile"
+  echo ""
+  echo "To set as default (so you can use just \"ccs\"):"
+  echo "  ${YELLOW}ccs auth default $profile_name${RESET}"
   echo ""
 }
 
@@ -950,6 +1010,9 @@ auto_recover || {
   exit 1
 }
 
+# Run migration to shared structure (Phase 1: idempotent)
+migrate_to_shared_structure
+
 # Smart profile detection: if first arg starts with '-', it's a flag not a profile
 if [[ $# -eq 0 ]] || [[ "${1}" =~ ^- ]]; then
   # No args or first arg is a flag → use default profile

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "3.0.1"
+$CcsVersion = "3.1.0"
 $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"
@@ -111,14 +111,9 @@ function Show-Help {
     Write-ColorLine "  ccs glm 'debug this code'   Use GLM and run command" "Yellow"
     Write-Host ""
     Write-ColorLine "Account Management:" "Cyan"
-    Write-ColorLine "  ccs auth create <profile>   Create new account profile" "Yellow"
-    Write-ColorLine "  ccs auth list               List all profiles" "Yellow"
-    Write-ColorLine "  ccs auth show <profile>     Show profile details" "Yellow"
-    Write-ColorLine "  ccs auth remove <profile>   Remove profile (requires --force)" "Yellow"
-    Write-ColorLine "  ccs auth default <profile>  Set default profile" "Yellow"
+    Write-ColorLine "  ccs auth --help             Manage multiple Claude accounts" "Yellow"
     Write-ColorLine "  ccs work                    Switch to work account" "Yellow"
     Write-ColorLine "  ccs personal                Switch to personal account" "Yellow"
-    Write-ColorLine "  ccs work 'review code'      Run command with work account" "Yellow"
     Write-Host ""
     Write-ColorLine "Diagnostics:" "Cyan"
     Write-ColorLine "  ccs doctor                  Run health check and diagnostics" "Yellow"
@@ -128,19 +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 "Examples:" "Cyan"
-    Write-Host "  # Create work account profile"
-    Write-ColorLine "  ccs auth create work" "Yellow"
-    Write-Host ""
-    Write-Host "  # Use work account"
-    Write-ColorLine "  ccs work 'Review architecture'" "Yellow"
-    Write-Host ""
-    Write-Host "  # Switch to GLM for cost-effective tasks"
-    Write-ColorLine "  ccs glm 'Write unit tests'" "Yellow"
+    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"
@@ -350,10 +341,9 @@ function Register-Profile {
         last_used = $null
     })
 
-    # Set as default if none exists
-    if (-not $Data.default) {
-        $Data.default = $ProfileName
-    }
+    # Note: No longer auto-set as default
+    # Users must explicitly run: ccs auth default <profile>
+    # Default always stays on implicit 'default' profile (uses ~/.claude/)
 
     Write-ProfilesJson $Data
 }
@@ -438,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 {
@@ -469,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
 }
@@ -640,9 +711,19 @@ function Show-AuthHelp {
     Write-Host "  default <profile>      Set default profile" -ForegroundColor Yellow
     Write-Host ""
     Write-Host "Examples:" -ForegroundColor Cyan
-    Write-Host "  ccs auth create work" -ForegroundColor Yellow
-    Write-Host "  ccs auth list" -ForegroundColor Yellow
-    Write-Host "  ccs auth remove work --force" -ForegroundColor Yellow
+    Write-Host "  ccs auth create work                     # Create & login to work profile" -ForegroundColor Yellow
+    Write-Host "  ccs auth default work                    # Set work as default" -ForegroundColor Yellow
+    Write-Host "  ccs auth list                            # List all profiles" -ForegroundColor Yellow
+    Write-Host '  ccs work "review code"                   # Use work profile' -ForegroundColor Yellow
+    Write-Host '  ccs "review code"                        # Use default profile' -ForegroundColor Yellow
+    Write-Host ""
+    Write-Host "Note:" -ForegroundColor Cyan
+    Write-Host "  By default, " -NoNewline
+    Write-Host "ccs" -ForegroundColor Yellow -NoNewline
+    Write-Host " uses Claude CLI defaults from ~/.claude/"
+    Write-Host "  Use " -NoNewline
+    Write-Host "ccs auth default <profile>" -ForegroundColor Yellow -NoNewline
+    Write-Host " to change the default profile."
     Write-Host ""
 }
 
@@ -703,7 +784,10 @@ function Invoke-AuthCreate {
     Write-Host "  Instance: $InstancePath"
     Write-Host ""
     Write-Host "Usage:"
-    Write-Host "  ccs $ProfileName `"your prompt here`"" -ForegroundColor Yellow
+    Write-Host "  ccs $ProfileName `"your prompt here`"        # Use this specific profile" -ForegroundColor Yellow
+    Write-Host ""
+    Write-Host 'To set as default (so you can use just "ccs"):'
+    Write-Host "  ccs auth default $ProfileName" -ForegroundColor Yellow
     Write-Host ""
 }
 
@@ -916,6 +1000,9 @@ if (-not (Invoke-AutoRecovery)) {
     exit 1
 }
 
+# Run migration to shared structure (Phase 1: idempotent)
+Migrate-SharedStructure
+
 # Smart profile detection: if first arg starts with '-', it's a flag not a profile
 if ($RemainingArgs.Count -eq 0 -or $RemainingArgs[0] -match '^-') {
     # No args or first arg is a flag → use default profile

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "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,23 @@ 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}/`);
+      }
+    }
+
     // Create config.json if missing
     const configPath = path.join(ccsDir, 'config.json');
     if (!fs.existsSync(configPath)) {