claude-switch-profile 1.4.0 → 1.4.2

package/src/commands/import.js

@@ -1,11 +1,47 @@
 import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync } from 'node:fs';
-import { resolve, basename } from 'node:path';
+import { existsSync, mkdirSync, lstatSync, readlinkSync, readdirSync, rmSync } from 'node:fs';
+import { resolve, basename, dirname, join } from 'node:path';
 import { addProfile, profileExists, getProfileDir, ensureProfilesDir } from '../profile-store.js';
 import { isWindows } from '../platform.js';
 import { validateProfile } from '../profile-validator.js';
+import { MANAGED_ITEMS, COPY_ITEMS, COPY_DIRS } from '../constants.js';
 import { success, error, warn } from '../output-helpers.js';
 
+const IMPORT_SAFE_ITEMS = [...new Set([...MANAGED_ITEMS, ...COPY_ITEMS, ...COPY_DIRS])];
+
+const isWithinDir = (baseDir, targetPath) => {
+  const normalizedBase = resolve(baseDir);
+  const normalizedTarget = resolve(targetPath);
+  return normalizedTarget === normalizedBase || normalizedTarget.startsWith(normalizedBase + '/');
+};
+
+const findUnsafeManagedSymlink = (profileDir) => {
+  const pending = IMPORT_SAFE_ITEMS.map((item) => join(profileDir, item)).filter((itemPath) => existsSync(itemPath));
+
+  while (pending.length > 0) {
+    const currentPath = pending.pop();
+    const stat = lstatSync(currentPath);
+
+    if (stat.isSymbolicLink()) {
+      const linkTarget = readlinkSync(currentPath);
+      const resolvedTarget = resolve(dirname(currentPath), linkTarget);
+      if (!isWithinDir(profileDir, resolvedTarget)) {
+        return { path: currentPath, target: linkTarget };
+      }
+      continue;
+    }
+
+    if (!stat.isDirectory()) continue;
+
+    const entries = readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      pending.push(join(currentPath, entry.name));
+    }
+  }
+
+  return null;
+};
+
 export const importCommand = (file, options) => {
   const filePath = resolve(file);
   if (!existsSync(filePath)) {
@@ -47,6 +83,15 @@ export const importCommand = (file, options) => {
     validation.errors.forEach((e) => warn(`  ${e}`));
   }
 
+  const unsafeSymlink = findUnsafeManagedSymlink(profileDir);
+  if (unsafeSymlink) {
+    rmSync(profileDir, { recursive: true, force: true });
+    error(
+      `Imported profile contains an unsafe symlink outside the profile tree: ${unsafeSymlink.path} -> ${unsafeSymlink.target}`,
+    );
+    process.exit(1);
+  }
+
   addProfile(name, { description: options.description || `Imported from ${basename(file)}` });
   success(`Profile "${name}" imported from ${filePath}`);
 };

package/src/commands/init.js

@@ -1,23 +1,43 @@
 import { existsSync } from 'node:fs';
-import { ensureProfilesDir, getActive, addProfile, setActive } from '../profile-store.js';
-import { success, info } from '../output-helpers.js';
-import { PROFILES_DIR } from '../constants.js';
+import {
+  ensureProfilesDir,
+  ensureDefaultProfileSnapshot,
+  getActive,
+  readProfiles,
+  addProfile,
+  setActive,
+  getProfileDir,
+} from '../profile-store.js';
+import { success, info, error } from '../output-helpers.js';
+import { PROFILES_DIR, DEFAULT_PROFILE } from '../constants.js';
 
 export const initCommand = () => {
   const active = getActive();
+
+  ensureProfilesDir();
+  info('Initializing Claude Switch Profile...');
+
+  const profiles = readProfiles();
+  if (!profiles[DEFAULT_PROFILE]) {
+    addProfile(DEFAULT_PROFILE, { description: 'Vanilla Claude defaults', mode: 'legacy' });
+  }
+
+  try {
+    ensureDefaultProfileSnapshot();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+
   if (existsSync(PROFILES_DIR) && active) {
     info(`Already initialized. Active profile: "${active}"`);
     info(`Profiles directory: ${PROFILES_DIR}`);
     return;
   }
 
-  ensureProfilesDir();
-  info('Initializing Claude Switch Profile...');
-
-  addProfile('default', { description: 'Vanilla Claude defaults', mode: 'legacy' });
-  setActive('default');
+  setActive(DEFAULT_PROFILE);
 
   success('Initialization complete.');
-  info('"default" profile uses ~/.claude directly — no copy/restore needed.');
+  info(`Created physical default profile at ${getProfileDir(DEFAULT_PROFILE)}`);
   info('Run "csp create <name>" to capture your current setup into a new profile.');
 };

package/src/commands/launch.js

@@ -1,7 +1,7 @@
 import { execFileSync, spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { profileExists } from '../profile-store.js';
+import { profileExists, ensureDefaultProfileSnapshot } from '../profile-store.js';
 import { useCommand } from './use.js';
 import { ensureRuntimeInstance } from '../runtime-instance-manager.js';
 import { withRuntimeLock } from '../safety.js';
@@ -128,6 +128,15 @@ export const stripInheritedLaunchEnv = (env = process.env) => {
 };
 
 export const launchCommand = async (name, claudeArgs, options = {}) => {
+  if (name === DEFAULT_PROFILE) {
+    try {
+      ensureDefaultProfileSnapshot();
+    } catch (err) {
+      error(err.message);
+      process.exit(1);
+    }
+  }
+
   if (!profileExists(name)) {
     error(`Profile "${name}" does not exist. Run "csp list" to see available profiles.`);
     process.exit(1);
@@ -142,12 +151,8 @@ export const launchCommand = async (name, claudeArgs, options = {}) => {
   let launchEnv = { ...process.env };
 
   if (options.legacyGlobal || legacyFromArgs) {
-    // Legacy path: keep historical behavior for compatibility.
     await useCommand(name, { save: true, skipClaudeCheck: true });
     info(`Launching legacy/global mode: claude ${args.join(' ')}`.trim());
-  } else if (name === DEFAULT_PROFILE) {
-    // Default profile: launch Claude using ~/.claude natively — no runtime override
-    info(`Launching with default profile (using ~/.claude directly): claude ${args.join(' ')}`.trim());
   } else {
     const runtimeDir = await withRuntimeLock(name, async () => ensureRuntimeInstance(name));
     const { profileSettingsEnv, profileDotEnvEnv } = readProfileLaunchEnvSources(runtimeDir);

package/src/commands/save.js

@@ -1,7 +1,7 @@
-import { getActive, profileExists, getProfileDir } from '../profile-store.js';
+import { getActive, profileExists, getProfileDir, ensureDefaultProfileSnapshot } from '../profile-store.js';
 import { saveItems } from '../item-manager.js';
 import { saveFiles, updateSettingsPaths } from '../file-operations.js';
-import { success, error, info } from '../output-helpers.js';
+import { success, error } from '../output-helpers.js';
 import { DEFAULT_PROFILE } from '../constants.js';
 
 export const saveCommand = () => {
@@ -12,8 +12,12 @@ export const saveCommand = () => {
   }
 
   if (active === DEFAULT_PROFILE) {
-    info('Default profile uses ~/.claude directly. No save needed.');
-    return;
+    try {
+      ensureDefaultProfileSnapshot();
+    } catch (err) {
+      error(err.message);
+      process.exit(1);
+    }
   }
 
   if (!profileExists(active)) {

package/src/commands/uninstall.js

@@ -1,6 +1,6 @@
 import { existsSync, rmSync } from 'node:fs';
 import { createInterface } from 'node:readline';
-import { getActive, profileExists, getProfileDir } from '../profile-store.js';
+import { getActive, profileExists, getProfileDir, ensureDefaultProfileSnapshot } from '../profile-store.js';
 import { removeItems, restoreItems } from '../item-manager.js';
 import { removeFiles, restoreFiles } from '../file-operations.js';
 import { withLock, createBackup, warnIfClaudeRunning } from '../safety.js';
@@ -26,15 +26,23 @@ export const uninstallCommand = async (options) => {
     return;
   }
 
+  const restoreProfile = options.profile || active;
+  if (restoreProfile === DEFAULT_PROFILE) {
+    try {
+      ensureDefaultProfileSnapshot();
+    } catch (err) {
+      error(err.message);
+      process.exit(1);
+    }
+  }
+
   // Show what will happen
   console.log('');
   info('This will:');
   if (options.profile && profileExists(options.profile)) {
     info(`  1. Restore profile "${options.profile}" to ~/.claude`);
-  } else if (active && active !== DEFAULT_PROFILE && profileExists(active)) {
+  } else if (active && profileExists(active)) {
     info(`  1. Restore active profile "${active}" to ~/.claude (use --profile <name> to choose)`);
-  } else if (active === DEFAULT_PROFILE) {
-    info('  1. Default profile — ~/.claude already in correct state');
   } else {
     warn('  1. No profile to restore (managed items will be removed)');
   }
@@ -61,26 +69,15 @@ export const uninstallCommand = async (options) => {
       // Non-critical — profiles dir may be empty
     }
 
-    // 2. Determine which profile to restore
-    const restoreProfile = options.profile || active;
-
-    // 3. Remove current managed items from ~/.claude (skip for default — items live there)
-    if (restoreProfile !== DEFAULT_PROFILE) {
-      removeItems();
-      removeFiles();
-    }
+    // 2. Remove current managed items from ~/.claude
+    removeItems();
+    removeFiles();
 
-    // 4. Restore the chosen profile's config
-    if (restoreProfile === DEFAULT_PROFILE) {
-      info('Default profile — ~/.claude already in correct state.');
-    } else if (restoreProfile && profileExists(restoreProfile)) {
+    // 3. Restore the chosen profile's config
+    if (restoreProfile && profileExists(restoreProfile)) {
       const profileDir = getProfileDir(restoreProfile);
-      // If restoring the active profile: items already in ~/.claude (moved there on switch)
-      // If restoring a different profile: need to restore from profileDir
-      if (restoreProfile !== active) {
-        restoreItems(profileDir);
-        restoreFiles(profileDir);
-      }
+      restoreItems(profileDir);
+      restoreFiles(profileDir);
       success(`Restored "${restoreProfile}" profile to ~/.claude`);
     } else {
       warn('No profile restored. ~/.claude managed items have been cleared.');

package/src/commands/use.js

@@ -1,24 +1,53 @@
-import { getActive, setActive, profileExists, getProfileDir, getProfileMeta, setPrevious } from '../profile-store.js';
-import { moveItemsToProfile, moveItemsToClaude, saveItems, removeItems } from '../item-manager.js';
-import { saveFiles, removeFiles, restoreFiles, updateSettingsPaths, moveDirsToProfile, moveDirsToClaude } from '../file-operations.js';
+import {
+  getActive,
+  setActive,
+  profileExists,
+  getProfileDir,
+  getProfileMeta,
+  setPrevious,
+  ensureDefaultProfileSnapshot,
+} from '../profile-store.js';
+import { moveItemsToProfile, moveItemsToClaude, removeItems } from '../item-manager.js';
+import {
+  saveFiles,
+  removeFiles,
+  restoreFiles,
+  updateSettingsPaths,
+  moveDirsToProfile,
+  moveDirsToClaude,
+} from '../file-operations.js';
 import { validateProfile } from '../profile-validator.js';
 import { withLock, assertClaudeNotRunning } from '../safety.js';
 import { success, error, info, warn } from '../output-helpers.js';
 import { CLAUDE_DIR, DEFAULT_PROFILE } from '../constants.js';
 
-export const useCommand = async (name, options) => {
-  // Warn about legacy behavior (skip if called internally from launch --legacy-global)
+const ensureDefaultProfileIfNeeded = (name) => {
+  if (name !== DEFAULT_PROFILE) return;
+
+  try {
+    ensureDefaultProfileSnapshot();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+};
+
+export const useCommand = async (name, options = {}) => {
   if (!options.skipClaudeCheck) {
     warn('Note: "csp use" modifies ~/.claude directly (legacy mode).');
     info('Prefer "csp launch <name>" for isolated sessions that never touch ~/.claude.');
   }
 
+  ensureDefaultProfileIfNeeded(name);
+
   if (!profileExists(name)) {
     error(`Profile "${name}" does not exist. Run "csp list" to see available profiles.`);
     process.exit(1);
   }
 
   const active = getActive();
+  ensureDefaultProfileIfNeeded(active);
+
   if (active === name) {
     info(`Profile "${name}" is already active.`);
     return;
@@ -32,14 +61,11 @@ export const useCommand = async (name, options) => {
     info('Legacy "csp use" mutates global ~/.claude state.');
   }
 
-  // Validate target profile (skip for default — it's a pass-through)
-  if (name !== DEFAULT_PROFILE) {
-    const validation = validateProfile(profileDir);
-    if (!validation.valid) {
-      error(`Profile "${name}" is invalid:`);
-      validation.errors.forEach((e) => error(`  ${e}`));
-      process.exit(1);
-    }
+  const validation = validateProfile(profileDir);
+  if (!validation.valid) {
+    error(`Profile "${name}" is invalid:`);
+    validation.errors.forEach((validationError) => error(`  ${validationError}`));
+    process.exit(1);
   }
 
   if (options.dryRun) {
@@ -58,54 +84,33 @@ export const useCommand = async (name, options) => {
   }
 
   await withLock(async () => {
-    // 1. Save current state (skip if from=default — ~/.claude IS default)
-    if (active && active !== DEFAULT_PROFILE && profileExists(active) && options.save !== false) {
+    if (active && profileExists(active) && options.save !== false) {
       const activeDir = getProfileDir(active);
-      if (name === DEFAULT_PROFILE) {
-        saveItems(activeDir);
-        saveFiles(activeDir);
-      } else {
-        moveItemsToProfile(activeDir);
-        saveFiles(activeDir);
-        moveDirsToProfile(activeDir);
-      }
+      moveItemsToProfile(activeDir);
+      saveFiles(activeDir);
+      moveDirsToProfile(activeDir);
       updateSettingsPaths(activeDir, 'save');
       info(`Saved current state to "${active}"`);
     }
 
-    // 2. Remove leftovers only when switching to non-default
-    if (name !== DEFAULT_PROFILE) {
-      if (active !== DEFAULT_PROFILE) {
-        removeItems();
-      }
-      removeFiles();
-    }
+    removeItems();
+    removeFiles();
 
-    // 3. Restore target (skip if to=default — ~/.claude already correct)
-    if (name !== DEFAULT_PROFILE) {
-      try {
-        moveItemsToClaude(profileDir);
-        restoreFiles(profileDir);
-        moveDirsToClaude(profileDir);
-        updateSettingsPaths(CLAUDE_DIR, 'restore', profileDir);
-      } catch (err) {
-        warn(`Switch failed: ${err.message}`);
-        error('Manual recovery: re-run "csp use <profile>" or restore from profile directory.');
-        throw err;
-      }
+    try {
+      moveItemsToClaude(profileDir);
+      restoreFiles(profileDir);
+      moveDirsToClaude(profileDir);
+      updateSettingsPaths(CLAUDE_DIR, 'restore', profileDir);
+    } catch (err) {
+      warn(`Switch failed: ${err.message}`);
+      error('Manual recovery: re-run "csp use <profile>" or restore from profile directory.');
+      throw err;
     }
 
-    // Track previous profile for toggle
     if (active) setPrevious(active);
-
-    // 4. Update active marker
     setActive(name);
 
     success(`Switched to profile "${name}"`);
-    if (name === DEFAULT_PROFILE) {
-      info('Using ~/.claude directly (default profile).');
-    } else {
-      info('Restart your Claude Code session to apply changes.');
-    }
+    info('Restart your Claude Code session to apply changes.');
   });
 };

package/src/constants.js

@@ -19,7 +19,7 @@ export const RUNTIMES_DIR = join(PROFILES_DIR, RUNTIME_DIR_NAME);
 export const LAUNCH_CONFIG_ENV = 'CLAUDE_CONFIG_DIR';
 export const LAUNCH_ANTHROPIC_ENV_KEYS = ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_MODEL'];
 
-// Items managed via copy (formerly symlinks — now always copied)
+// Items managed by snapshot/move flows; file/dir/symlink shape is preserved
 export const MANAGED_ITEMS = [
   'CLAUDE.md',
   'rules',

package/src/file-operations.js

@@ -1,5 +1,5 @@
-import { existsSync, copyFileSync, cpSync, unlinkSync, rmSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, cpSync, unlinkSync, rmSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
 import { CLAUDE_DIR, COPY_ITEMS, COPY_DIRS } from './constants.js';
 
 // Rename-based dir move with EXDEV fallback
@@ -9,12 +9,18 @@ const moveDir = (src, dest) => {
     renameSync(src, dest);
   } catch (err) {
     if (err.code === 'EXDEV') {
-      cpSync(src, dest, { recursive: true });
+      cpSync(src, dest, { recursive: true, verbatimSymlinks: true });
       rmSync(src, { recursive: true, force: true });
     } else throw err;
   }
 };
 
+const copyPathPreservingSymlink = (src, dest) => {
+  mkdirSync(dirname(dest), { recursive: true });
+  rmSync(dest, { recursive: true, force: true });
+  cpSync(src, dest, { recursive: true, verbatimSymlinks: true });
+};
+
 // Copy COPY_ITEMS files + COPY_DIRS dirs from ~/.claude to profileDir
 export const saveFiles = (profileDir) => {
   mkdirSync(profileDir, { recursive: true });
@@ -22,16 +28,14 @@ export const saveFiles = (profileDir) => {
   for (const item of COPY_ITEMS) {
     const src = join(CLAUDE_DIR, item);
     if (existsSync(src)) {
-      copyFileSync(src, join(profileDir, item));
+      copyPathPreservingSymlink(src, join(profileDir, item));
     }
   }
 
   for (const dir of COPY_DIRS) {
     const src = join(CLAUDE_DIR, dir);
     if (existsSync(src)) {
-      const dest = join(profileDir, dir);
-      rmSync(dest, { recursive: true, force: true });
-      cpSync(src, dest, { recursive: true });
+      copyPathPreservingSymlink(src, join(profileDir, dir));
     }
   }
 };
@@ -41,16 +45,14 @@ export const restoreFiles = (profileDir) => {
   for (const item of COPY_ITEMS) {
     const src = join(profileDir, item);
     if (existsSync(src)) {
-      copyFileSync(src, join(CLAUDE_DIR, item));
+      copyPathPreservingSymlink(src, join(CLAUDE_DIR, item));
     }
   }
 
   for (const dir of COPY_DIRS) {
     const src = join(profileDir, dir);
     if (existsSync(src)) {
-      const dest = join(CLAUDE_DIR, dir);
-      rmSync(dest, { recursive: true, force: true });
-      cpSync(src, dest, { recursive: true });
+      copyPathPreservingSymlink(src, join(CLAUDE_DIR, dir));
     }
   }
 };

package/src/item-manager.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, cpSync, rmSync, mkdirSync, lstatSync, copyFileSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, cpSync, rmSync, mkdirSync, lstatSync, renameSync } from 'node:fs';
 import { join, dirname, basename } from 'node:path';
 import { CLAUDE_DIR, MANAGED_ITEMS, SOURCE_FILE } from './constants.js';
 
@@ -13,7 +13,7 @@ const moveItem = (src, dest) => {
     renameSync(src, dest);
   } catch (err) {
     if (err.code === 'EXDEV') {
-      cpSync(src, dest, { recursive: true, filter: skipHeavyDirs });
+      cpSync(src, dest, { recursive: true, filter: skipHeavyDirs, verbatimSymlinks: true });
       rmSync(src, { recursive: true, force: true });
     } else throw err;
   }
@@ -49,6 +49,12 @@ export const removeItems = () => {
   }
 };
 
+const copyItemPreservingSymlink = (src, dest) => {
+  mkdirSync(dirname(dest), { recursive: true });
+  rmSync(dest, { recursive: true, force: true });
+  cpSync(src, dest, { recursive: true, verbatimSymlinks: true });
+};
+
 // Copy managed items from ~/.claude into profileDir, write source.json manifest (non-destructive)
 export const copyItems = (profileDir) => {
   const sourceMap = {};
@@ -58,14 +64,7 @@ export const copyItems = (profileDir) => {
       if (!existsSync(itemPath)) continue;
 
       const dest = join(profileDir, item);
-      const stat = lstatSync(itemPath);
-
-      if (stat.isDirectory()) {
-        rmSync(dest, { recursive: true, force: true });
-        cpSync(itemPath, dest, { recursive: true });
-      } else if (stat.isFile()) {
-        copyFileSync(itemPath, dest);
-      }
+      copyItemPreservingSymlink(itemPath, dest);
       sourceMap[item] = dest;
     } catch {
       // Not readable — skip
@@ -99,12 +98,7 @@ export const restoreItems = (profileDir) => {
     // Copy from profile (or external legacy path) into ~/.claude
     if (existsSync(srcPath)) {
       try {
-        const stat = lstatSync(srcPath);
-        if (stat.isDirectory()) {
-          cpSync(srcPath, dest, { recursive: true });
-        } else if (stat.isFile()) {
-          copyFileSync(srcPath, dest);
-        }
+        copyItemPreservingSymlink(srcPath, dest);
       } catch {
         // skip unreadable
       }

package/src/profile-store.js

@@ -1,5 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
+import { saveFiles, updateSettingsPaths } from './file-operations.js';
+import { copyItems } from './item-manager.js';
 import {
   PROFILES_DIR,
   ACTIVE_FILE,
@@ -53,6 +55,15 @@ const normalizeProfiles = (raw) => {
   return normalized;
 };
 
+const backfillDefaultProfileSnapshot = () => {
+  const profileDir = getProfileDir(DEFAULT_PROFILE);
+  mkdirSync(profileDir, { recursive: true });
+  copyItems(profileDir);
+  saveFiles(profileDir);
+  updateSettingsPaths(profileDir, 'save');
+  return profileDir;
+};
+
 export const readProfiles = () => {
   const metaPath = join(PROFILES_DIR, PROFILES_META);
   if (!existsSync(metaPath)) return {};
@@ -130,12 +141,27 @@ export const removeProfile = (name) => {
   writeProfiles(profiles);
 };
 
+export const ensureDefaultProfileSnapshot = () => {
+  const profileDir = getProfileDir(DEFAULT_PROFILE);
+  if (existsSync(profileDir)) return profileDir;
+
+  const profiles = readProfiles();
+  if (!profiles[DEFAULT_PROFILE]) return profileDir;
+
+  const active = getActive();
+  if (active && active !== DEFAULT_PROFILE) {
+    throw new Error(
+      `Default profile snapshot is missing for this legacy install while "${active}" is active. CSP cannot safely recreate "default" from the current ~/.claude state. Switch back to your intended default baseline, then retry.`,
+    );
+  }
+
+  return backfillDefaultProfileSnapshot();
+};
+
 export const profileExists = (name) => {
-  if (name === DEFAULT_PROFILE) return true;
   return existsSync(getProfileDir(name));
 };
 
-// Validate profile name — prevent path traversal and injection
 const SAFE_NAME = /^[a-zA-Z0-9_-]+$/;
 export const validateName = (name) => {
   if (!name || !SAFE_NAME.test(name)) {
@@ -170,31 +196,28 @@ export const updateProfileMeta = (name, patch) => {
 
 export const markRuntimeInitialized = (name, runtimeDir) => {
   const now = new Date().toISOString();
-  return updateProfileMeta(name, {
+  return updateProfileMeta(name, (meta) => ({
+    ...meta,
     runtimeDir,
     runtimeInitializedAt: now,
     lastLaunchAt: now,
-    mode: 'account-session',
-  });
+    mode: name === DEFAULT_PROFILE ? meta.mode : 'account-session',
+  }));
 };
 
 export const markProfileLaunched = (name) => {
-  return updateProfileMeta(name, {
+  return updateProfileMeta(name, (meta) => ({
+    ...meta,
     lastLaunchAt: new Date().toISOString(),
-    mode: 'account-session',
-  });
+    mode: name === DEFAULT_PROFILE ? meta.mode : 'account-session',
+  }));
 };
 
 export const listProfileNames = () => {
   return Object.keys(readProfiles());
 };
 
-// Returns the directory containing a profile's actual files.
-// If profile is active, items were moved to CLAUDE_DIR during switch.
-// If profile is not active, items are in profileDir.
 export const getEffectiveDir = (name) => {
-  if (name === DEFAULT_PROFILE) return CLAUDE_DIR;
   const active = getActive();
-  if (active === name) return CLAUDE_DIR;
-  return getProfileDir(name);
+  return active === name ? CLAUDE_DIR : getProfileDir(name);
 };