claude-switch-profile 1.0.2 → 1.4.0

package/src/commands/create.js

@@ -1,8 +1,8 @@
-import { mkdirSync, cpSync, existsSync, writeFileSync, readdirSync } 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 { 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,44 +32,102 @@ 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 ~/.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 });
+        } else {
+          copyFileSync(src, dest);
+        }
+        sourceMap[item] = dest;
+      } catch { /* skip */ }
     }
 
     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 brand new independent profile — everything fresh, nothing copied
+    // Create new profile — full clone of ~/.claude/ (blacklist approach)
     mkdirSync(profileDir, { recursive: true });
 
-    // Create self-contained directories for each symlink directory item
     const sourceMap = {};
-    for (const item of SYMLINK_DIRS) {
-      const itemDir = join(profileDir, item);
-      mkdirSync(itemDir, { recursive: true });
-      sourceMap[item] = itemDir;
+    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 {
+        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;
+          }
+        }
+      } catch { /* skip unreadable items */ }
+    }
+
+    // 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 });
+        sourceMap[item] = itemDir;
+      }
     }
 
     writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
-    // Do NOT call saveFiles() — new profile should start clean
-    // without inheriting settings.json, .env, .ck*, etc. from current state
-    info('Created new independent profile (clean state)');
+
+    // Update absolute paths in settings.json
+    updateSettingsPaths(profileDir, 'save');
+
+    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.');
+};

package/src/commands/delete.js

@@ -1,7 +1,8 @@
 import { rmSync } from 'node:fs';
 import { createInterface } from 'node:readline';
-import { getActive, removeProfile, profileExists, getProfileDir } from '../profile-store.js';
-import { success, error, warn } from '../output-helpers.js';
+import { getActive, clearActive, removeProfile, profileExists, getProfileDir } from '../profile-store.js';
+import { success, error, warn, info } from '../output-helpers.js';
+import { DEFAULT_PROFILE } from '../constants.js';
 
 const confirm = (question) => {
   return new Promise((resolve) => {
@@ -14,14 +15,13 @@ const confirm = (question) => {
 };
 
 export const deleteCommand = async (name, options) => {
-  if (!profileExists(name)) {
-    error(`Profile "${name}" does not exist.`);
+  if (name === DEFAULT_PROFILE) {
+    error('Cannot delete the default profile.');
     process.exit(1);
   }
 
-  const active = getActive();
-  if (active === name) {
-    error(`Cannot delete active profile "${name}". Switch to another profile first.`);
+  if (!profileExists(name)) {
+    error(`Profile "${name}" does not exist.`);
     process.exit(1);
   }
 
@@ -33,8 +33,20 @@ export const deleteCommand = async (name, options) => {
     }
   }
 
+  const active = getActive();
   const profileDir = getProfileDir(name);
+
+  // Delete profile directory
   rmSync(profileDir, { recursive: true, force: true });
   removeProfile(name);
+
+  // If deleting the active profile, just clear the marker
+  // NEVER touch ~/.claude — leave symlinks/files as-is
+  if (active === name) {
+    clearActive();
+    info('Was active profile — active marker cleared.');
+    info('Symlinks in ~/.claude may now be dangling. Run "csp use <profile>" to switch.');
+  }
+
   success(`Profile "${name}" deleted.`);
 };

package/src/commands/diff.js

@@ -1,8 +1,8 @@
 import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import chalk from 'chalk';
-import { profileExists, getProfileDir, getActive } from '../profile-store.js';
-import { SOURCE_FILE } from '../constants.js';
+import { profileExists, getActive, getEffectiveDir } from '../profile-store.js';
+import { SOURCE_FILE, ALL_MANAGED } from '../constants.js';
 import { error, info } from '../output-helpers.js';
 
 export const diffCommand = (profileA, profileB) => {
@@ -31,19 +31,29 @@ export const diffCommand = (profileA, profileB) => {
     process.exit(1);
   }
 
-  const dirA = getProfileDir(nameA);
-  const dirB = getProfileDir(nameB);
+  const dirA = getEffectiveDir(nameA);
+  const dirB = getEffectiveDir(nameB);
 
   console.log(`\n${chalk.bold('Comparing:')} ${chalk.cyan(nameA)} ↔ ${chalk.cyan(nameB)}\n`);
 
-  // Compare source.json (symlink targets)
+  // Compare source.json (managed item sources)
   const sourceA = readJsonSafe(join(dirA, SOURCE_FILE));
   const sourceB = readJsonSafe(join(dirB, SOURCE_FILE));
-  diffObject('Symlink targets (source.json)', sourceA, sourceB, nameA, nameB);
+  diffObject('Managed item sources (source.json)', sourceA, sourceB, nameA, nameB);
 
   // Compare files that exist in either profile
-  const filesA = new Set(readdirSync(dirA).filter((f) => f !== SOURCE_FILE));
-  const filesB = new Set(readdirSync(dirB).filter((f) => f !== SOURCE_FILE));
+  // When reading from CLAUDE_DIR (active/default profile), filter to only managed items
+  const active = getActive();
+  const managedSet = new Set(ALL_MANAGED);
+  const listManagedFiles = (dir) => {
+    const all = readdirSync(dir).filter((f) => f !== SOURCE_FILE);
+    if ((dir === dirA && active === nameA) || (dir === dirB && active === nameB)) {
+      return new Set(all.filter((f) => managedSet.has(f)));
+    }
+    return new Set(all);
+  };
+  const filesA = listManagedFiles(dirA, nameA);
+  const filesB = listManagedFiles(dirB, nameB);
 
   const allFiles = new Set([...filesA, ...filesB]);
   const diffs = [];
@@ -73,7 +83,7 @@ export const diffCommand = (profileA, profileB) => {
   }
 
   if (diffs.length === 0) {
-    info('Profiles are identical (excluding symlink targets).');
+    info('Profiles are identical (excluding source paths).');
   } else {
     console.log(chalk.bold('File differences:'));
     for (const d of diffs) {

package/src/commands/export.js

@@ -1,10 +1,18 @@
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { profileExists, getProfileDir } from '../profile-store.js';
-import { success, error } from '../output-helpers.js';
+import { profileExists, getProfileDir, getActive } from '../profile-store.js';
+import { isWindows } from '../platform.js';
+import { saveItems } from '../item-manager.js';
+import { saveFiles, updateSettingsPaths } from '../file-operations.js';
+import { success, error, info } from '../output-helpers.js';
+import { DEFAULT_PROFILE } from '../constants.js';
 
 export const exportCommand = (name, options) => {
+  if (name === DEFAULT_PROFILE) {
+    error('Cannot export the default profile (it uses ~/.claude directly).');
+    process.exit(1);
+  }
+
   if (!profileExists(name)) {
     error(`Profile "${name}" does not exist.`);
     process.exit(1);
@@ -14,11 +22,28 @@ export const exportCommand = (name, options) => {
   const output = options.output || `./${name}.csp.tar.gz`;
   const outputPath = resolve(output);
 
+  // If exporting active profile, save a copy first (non-destructive)
+  const active = getActive();
+  if (active === name) {
+    saveItems(profileDir);
+    saveFiles(profileDir);
+    updateSettingsPaths(profileDir, 'save');
+    info('Saved current state before export.');
+  }
+
+  const tarArgs = isWindows
+    ? ['--force-local', '-czf', outputPath, '-C', profileDir.replace(/\\/g, '/'), '.']
+    : ['-czf', outputPath, '-C', profileDir, '.'];
+
   try {
-    execFileSync('tar', ['-czf', outputPath, '-C', profileDir, '.'], { stdio: 'pipe' });
+    execFileSync(isWindows ? 'tar.exe' : 'tar', tarArgs, { stdio: 'pipe' });
     success(`Profile "${name}" exported to ${outputPath}`);
   } catch (err) {
-    error(`Failed to export: ${err.message}`);
+    if (err.code === 'ENOENT') {
+      error('tar command not found. On Windows, tar is available on Windows 10+.');
+    } else {
+      error(`Failed to export: ${err.message}`);
+    }
     process.exit(1);
   }
 };

package/src/commands/import.js

@@ -2,6 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync } from 'node:fs';
 import { resolve, basename } from 'node:path';
 import { addProfile, profileExists, getProfileDir, ensureProfilesDir } from '../profile-store.js';
+import { isWindows } from '../platform.js';
 import { validateProfile } from '../profile-validator.js';
 import { success, error, warn } from '../output-helpers.js';
 
@@ -24,10 +25,18 @@ export const importCommand = (file, options) => {
   const profileDir = getProfileDir(name);
   mkdirSync(profileDir, { recursive: true });
 
+  const tarArgs = isWindows
+    ? ['--force-local', '-xzf', filePath, '-C', profileDir.replace(/\\/g, '/')]
+    : ['-xzf', filePath, '-C', profileDir];
+
   try {
-    execFileSync('tar', ['-xzf', filePath, '-C', profileDir], { stdio: 'pipe' });
+    execFileSync(isWindows ? 'tar.exe' : 'tar', tarArgs, { stdio: 'pipe' });
   } catch (err) {
-    error(`Failed to extract: ${err.message}`);
+    if (err.code === 'ENOENT') {
+      error('tar command not found. On Windows, tar is available on Windows 10+.');
+    } else {
+      error(`Failed to extract: ${err.message}`);
+    }
     process.exit(1);
   }
 

package/src/commands/init.js

@@ -1,12 +1,11 @@
 import { existsSync } from 'node:fs';
-import { ensureProfilesDir, getActive, profileExists } from '../profile-store.js';
-import { createCommand } from './create.js';
-import { success, info, warn } from '../output-helpers.js';
+import { ensureProfilesDir, getActive, addProfile, setActive } from '../profile-store.js';
+import { success, info } from '../output-helpers.js';
 import { PROFILES_DIR } from '../constants.js';
 
 export const initCommand = () => {
-  if (existsSync(PROFILES_DIR) && getActive()) {
-    const active = getActive();
+  const active = getActive();
+  if (existsSync(PROFILES_DIR) && active) {
     info(`Already initialized. Active profile: "${active}"`);
     info(`Profiles directory: ${PROFILES_DIR}`);
     return;
@@ -15,7 +14,10 @@ export const initCommand = () => {
   ensureProfilesDir();
   info('Initializing Claude Switch Profile...');
 
-  // Create default profile from current state
-  createCommand('default', { description: 'Default profile (initial capture)' });
-  success('Initialization complete. Your current setup is saved as "default".');
+  addProfile('default', { description: 'Vanilla Claude defaults', mode: 'legacy' });
+  setActive('default');
+
+  success('Initialization complete.');
+  info('"default" profile uses ~/.claude directly — no copy/restore needed.');
+  info('Run "csp create <name>" to capture your current setup into a new profile.');
 };

package/src/commands/launch.js

@@ -0,0 +1,216 @@
+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 { useCommand } from './use.js';
+import { ensureRuntimeInstance } from '../runtime-instance-manager.js';
+import { withRuntimeLock } from '../safety.js';
+import { error, info, warn } from '../output-helpers.js';
+import { isWindows } from '../platform.js';
+import { LAUNCH_CONFIG_ENV, DEFAULT_PROFILE } from '../constants.js';
+import { buildEffectiveLaunchEnv, parseDotEnvLaunchEnv, parseSettingsLaunchEnv, sanitizeInheritedLaunchEnv } from '../launch-effective-env-resolver.js';
+
+const isTruthyDebugValue = (value) => {
+  if (value === undefined || value === null) return false;
+  const normalized = String(value).trim().toLowerCase();
+  return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+};
+
+const findWindowsClaudePath = (env, dependencies = {}) => {
+  const execRunner = dependencies.execFileSync || execFileSync;
+  const pathExists = dependencies.existsSync || existsSync;
+
+  const pathMatches = (() => {
+    try {
+      return execRunner('where.exe', ['claude'], {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        env,
+      })
+        .trim()
+        .split(/\r?\n/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    } catch {
+      return [];
+    }
+  })();
+
+  const resolvedFromPath = pathMatches.find((entry) => /\.(exe|cmd|bat)$/i.test(entry)) || pathMatches[0];
+  if (resolvedFromPath && pathExists(resolvedFromPath)) {
+    return resolvedFromPath;
+  }
+
+  const fallbackCandidates = [
+    env.USERPROFILE ? join(env.USERPROFILE, '.local', 'bin', 'claude.exe') : null,
+    env.APPDATA ? join(env.APPDATA, 'npm', 'claude.cmd') : null,
+    env.USERPROFILE ? join(env.USERPROFILE, '.bun', 'bin', 'claude.exe') : null,
+  ].filter(Boolean);
+
+  return fallbackCandidates.find((candidate) => pathExists(candidate)) || null;
+};
+
+export const resolveClaudeLaunchTarget = (env = process.env, dependencies = {}) => {
+  const windows = dependencies.isWindows ?? isWindows;
+  if (!windows) {
+    return { command: 'claude', shell: false };
+  }
+
+  const resolvedPath = findWindowsClaudePath(env, dependencies);
+  if (!resolvedPath) {
+    return { command: 'claude', shell: true };
+  }
+
+  const requiresShell = /\.(cmd|bat)$/i.test(resolvedPath);
+
+  return {
+    command: requiresShell ? `"${resolvedPath}"` : resolvedPath,
+    shell: requiresShell,
+  };
+};
+
+const readProfileSettingsLaunchEnv = (profileDir) => {
+  const settingsPath = join(profileDir, 'settings.json');
+  if (!existsSync(settingsPath)) return {};
+
+  try {
+    const rawSettings = readFileSync(settingsPath, 'utf-8');
+    return parseSettingsLaunchEnv(rawSettings);
+  } catch {
+    warn(`Could not parse launch env from ${settingsPath}; falling back to inherited env.`);
+    return {};
+  }
+};
+
+const readProfileDotEnvLaunchEnv = (profileDir) => {
+  const dotEnvPath = join(profileDir, '.env');
+  if (!existsSync(dotEnvPath)) return {};
+
+  try {
+    const rawDotEnv = readFileSync(dotEnvPath, 'utf-8');
+    return parseDotEnvLaunchEnv(rawDotEnv);
+  } catch {
+    warn(`Could not parse launch env from ${dotEnvPath}; falling back to inherited env.`);
+    return {};
+  }
+};
+
+const readProfileLaunchEnvSources = (runtimeDir) => {
+  return {
+    profileSettingsEnv: readProfileSettingsLaunchEnv(runtimeDir),
+    profileDotEnvEnv: readProfileDotEnvLaunchEnv(runtimeDir),
+  };
+};
+
+const formatLaunchEnvDiagnostics = (diagnostics = {}) => {
+  const keys = diagnostics.anthropicKeys || [];
+  const sources = diagnostics.anthropicKeySources || {};
+
+  if (!keys.length) {
+    return 'ANTHROPIC_* keys: none';
+  }
+
+  const keyDetails = keys
+    .map((key) => `${key}<=${sources[key] || 'unknown'}`)
+    .join(', ');
+
+  return `ANTHROPIC_* keys: ${keyDetails}`;
+};
+
+export const stripInheritedLaunchEnv = (env = process.env) => {
+  const sanitized = sanitizeInheritedLaunchEnv(env);
+  for (const key of Object.keys(sanitized)) {
+    if (key.toUpperCase().startsWith('ANTHROPIC_')) {
+      delete sanitized[key];
+    }
+  }
+  return sanitized;
+};
+
+export const launchCommand = async (name, claudeArgs, options = {}) => {
+  if (!profileExists(name)) {
+    error(`Profile "${name}" does not exist. Run "csp list" to see available profiles.`);
+    process.exit(1);
+  }
+
+  let args = [...(claudeArgs || [])];
+  const legacyFromArgs = args.includes('--legacy-global');
+  if (legacyFromArgs) {
+    args = args.filter((a) => a !== '--legacy-global');
+  }
+
+  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);
+    const { launchEnv: resolvedLaunchEnv, diagnostics } = buildEffectiveLaunchEnv({
+      parentEnv: process.env,
+      profileSettingsEnv,
+      profileDotEnvEnv,
+    });
+
+    launchEnv = {
+      ...resolvedLaunchEnv,
+      [LAUNCH_CONFIG_ENV]: runtimeDir,
+    };
+
+    // CLAUDE_CONFIG_DIR already redirects user-level config lookups to the
+    // runtime dir, so the "user" settings source reads {runtimeDir}/settings.json
+    // — which is the correct profile-specific settings. We do NOT exclude "user"
+    // because Claude Code gates skill/hook discovery on it being enabled.
+
+    // Always show launch diagnostics for debugging credential issues
+    info(`Launch env diagnostics (${name}): ${formatLaunchEnvDiagnostics(diagnostics)}`);
+    info(`CLAUDE_CONFIG_DIR=${launchEnv[LAUNCH_CONFIG_ENV]}`);
+    info(`ANTHROPIC_AUTH_TOKEN=${launchEnv.ANTHROPIC_AUTH_TOKEN ? launchEnv.ANTHROPIC_AUTH_TOKEN.slice(0, 8) + '...' : '(not set)'}`);
+    info(`ANTHROPIC_BASE_URL=${launchEnv.ANTHROPIC_BASE_URL || '(not set)'}`);
+
+    if (isTruthyDebugValue(process.env.CSP_DEBUG_LAUNCH_ENV)) {
+      info(`[DEBUG] Full launch env ANTHROPIC keys: ${JSON.stringify(Object.fromEntries(Object.entries(launchEnv).filter(([k]) => k.startsWith('ANTHROPIC_'))))}`);
+    }
+
+    info(`Launching isolated session for profile "${name}": claude ${args.join(' ')}`.trim());
+  }
+
+  const launchTarget = resolveClaudeLaunchTarget(launchEnv);
+
+  const child = spawn(launchTarget.command, args, {
+    stdio: 'inherit',
+    shell: launchTarget.shell,
+    detached: false,
+    env: launchEnv,
+  });
+
+  // Forward signals to child instead of killing parent
+  const forwardSignal = (sig) => {
+    try {
+      child.kill(sig);
+    } catch {
+      // Child may have already exited
+    }
+  };
+  process.on('SIGINT', forwardSignal);
+  process.on('SIGTERM', forwardSignal);
+
+  child.on('error', (err) => {
+    error(`Failed to launch Claude: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    process.removeListener('SIGINT', forwardSignal);
+    process.removeListener('SIGTERM', forwardSignal);
+    process.exit(code || 0);
+  });
+
+  // Keep process alive while Claude runs
+  return new Promise(() => {});
+};

package/src/commands/list.js

@@ -20,7 +20,8 @@ export const listCommand = () => {
     const label = isActive ? chalk.green.bold(name) : name;
     const desc = meta.description ? chalk.dim(` — ${meta.description}`) : '';
     const date = meta.created ? chalk.dim(` (${meta.created.split('T')[0]})`) : '';
-    console.log(`${marker}${label}${desc}${date}`);
+    const mode = meta.mode ? chalk.dim(` [${meta.mode}]`) : '';
+    console.log(`${marker}${label}${desc}${date}${mode}`);
   }
   console.log('');
 };

package/src/commands/save.js

@@ -1,7 +1,8 @@
 import { getActive, profileExists, getProfileDir } from '../profile-store.js';
-import { saveSymlinks } from '../symlink-manager.js';
-import { saveFiles } from '../file-operations.js';
-import { success, error } from '../output-helpers.js';
+import { saveItems } from '../item-manager.js';
+import { saveFiles, updateSettingsPaths } from '../file-operations.js';
+import { success, error, info } from '../output-helpers.js';
+import { DEFAULT_PROFILE } from '../constants.js';
 
 export const saveCommand = () => {
   const active = getActive();
@@ -10,13 +11,19 @@ export const saveCommand = () => {
     process.exit(1);
   }
 
+  if (active === DEFAULT_PROFILE) {
+    info('Default profile uses ~/.claude directly. No save needed.');
+    return;
+  }
+
   if (!profileExists(active)) {
     error(`Active profile "${active}" directory is missing.`);
     process.exit(1);
   }
 
   const profileDir = getProfileDir(active);
-  saveSymlinks(profileDir);
+  saveItems(profileDir);
   saveFiles(profileDir);
+  updateSettingsPaths(profileDir, 'save');
   success(`Saved current state to profile "${active}"`);
 };