claude-switch-profile 1.1.0 → 1.4.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to `claude-switch-profile` are documented here.
 
+## [1.3.0] - 2026-03-28
+
+### Added
+- ✨ **Interactive profile selector** — Run `csp` with no arguments to get an arrow-key profile picker that launches isolated sessions. Supports ↑/↓/j/k navigation, Enter to select, Esc to cancel.
+- ✨ **`csp status`** — Dashboard showing active profile, profile count, last launch info, and Claude running status at a glance.
+- ✨ **`csp toggle`** — Quick-switch to the previous profile (like `cd -`). Uses isolated launch, never touches ~/.claude.
+- ✨ **`csp select`** — Explicit alias for the interactive selector.
+
+### Changed
+- 🔒 **`~/.claude` is never modified** — All profile operations now use isolated runtime (`CLAUDE_CONFIG_DIR`). The `default` profile is a virtual alias for `~/.claude` as-is.
+- 🔒 **`default` profile is virtual** — `csp init` no longer creates a physical directory for the default profile. Default means "use ~/.claude directly".
+- 🔒 **`csp launch default`** — Launches Claude with native `~/.claude` (no runtime dir, no `CLAUDE_CONFIG_DIR` override).
+- 🔒 **`csp deactivate`** — Now simply resets active marker to `default`. No longer deletes files from `~/.claude`.
+- ⚠️ **`csp use` deprecated** — Shows warning that it modifies `~/.claude` (legacy mode). Users should prefer `csp launch`.
+- 🔄 **`csp toggle`** — Now uses `launch` (isolated) instead of `use` (legacy).
+
+### Fixed
+- 🐛 Removed dead `--force` option from `csp use`.
+- 🐛 Fixed double `getActive()` call in `init` command.
+- 🐛 Fixed stale "symlink targets" comment in safety.js.
+- 🐛 Removed unused parameter in diff.js.
+
+---
+
 ## [1.1.0] - 2026-03-13
 
 ### Added

package/README.md

@@ -4,7 +4,7 @@
 [![Node.js >= 18](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-A CLI tool for managing multiple Claude Code configurations and profiles. Effortlessly switch between different development setups, each with their own rules, agents, skills, and settings.
+A CLI tool for managing multiple Claude Code configurations and profiles. Use legacy global switching (`csp use`) or concurrent isolated account sessions (`csp launch`) with per-profile runtime roots.
 
 ## Overview
 
@@ -46,7 +46,8 @@ csp --help
 ### Requirements
 
 - Node.js >= 18.0.0
-- Unix/Linux/macOS (uses symlinks and POSIX tools)
+- Unix/Linux/macOS
+- Windows 10+
 
 ## Quick Start
 
@@ -146,7 +147,7 @@ csp init
 
 ### current
 
-Display the currently active profile.
+Display the currently active **legacy** profile and isolated launch metadata (if present).
 
 ```bash
 csp current
@@ -154,8 +155,10 @@ csp current
 
 **Output:**
 ```
-✓ Active profile: default
+✓ Active legacy profile: default
 ℹ Location: /home/user/.claude-profiles/default
+ℹ Last isolated launch: 2026-03-26T14:45:00.000Z
+ℹ Isolated runtime: /home/user/.claude-profiles/.runtime/default
 ```
 
 ---
@@ -171,8 +174,8 @@ csp ls
 
 **Output format:**
 ```
- * profile-name — optional description (YYYY-MM-DD)
-   other-profile (YYYY-MM-DD)
+ * profile-name — optional description (YYYY-MM-DD) [legacy|account-session]
+   other-profile (YYYY-MM-DD) [account-session]
 ```
 
 The `*` marks the currently active profile.
@@ -226,7 +229,7 @@ csp save
 ```
 
 **Behavior:**
-- Captures all managed symlinks and files from `~/.claude`
+- Captures all managed items and files from `~/.claude`
 - Overwrites profile's `source.json` and file copies
 - Useful after modifying rules, settings, or other configuration
 - Requires active profile (run `csp create` if none exists)
@@ -244,7 +247,7 @@ csp use <name> [options]
 **Options:**
 - `--dry-run` — Show what would change without executing
 - `--no-save` — Skip saving current profile before switching
-- `--force` — Switch even if some symlink targets are missing
+- `--force` — Accepted for compatibility (current switch path does not block on target-link validation)
 
 **Examples:**
 
@@ -269,14 +272,13 @@ csp use legacy --force
 ```
 
 **Behavior:**
-1. Validates target profile exists and is valid
-2. (Optional) Validates symlink targets exist
+1. Validates target profile exists and profile structure is valid
+2. Refuses to switch while Claude Code is running (legacy/global switching mutates `~/.claude` directly)
 3. If active profile exists and `--no-save` is not set: saves current state
-4. Creates automatic backup at `~/.claude-profiles/.backup/`
-5. Removes all managed items from `~/.claude`
-6. Restores target profile's symlinks and files
-7. Updates active marker
-8. **Important:** Claude Code session must be restarted for changes to apply
+4. Removes managed items/files from `~/.claude` as needed
+5. Restores target profile configuration into `~/.claude`
+6. Updates active marker
+7. **Important:** Claude Code session must be restarted for changes to apply
 
 ---
 
@@ -339,7 +341,7 @@ csp export staging -o ~/backups/claude-staging.tar.gz
 
 **Behavior:**
 - Creates tar.gz archive of entire profile directory
-- Includes source.json (symlink targets) and all copied files
+- Includes `source.json` (managed item map) and copied profile files/directories
 - Useful for backup, sharing, or version control
 
 ---
@@ -403,7 +405,7 @@ csp diff current backup
 ```
 Comparing: staging ↔ production
 
-Symlink targets (source.json): identical
+Managed item map (source.json): identical
 
 File differences:
   settings.json — different
@@ -412,10 +414,80 @@ File differences:
 ```
 
 **Behavior:**
-- Compares `source.json` (symlink targets)
+- Compares `source.json` (managed item map)
 - Lists file presence and content differences
 - Shows which files differ and in which profile they exist
 
+---
+
+### deactivate
+
+Deactivate the currently active non-default profile and clear `.active` without switching to another profile.
+
+```bash
+csp deactivate
+```
+
+**Options:**
+- `--no-save` — Skip saving current profile state before deactivation
+
+**Behavior:**
+1. Exits early if no active profile or active profile is `default`
+2. Optionally saves active profile state
+3. Removes managed items/files from `~/.claude`
+4. Clears active marker
+
+---
+
+### launch (la)
+
+Launch an isolated Claude session for a profile. This does **not** change global active profile. All extra arguments are forwarded to `claude`.
+
+```bash
+csp launch <name> [claude-args...]
+csp la <name> [claude-args...]
+```
+
+**Options:**
+- `--legacy-global` — Use old behavior (`csp use <name>` then launch)
+
+**Examples:**
+
+Launch isolated session:
+```bash
+csp launch work
+```
+
+Launch isolated with Claude flags:
+```bash
+csp launch work --dangerously-skip-permissions
+csp la dev --model opus
+```
+
+Launch legacy/global mode:
+```bash
+csp launch work --legacy-global
+```
+
+**Behavior (default isolated mode):**
+1. Validates target profile exists
+2. Prepares per-profile runtime under `~/.claude-profiles/.runtime/<name>`
+3. Resolves effective allowlisted `ANTHROPIC_*` launch env (`ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_MODEL`) with precedence: `settings.json env` > profile `.env` allowlist > parent process env
+4. Strips inherited `CLAUDECODE`, inherited `CLAUDE_CONFIG_DIR`, and inherited `ANTHROPIC_*` before applying resolved allowlisted values
+5. Spawns `claude` with `CLAUDE_CONFIG_DIR=<runtimeDir>`
+6. Inherits stdin/stdout/stderr for interactive use
+7. Forwards Claude's exit code
+8. Keeps `.active` unchanged and never mutates global `~/.claude`
+
+`ANTHROPIC_*` keys currently in isolated launch scope:
+- `ANTHROPIC_AUTH_TOKEN`
+- `ANTHROPIC_BASE_URL`
+- `ANTHROPIC_MODEL`
+
+Set `CSP_DEBUG_LAUNCH_ENV=1` to print key-level launch diagnostics (sources only, values are never printed).
+
+---
+
 ### uninstall
 
 Remove all profiles and restore Claude Code to its pre-CSP state.
@@ -462,10 +534,13 @@ Profiles are stored in `~/.claude-profiles/`:
 
 ```
 ~/.claude-profiles/
-├── .active                    # Current active profile name
-├── profiles.json              # Metadata for all profiles
+├── .active                    # Current active profile name (legacy use mode)
+├── profiles.json              # Metadata for all profiles (v2 schema)
+├── .runtime/                  # Isolated launch roots
+│   ├── work/
+│   └── personal/
 ├── default/
-│   ├── source.json           # Symlink targets
+│   ├── source.json           # Managed item map
 │   ├── settings.json         # Copied from ~/.claude
 │   ├── .env                  # Copied from ~/.claude
 │   ├── .ck.json              # Copied from ~/.claude
@@ -480,7 +555,7 @@ Profiles are stored in `~/.claude-profiles/`:
 
 ### What Gets Managed
 
-**Symlinked Items** (via `source.json`):
+**Managed Static Items** (via `source.json`):
 - `CLAUDE.md` — Project-specific Claude configuration
 - `rules/` — Development rules and guidelines
 - `agents/` — Agent scripts and configurations
@@ -491,45 +566,49 @@ Profiles are stored in `~/.claude-profiles/`:
 
 **Copied Files**:
 - `settings.json` — Editor settings
-- `.env` — Environment variables
-- `.ck.json` — Custom settings
-- `.ckignore` — Ignore patterns
+- `.env`, `.env.example` — Environment variables
+- `.ck.json`, `.ckignore` — Custom settings and ignore patterns
+- `.mcp.json`, `.mcp.json.example` — MCP configuration
+- `.gitignore` — Local ignore settings
 
 **Copied Directories**:
-- `commands/` — Custom commands
-- `plugins/` — Custom plugins
+- `commands/`, `plugins/` — Custom commands/plugins
+- `workflows/`, `scripts/` — Automation and workflow assets
+- `output-styles/`, `schemas/` — Output and schema assets
 
 **Never Touched** (runtime/session data):
 - `.credentials.json`
-- `projects/`
-- `backups/`
-- `cache/`, `debug/`, `telemetry/`
-- `history.jsonl`
-- `plans/`, `todos/`, `tasks/`
-- `agent-memory/`, `session-env/`
+- `projects/`, `sessions/`, `session-env/`, `ide/`
+- `cache/`, `paste-cache/`, `downloads/`, `telemetry/`, `debug/`, `statsig/`
+- `history.jsonl`, `metadata.json`, `stats-cache.json`, `active-plan`
+- `backups/`, `command-archive/`, `commands-archived/`
+- `plans/`, `todos/`, `tasks/`, `teams/`, `agent-memory/`, `file-history/`, `shell-snapshots/`
 - All other session-specific data
 
-### Symlink vs. Copy Strategy
+### Legacy vs Isolated Launch Modes
 
-**Why symlinks for some items?**
-- Rules, agents, skills often live in external git repos
-- Multiple profiles may share the same rules/skills
-- Symlinks avoid duplication and keep everything in sync
+CSP now supports two paths:
 
-**Why copies for others?**
-- Settings and env vars are environment-specific
-- Each profile needs its own independent configuration
-- Prevents accidental modifications from affecting other profiles
+- **Legacy global mode (`csp use`)**
+  - Mutates `~/.claude`
+  - Updates `.active`
+  - Preserves old behavior for existing scripts
 
-### Real Directory Handling
+- **Isolated launch mode (`csp launch`)**
+  - Does not mutate `~/.claude`
+  - Does not change `.active`
+  - Creates/updates runtime root per profile at `~/.claude-profiles/.runtime/<name>`
+  - Launches Claude with `CLAUDE_CONFIG_DIR` pointing to that runtime root
 
-When `csp save` (or `csp use`) encounters a **real directory/file** in `~/.claude` for a managed item (instead of a symlink), it automatically:
+### Runtime Sync Policy (isolated launch)
 
-1. **Moves** the real item into the profile directory (`~/.claude-profiles/<name>/<item>`)
-2. **Replaces** it with a symlink at the original location
-3. **Records** the new location in `source.json`
+For each launch, CSP syncs static profile config into runtime root:
 
-This ensures that profiles created from a fresh `~/.claude` setup (before any symlinks exist) work correctly on first use.
+- Managed items (`CLAUDE.md`, `rules`, `agents`, `skills`, `hooks`, statusline files, `.luna.json`)
+- Copied files (`settings.json`, `.env`, `.ck.json`, `.ckignore`, etc.)
+- Copied directories (`commands`, `plugins`, `workflows`, `scripts`, ...)
+
+Runtime/account continuity stays isolated per runtime root and is not globally swapped.
 
 ## Safety Features
 
@@ -561,7 +640,7 @@ Every profile switch creates a timestamped backup:
     └── ...
 ```
 
-Backups are kept indefinitely. You can manually restore by copying from backup directory.
+Backups are pruned automatically; CSP keeps only the 2 most recent backups. You can manually restore by copying from backup directory.
 
 ### Claude Process Detection
 
@@ -573,14 +652,19 @@ When switching profiles, CSP detects if Claude Code is running:
 
 **Important:** Changes only take effect after restarting Claude Code.
 
+### Windows Support
+
+Process detection uses `tasklist` instead of `pgrep` on Windows.
+
+Export/import commands use the built-in `tar.exe` available on Windows 10+.
+
 ### Validation
 
 Before switching, CSP validates:
 1. Target profile exists
 2. Profile structure is valid
-3. (Optional with `--force`) Symlink targets are accessible
 
-Use `--force` to proceed even if validation fails:
+`--force` is currently accepted for compatibility:
 
 ```bash
 csp use legacy --force
@@ -728,15 +812,11 @@ csp delete default
 rm ~/.claude-profiles/.lock
 ```
 
-### Symlink targets missing
-
-**Warning:** `Some symlink targets are missing: rules/development-rules.md — missing target`
+### Invalid profile structure
 
-**Solution:** Either restore the missing files to their original location or use `--force`:
+**Error:** `Profile "name" is invalid: Missing source.json — no managed items defined`
 
-```bash
-csp use production --force
-```
+**Solution:** Recreate the profile or import a valid profile archive.
 
 ### Changes not applying
 
@@ -781,10 +861,15 @@ See [CHANGELOG.md](CHANGELOG.md) for version history and migration guidance.
 │   │   ├── delete.js
 │   │   ├── export.js
 │   │   ├── import.js
-│   │   └── diff.js
+│   │   ├── diff.js
+│   │   ├── launch.js
+│   │   ├── deactivate.js
+│   │   └── uninstall.js
 │   ├── constants.js              # Configuration constants
+│   ├── platform.js               # Cross-platform compatibility
 │   ├── profile-store.js          # Profile metadata management
-│   ├── symlink-manager.js        # Symlink operations
+│   ├── runtime-instance-manager.js # Isolated runtime sync
+│   ├── item-manager.js           # Managed item copy/move operations
 │   ├── file-operations.js        # File copy/restore operations
 │   ├── safety.js                 # Locking, backups, validation
 │   ├── profile-validator.js      # Profile validation

package/bin/csp.js

@@ -16,6 +16,11 @@ import { importCommand } from '../src/commands/import.js';
 import { diffCommand } from '../src/commands/diff.js';
 import { initCommand } from '../src/commands/init.js';
 import { uninstallCommand } from '../src/commands/uninstall.js';
+import { launchCommand } from '../src/commands/launch.js';
+import { deactivateCommand } from '../src/commands/deactivate.js';
+import { toggleCommand } from '../src/commands/toggle.js';
+import { statusCommand } from '../src/commands/status.js';
+import { selectCommand } from '../src/commands/select.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -25,7 +30,13 @@ const program = new Command();
 program
   .name('csp')
   .description('Claude Switch Profile — manage multiple Claude Code configurations')
-  .version(pkg.version);
+  .version(pkg.version)
+  .enablePositionalOptions();
+
+program
+  .command('select', { isDefault: true })
+  .description('Interactive profile selector (default when no command given)')
+  .action(selectCommand);
 
 program
   .command('init')
@@ -34,7 +45,7 @@ program
 
 program
   .command('current')
-  .description('Show the active profile')
+  .description('Show the active legacy profile and isolated launch metadata')
   .action(currentCommand);
 
 program
@@ -43,6 +54,11 @@ program
   .description('List all profiles')
   .action(listCommand);
 
+program
+  .command('status')
+  .description('Show CSP status dashboard')
+  .action(statusCommand);
+
 program
   .command('create <name>')
   .description('Create a new profile from current Claude Code state')
@@ -61,9 +77,13 @@ program
   .description('Switch to a different profile')
   .option('--dry-run', 'Show what would change without executing')
   .option('--no-save', 'Skip saving current profile before switching')
-  .option('--force', 'Switch even if symlink targets are missing')
   .action(useCommand);
 
+program
+  .command('toggle')
+  .description('Switch to the previous profile')
+  .action(toggleCommand);
+
 program
   .command('delete <name>')
   .alias('rm')
@@ -89,6 +109,27 @@ program
   .description('Compare two profiles (use "current" for active profile)')
   .action(diffCommand);
 
+program
+  .command('deactivate')
+  .description('Deactivate the current profile (remove managed items from ~/.claude)')
+  .option('--no-save', 'Skip saving current profile before deactivating')
+  .action(deactivateCommand);
+
+program
+  .command('launch <name> [args...]')
+  .alias('la')
+  .description('Launch isolated Claude session for a profile (use --legacy-global for old switch+launch behavior)')
+  .option('--legacy-global', 'Use legacy global switch path before launching Claude')
+  .allowUnknownOption(true)
+  .enablePositionalOptions(true)
+  .passThroughOptions(true)
+  .action((name, args, options, cmd) => {
+    // Merge explicit positional args with unknown options (e.g. --dangerously-skip-permissions)
+    const unknownOpts = cmd.args.filter((a) => a !== name && !args.includes(a));
+    const claudeArgs = [...args, ...unknownOpts];
+    launchCommand(name, claudeArgs, options);
+  });
+
 program
   .command('uninstall')
   .description('Remove all profiles and restore Claude Code to pre-CSP state')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-switch-profile",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "description": "CLI tool for managing multiple Claude Code profiles",
   "type": "module",
   "bin": {

package/src/commands/create.js

@@ -1,8 +1,8 @@
-import { mkdirSync, cpSync, existsSync, statSync, writeFileSync, readFileSync, copyFileSync } from 'node:fs';
+import { mkdirSync, cpSync, existsSync, statSync, writeFileSync, copyFileSync, readdirSync, lstatSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { addProfile, getActive, setActive, profileExists, getProfileDir } from '../profile-store.js';
-import { saveFiles } from '../file-operations.js';
-import { CLAUDE_DIR, SYMLINK_ITEMS, SYMLINK_DIRS, SOURCE_FILE } from '../constants.js';
+import { saveFiles, updateSettingsPaths } from '../file-operations.js';
+import { CLAUDE_DIR, MANAGED_ITEMS, MANAGED_DIRS, SOURCE_FILE, NEVER_CLONE } from '../constants.js';
 import { success, error, info, warn } from '../output-helpers.js';
 
 export const createCommand = (name, options) => {
@@ -32,28 +32,36 @@ export const createCommand = (name, options) => {
 
     mkdirSync(profileDir, { recursive: true });
 
-    // Build source.json from the kit directory
+    // Copy items from source kit into profile dir
     const sourceMap = {};
-    for (const item of SYMLINK_ITEMS) {
+    for (const item of MANAGED_ITEMS) {
       const target = join(sourcePath, item);
       if (existsSync(target)) {
-        sourceMap[item] = target;
+        const dest = join(profileDir, item);
+        try {
+          if (statSync(target).isDirectory()) {
+            cpSync(target, dest, { recursive: true });
+          } else {
+            copyFileSync(target, dest);
+          }
+          sourceMap[item] = dest;
+        } catch { /* skip */ }
       }
     }
 
     if (Object.keys(sourceMap).length === 0) {
-      warn(`No recognized items found in "${sourcePath}". Expected: ${SYMLINK_ITEMS.join(', ')}`);
+      warn(`No recognized items found in "${sourcePath}". Expected: ${MANAGED_ITEMS.join(', ')}`);
     }
 
-    // Inherit missing items from current state (hooks, statusline, etc.)
-    for (const item of SYMLINK_ITEMS) {
+    // Inherit missing items from current ~/.claude state
+    for (const item of MANAGED_ITEMS) {
       if (sourceMap[item]) continue;
       const src = join(CLAUDE_DIR, item);
       if (!existsSync(src)) continue;
       try {
         const dest = join(profileDir, item);
         if (statSync(src).isDirectory()) {
-          cpSync(src, dest, { recursive: true, dereference: true });
+          cpSync(src, dest, { recursive: true });
         } else {
           copyFileSync(src, dest);
         }
@@ -62,33 +70,48 @@ export const createCommand = (name, options) => {
     }
 
     writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
-    info(`Linked to kit at ${sourcePath}`);
+    info(`Copied from kit at ${sourcePath}`);
     info(`Items found: ${Object.keys(sourceMap).join(', ') || 'none'}`);
 
     // Also copy current mutable files
     saveFiles(profileDir);
   } else {
-    // Create new independent profile — inherit infrastructure from current state
+    // Create new profile — full clone of ~/.claude/ (blacklist approach)
     mkdirSync(profileDir, { recursive: true });
 
-    // Copy all current symlink items (dirs + files) into profile — dereference symlinks
     const sourceMap = {};
-    for (const item of SYMLINK_ITEMS) {
-      const src = join(CLAUDE_DIR, item);
-      const dest = join(profileDir, item);
+    let entries;
+    try {
+      entries = readdirSync(CLAUDE_DIR);
+    } catch {
+      entries = [];
+    }
+
+    for (const entry of entries) {
+      if (NEVER_CLONE.includes(entry)) continue;
+
+      const src = join(CLAUDE_DIR, entry);
       try {
-        if (!existsSync(src)) continue;
-        if (statSync(src).isDirectory()) {
-          cpSync(src, dest, { recursive: true, dereference: true });
-        } else {
+        const stat = lstatSync(src);
+
+        if (stat.isDirectory()) {
+          const dest = join(profileDir, entry);
+          cpSync(src, dest, { recursive: true });
+          if (MANAGED_ITEMS.includes(entry)) {
+            sourceMap[entry] = dest;
+          }
+        } else if (stat.isFile()) {
+          const dest = join(profileDir, entry);
           copyFileSync(src, dest);
+          if (MANAGED_ITEMS.includes(entry)) {
+            sourceMap[entry] = dest;
+          }
         }
-        sourceMap[item] = dest;
       } catch { /* skip unreadable items */ }
     }
 
-    // Fallback: ensure empty dirs for any missing SYMLINK_DIRS
-    for (const item of SYMLINK_DIRS) {
+    // Ensure empty dirs for any missing MANAGED_DIRS
+    for (const item of MANAGED_DIRS) {
       if (!sourceMap[item]) {
         const itemDir = join(profileDir, item);
         mkdirSync(itemDir, { recursive: true });
@@ -98,21 +121,13 @@ export const createCommand = (name, options) => {
 
     writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
 
-    // Copy hooks config from settings.json (hooks won't run without it)
-    const settingsPath = join(CLAUDE_DIR, 'settings.json');
-    if (existsSync(settingsPath)) {
-      try {
-        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-        if (settings.hooks) {
-          writeFileSync(join(profileDir, 'settings.json'), JSON.stringify({ hooks: settings.hooks }, null, 2) + '\n');
-        }
-      } catch { /* parse error — skip */ }
-    }
+    // Update absolute paths in settings.json
+    updateSettingsPaths(profileDir, 'save');
 
-    info('Created new independent profile (infrastructure inherited)');
+    info('Created new profile (full clone of current state)');
   }
 
-  addProfile(name, { description: options.description || '' });
+  addProfile(name, { description: options.description || '', mode: 'account-session' });
 
   // Set as active if first profile
   if (!getActive()) {

package/src/commands/current.js

@@ -1,5 +1,4 @@
-import { getActive } from '../profile-store.js';
-import { getProfileDir } from '../profile-store.js';
+import { getActive, getProfileDir, getProfileMeta } from '../profile-store.js';
 import { success, info, warn } from '../output-helpers.js';
 
 export const currentCommand = () => {
@@ -8,6 +7,12 @@ export const currentCommand = () => {
     warn('No active profile. Run "csp create <name>" to create one.');
     return;
   }
-  success(`Active profile: ${active}`);
+  success(`Active legacy profile: ${active}`);
   info(`Location: ${getProfileDir(active)}`);
+
+  const meta = getProfileMeta(active);
+  if (meta?.lastLaunchAt) {
+    info(`Last isolated launch: ${meta.lastLaunchAt}`);
+    if (meta.runtimeDir) info(`Isolated runtime: ${meta.runtimeDir}`);
+  }
 };

package/src/commands/deactivate.js

@@ -0,0 +1,22 @@
+import { getActive, setActive } from '../profile-store.js';
+import { success, info } from '../output-helpers.js';
+import { DEFAULT_PROFILE } from '../constants.js';
+
+export const deactivateCommand = async () => {
+  const active = getActive();
+  if (!active) {
+    info('No active profile to deactivate.');
+    return;
+  }
+
+  if (active === DEFAULT_PROFILE) {
+    info('Default profile uses ~/.claude directly. Nothing to deactivate.');
+    return;
+  }
+
+  // Just reset to default — never touch ~/.claude
+  setActive(DEFAULT_PROFILE);
+
+  success(`Profile "${active}" deactivated. Reset to default.`);
+  info('~/.claude was not modified.');
+};