contextswitch 0.1.5 → 0.1.6

package/dist/archive-MN425GUR.js

@@ -0,0 +1,10 @@
+import {
+  archiveCommand,
+  listArchives
+} from "./chunk-BGARUR7R.js";
+import "./chunk-D3DHIVER.js";
+import "./chunk-F36TGFK2.js";
+export {
+  archiveCommand,
+  listArchives
+};

package/dist/{chunk-GHF4FLJV.js → chunk-BGARUR7R.js}

@@ -1,9 +1,9 @@
 import {
   configManager
-} from "./chunk-YMFZWGZO.js";
+} from "./chunk-D3DHIVER.js";
 import {
   paths
-} from "./chunk-A7YXSI66.js";
+} from "./chunk-F36TGFK2.js";
 
 // src/commands/archive.ts
 import picocolors from "picocolors";
@@ -26,18 +26,18 @@ async function archiveCommand(domainName) {
     if (!existsSync(archiveDir)) {
       mkdirSync(archiveDir, { recursive: true });
     }
+    const domain = configManager.loadDomain(domainName);
     const timestamp = /* @__PURE__ */ new Date();
     const archiveMetadata = {
       domain: domainName,
       session,
       timestamp: timestamp.toISOString(),
-      config: configManager.loadDomain(domainName)
+      config: domain
     };
     const dateStr = timestamp.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, -5);
     const archiveName = `${dateStr}.json`;
     const archivePath = join(archiveDir, archiveName);
     writeFileSync(archivePath, JSON.stringify(archiveMetadata, null, 2), "utf-8");
-    const domain = configManager.loadDomain(domainName);
     if (domain.claudeConfig?.memory) {
       const memoryArchiveDir = join(archiveDir, dateStr, "memory");
       mkdirSync(memoryArchiveDir, { recursive: true });
@@ -56,11 +56,10 @@ async function archiveCommand(domainName) {
     console.log(pc.green(`\u2705 Session archived successfully`));
     console.log(pc.gray(`Archive: ${archivePath}`));
     console.log(pc.gray(`Size: ${sizeKB} KB`));
-    const { SessionManager } = await import("./session-IWXAKW6Z.js");
+    const { SessionManager } = await import("./session-H5HPE5OT.js");
     console.log(pc.gray(`Session age: ${SessionManager.getSessionAge(session.started)}`));
   } catch (error) {
-    console.error(pc.red(`\u274C Failed to archive session: ${error}`));
-    process.exit(1);
+    throw new Error(`Failed to archive session: ${error}`);
   }
 }
 function listArchives(domainName) {

package/dist/{chunk-YMFZWGZO.js → chunk-D3DHIVER.js}

@@ -1,10 +1,7 @@
 import {
+  debug,
   paths
-} from "./chunk-A7YXSI66.js";
-
-// src/core/config.ts
-import { readFileSync, existsSync, writeFileSync, readdirSync, renameSync, unlinkSync } from "fs";
-import { parse, stringify } from "yaml";
+} from "./chunk-F36TGFK2.js";
 
 // src/core/domain.ts
 import { z } from "zod";
@@ -13,15 +10,35 @@ var MCPServerSchema = z.object({
   args: z.array(z.string()).optional().describe("Arguments for the command"),
   env: z.record(z.string()).optional().describe("Environment variables")
 });
+var DOMAIN_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var ENV_VAR_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function validateDomainName(name) {
+  if (!name || name.length === 0) {
+    return "Domain name cannot be empty";
+  }
+  if (name.length > 64) {
+    return "Domain name must be 64 characters or fewer";
+  }
+  if (!DOMAIN_NAME_REGEX.test(name)) {
+    return "Domain name must start with a letter or number and contain only letters, numbers, hyphens, underscores, and dots";
+  }
+  if (name === "." || name === "..") {
+    return 'Domain name cannot be "." or ".."';
+  }
+  return null;
+}
 var DomainConfigSchema = z.object({
-  name: z.string().min(1).describe("Domain identifier"),
+  name: z.string().min(1).regex(DOMAIN_NAME_REGEX, "Domain name must start with a letter or number and contain only letters, numbers, hyphens, underscores, and dots").describe("Domain identifier"),
   workingDirectory: z.string().describe("Working directory for this domain"),
   claudeConfig: z.object({
     instructions: z.string().optional().describe("Path to CLAUDE.md file"),
     memory: z.array(z.string()).optional().describe("Memory file paths")
   }).optional(),
   mcpServers: z.record(MCPServerSchema).optional().describe("MCP server configurations"),
-  env: z.record(z.string()).optional().describe("Environment variables for this domain"),
+  env: z.record(
+    z.string().regex(ENV_VAR_NAME_REGEX, "Environment variable names must start with a letter or underscore and contain only letters, digits, and underscores"),
+    z.string()
+  ).optional().describe("Environment variables for this domain"),
   extends: z.string().optional().describe("Parent domain to inherit from"),
   metadata: z.object({
     description: z.string().optional(),
@@ -56,6 +73,10 @@ var GlobalConfigSchema = z.object({
     killTimeout: z.number().default(5e3).describe("Milliseconds to wait before force kill")
   }).optional()
 });
+var SessionFallbackMarkerSchema = z.object({
+  domain: z.string().min(1).regex(DOMAIN_NAME_REGEX),
+  sessionId: z.string().min(1)
+});
 var DEFAULT_DOMAIN_TEMPLATE = {
   name: "default",
   workingDirectory: process.cwd(),
@@ -70,6 +91,15 @@ var DEFAULT_DOMAIN_TEMPLATE = {
     tags: []
   }
 };
+function validateEnvVarName(name) {
+  if (!name || name.length === 0) {
+    return "Environment variable name cannot be empty";
+  }
+  if (!ENV_VAR_NAME_REGEX.test(name)) {
+    return `Invalid environment variable name '${name}': must start with a letter or underscore and contain only letters, digits, and underscores`;
+  }
+  return null;
+}
 function validateDomain(data) {
   return DomainConfigSchema.parse(data);
 }
@@ -86,30 +116,28 @@ function createInitialState() {
 }
 
 // src/core/config.ts
+import { readFileSync, existsSync, writeFileSync, readdirSync, renameSync, unlinkSync } from "fs";
+import { parse, stringify } from "yaml";
 var ConfigManager = class {
-  globalConfig = null;
-  state = null;
-  domainCache = /* @__PURE__ */ new Map();
   /**
    * Load global configuration
    */
   loadGlobalConfig() {
     const configPath = paths.globalConfigFile;
     if (!existsSync(configPath)) {
-      this.globalConfig = {
+      const defaultConfig = {
         version: "1.0.0",
         defaultDomain: "default",
         autoArchive: true,
         logLevel: "info"
       };
-      this.saveGlobalConfig(this.globalConfig);
-      return this.globalConfig;
+      this.saveGlobalConfig(defaultConfig);
+      return defaultConfig;
     }
     try {
       const content = readFileSync(configPath, "utf-8");
       const data = parse(content);
-      this.globalConfig = GlobalConfigSchema.parse(data);
-      return this.globalConfig;
+      return GlobalConfigSchema.parse(data);
     } catch (error) {
       throw new Error(`Failed to load global config: ${error}`);
     }
@@ -123,23 +151,25 @@ var ConfigManager = class {
     const content = stringify(config, { indent: 2 });
     writeFileSync(tempPath, content, "utf-8");
     renameSync(tempPath, configPath);
-    this.globalConfig = config;
   }
   /**
    * Load state file
    */
   loadState() {
     const statePath = paths.stateFile;
+    debug("config", `Loading state from ${statePath}`);
     if (!existsSync(statePath)) {
-      this.state = createInitialState();
-      this.saveState(this.state);
-      return this.state;
+      debug("config", "No state file found, creating initial state");
+      const initial = createInitialState();
+      this.saveState(initial);
+      return initial;
     }
     try {
       const content = readFileSync(statePath, "utf-8");
       const data = JSON.parse(content);
-      this.state = validateState(data);
-      return this.state;
+      const state = validateState(data);
+      debug("config", `State loaded: activeDomain=${state.activeDomain}, sessions=${Object.keys(state.sessions || {}).join(",") || "none"}`);
+      return state;
     } catch (error) {
       throw new Error(`Failed to load state: ${error}`);
     }
@@ -150,19 +180,23 @@ var ConfigManager = class {
   saveState(state) {
     const statePath = paths.stateFile;
     const tempPath = `${statePath}.tmp`;
+    debug("config", `Saving state to ${statePath} (activeDomain=${state.activeDomain})`);
     const content = JSON.stringify(state, null, 2);
     writeFileSync(tempPath, content, "utf-8");
     renameSync(tempPath, statePath);
-    this.state = state;
   }
   /**
    * Load a domain configuration
    */
   loadDomain(domainName) {
-    if (this.domainCache.has(domainName)) {
-      return this.domainCache.get(domainName);
-    }
+    return this.loadDomainInternal(domainName, []);
+  }
+  /**
+   * Internal domain loader with cycle detection for inheritance chains.
+   */
+  loadDomainInternal(domainName, ancestors) {
     const domainPath = paths.domainConfigFile(domainName);
+    debug("config", `Loading domain '${domainName}' from ${domainPath}`);
     if (!existsSync(domainPath)) {
       throw new Error(`Domain '${domainName}' not found`);
     }
@@ -171,7 +205,11 @@ var ConfigManager = class {
       const data = parse(content);
       let domain = validateDomain(data);
       if (domain.extends) {
-        const parent = this.loadDomain(domain.extends);
+        if (ancestors.includes(domain.extends)) {
+          throw new Error(`Circular inheritance detected: ${[...ancestors, domainName, domain.extends].join(" -> ")}`);
+        }
+        debug("config", `Domain '${domainName}' extends '${domain.extends}', merging`);
+        const parent = this.loadDomainInternal(domain.extends, [...ancestors, domainName]);
         domain = this.mergeDomains(parent, domain);
       }
       domain.workingDirectory = paths.expandPath(domain.workingDirectory);
@@ -181,7 +219,6 @@ var ConfigManager = class {
       if (domain.claudeConfig?.memory) {
         domain.claudeConfig.memory = domain.claudeConfig.memory.map((p) => paths.expandPath(p));
       }
-      this.domainCache.set(domainName, domain);
       return domain;
     } catch (error) {
       throw new Error(`Failed to load domain '${domainName}': ${error}`);
@@ -196,7 +233,6 @@ var ConfigManager = class {
     const content = stringify(domain, { indent: 2 });
     writeFileSync(tempPath, content, "utf-8");
     renameSync(tempPath, domainPath);
-    this.domainCache.set(domain.name, domain);
   }
   /**
    * Create a new domain from template
@@ -241,7 +277,6 @@ var ConfigManager = class {
       throw new Error(`Domain '${domainName}' not found`);
     }
     unlinkSync(domainPath);
-    this.domainCache.delete(domainName);
   }
   /**
    * Merge two domain configurations (child overrides parent)
@@ -289,13 +324,13 @@ var ConfigManager = class {
    * Clear cache
    */
   clearCache() {
-    this.globalConfig = null;
-    this.state = null;
-    this.domainCache.clear();
   }
 };
 var configManager = new ConfigManager();
 
 export {
+  validateDomainName,
+  SessionFallbackMarkerSchema,
+  validateEnvVarName,
   configManager
 };

package/dist/{chunk-A7YXSI66.js → chunk-F36TGFK2.js}

@@ -72,6 +72,9 @@ var Paths = class _Paths {
    * Get domain config file path
    */
   domainConfigFile(domainName) {
+    if (domainName.includes("/") || domainName.includes("\\") || domainName === ".." || domainName === ".") {
+      throw new Error(`Unsafe domain name: ${domainName}`);
+    }
     return join(this.domainsDir, `${domainName}.yml`);
   }
   /**
@@ -108,7 +111,9 @@ var Paths = class _Paths {
    * Expand environment variables and ~ in paths
    */
   expandPath(inputPath) {
-    if (inputPath.startsWith("~/")) {
+    if (inputPath === "~") {
+      inputPath = homedir();
+    } else if (inputPath.startsWith("~/")) {
       inputPath = join(homedir(), inputPath.slice(2));
     }
     inputPath = inputPath.replace(/\$([A-Z_][A-Z0-9_]*)/gi, (match, varName) => {
@@ -158,6 +163,20 @@ var Paths = class _Paths {
 };
 var paths = Paths.instance;
 
+// src/core/debug.ts
+import picocolors from "picocolors";
+var pc = picocolors;
+var enabled = false;
+function enableDebug() {
+  enabled = true;
+}
+function debug(context, message) {
+  if (!enabled) return;
+  console.log(pc.dim(`[debug:${context}] ${message}`));
+}
+
 export {
-  paths
+  paths,
+  enableDebug,
+  debug
 };

package/dist/{chunk-756VUR5T.js → chunk-K7ISIY3Q.js}

@@ -1,6 +1,7 @@
 import {
+  debug,
   paths
-} from "./chunk-A7YXSI66.js";
+} from "./chunk-F36TGFK2.js";
 
 // src/core/process.ts
 import { execSync, spawn } from "child_process";
@@ -47,9 +48,11 @@ var ProcessManager = class {
         const basename = command.split("/").pop() || "";
         const isClaudeBinary = basename === "claude" || basename === "claude.exe";
         if (isClaudeBinary) {
+          debug("process", `Found Claude process: PID=${pid} cmd=${command} args=${args.join(" ")}`);
           processes.push({ pid, command, args });
         }
       }
+      debug("process", `Unix process scan found ${processes.length} Claude process(es)`);
       return processes;
     } catch (error) {
       console.error(`Unix process detection failed: ${error}`);
@@ -73,11 +76,17 @@ var ProcessManager = class {
         const match = line.match(/^"?(\d+)"?,"?(.*?)"?$/);
         if (match) {
           const pid = parseInt(match[1], 10);
+          if (!Number.isInteger(pid) || pid <= 0) continue;
           const commandLine = match[2] || "";
-          if (commandLine.includes("claude") && !commandLine.includes("cs switch")) {
+          if (commandLine.includes("cs switch")) continue;
+          const exe = commandLine.split(/[\s"]+/)[0] || "";
+          const bin = exe.split(/[/\\]/).pop() || "";
+          const isClaudeBinary = bin === "claude" || bin === "claude.exe";
+          if (isClaudeBinary) {
+            debug("process", `Found Claude process: PID=${pid} cmd=${commandLine}`);
             processes.push({
               pid,
-              command: "claude",
+              command: exe,
               args: commandLine.split(" ").slice(1)
             });
           }
@@ -93,6 +102,10 @@ var ProcessManager = class {
    * Kill a process by PID
    */
   killProcess(pid, force = false) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      debug("process", `Invalid PID: ${pid}`);
+      return false;
+    }
     try {
       if (this.platform === "win32") {
         const flag = force ? "/F" : "";
@@ -114,88 +127,28 @@ var ProcessManager = class {
     if (processes.length === 0) {
       return;
     }
+    debug("process", `Found ${processes.length} Claude process(es) to terminate`);
     console.log(`Found ${processes.length} Claude process(es) to terminate`);
     for (const proc of processes) {
+      debug("process", `Sending SIGTERM to PID ${proc.pid}`);
       this.killProcess(proc.pid, false);
     }
     await new Promise((resolve) => setTimeout(resolve, Math.min(timeout, 1e3)));
     const remaining = this.findClaudeProcesses();
     for (const proc of remaining) {
+      debug("process", `Force killing PID ${proc.pid} (still alive after grace period)`);
       console.log(`Force killing process ${proc.pid}`);
       this.killProcess(proc.pid, true);
     }
   }
-  /**
-   * Spawn Claude with specific arguments
-   */
-  spawnClaude(args, options) {
-    const claudeCmd = this.findClaudeExecutable();
-    if (!claudeCmd) {
-      throw new Error("Claude CLI not found. Please ensure it is installed and in your PATH.");
-    }
-    if (this.platform === "darwin") {
-      const cwd = options?.cwd || process.cwd();
-      const claudeCommand = `cd "${cwd}" && ${claudeCmd} ${args.join(" ")}`;
-      const script = `tell app "Terminal" to do script "${claudeCommand.replace(/"/g, '\\"')}"`;
-      const terminalProcess = spawn("osascript", ["-e", script], {
-        detached: true,
-        stdio: "ignore"
-      });
-      terminalProcess.unref();
-      return terminalProcess.pid || 0;
-    }
-    if (this.platform === "linux") {
-      const cwd = options?.cwd || process.cwd();
-      const claudeCommand = `${claudeCmd} ${args.join(" ")}`;
-      const terminals = ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"];
-      for (const term of terminals) {
-        try {
-          const termProcess = spawn(term, ["--", "bash", "-c", `cd "${cwd}" && ${claudeCommand}`], {
-            detached: true,
-            stdio: "ignore"
-          });
-          termProcess.unref();
-          return termProcess.pid || 0;
-        } catch {
-        }
-      }
-    }
-    if (this.platform === "win32") {
-      const cwd = options?.cwd || process.cwd();
-      const gitBash = this.findGitBash();
-      if (gitBash) {
-        const claudeCommand = `cd "${String(cwd).replace(/\\/g, "/")}" && ${claudeCmd} ${args.join(" ")}`;
-        const cmdProcess = spawn("cmd.exe", ["/c", "start", "", gitBash, "-c", claudeCommand], {
-          detached: true,
-          stdio: "ignore",
-          windowsHide: false
-        });
-        cmdProcess.unref();
-        return cmdProcess.pid || 0;
-      } else {
-        const claudeCommand = `cd /d "${cwd}" && ${claudeCmd} ${args.join(" ")}`;
-        const cmdProcess = spawn("cmd.exe", ["/c", "start", "cmd.exe", "/k", claudeCommand], {
-          detached: true,
-          stdio: "ignore",
-          windowsHide: false
-        });
-        cmdProcess.unref();
-        return cmdProcess.pid || 0;
-      }
-    }
-    const claudeProcess = spawn(claudeCmd, args, {
-      detached: true,
-      stdio: "ignore",
-      ...options
-    });
-    claudeProcess.unref();
-    return claudeProcess.pid || 0;
-  }
   /**
    * Spawn a shell script in a new terminal window
    */
   spawnTerminalScript(script, _cwd) {
-    const scriptFile = join(paths.baseDir, "launch.sh");
+    const scriptFile = join(paths.baseDir, `launch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.sh`);
+    debug("process", `Writing launch script to ${scriptFile}`);
+    debug("process", `Script contents:
+${script}`);
     writeFileSync(scriptFile, script, { mode: 493 });
     if (this.platform === "darwin") {
       const escapedPath = scriptFile.replace(/"/g, '\\"');
@@ -280,12 +233,15 @@ var ProcessManager = class {
       if (this.platform === "win32") {
         const output = execSync("where claude", { encoding: "utf-8" }).trim();
         const firstLine = output.split("\n")[0];
+        debug("process", `Found Claude via 'where': ${firstLine}`);
         return firstLine || null;
       } else {
         const output = execSync("which claude", { encoding: "utf-8" }).trim();
+        debug("process", `Found Claude via 'which': ${output}`);
         return output || null;
       }
     } catch {
+      debug("process", "Claude not found via PATH, checking common install locations");
       const commonPaths = this.platform === "win32" ? [
         join(process.env.LOCALAPPDATA || "", "Programs", "Claude Code", "claude.exe"),
         join(process.env.PROGRAMFILES || "C:\\Program Files", "Claude Code", "claude.exe"),
@@ -299,9 +255,11 @@ var ProcessManager = class {
       ];
       for (const candidatePath of commonPaths) {
         if (candidatePath && existsSync(candidatePath)) {
+          debug("process", `Found Claude at fallback path: ${candidatePath}`);
           return candidatePath;
         }
       }
+      debug("process", "Claude executable not found anywhere");
       return null;
     }
   }
@@ -340,6 +298,9 @@ var ProcessManager = class {
    * Check if a process is still running
    */
   isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      return false;
+    }
     try {
       if (this.platform === "win32") {
         const output = execSync(`tasklist /FI "PID eq ${pid}"`, { encoding: "utf-8" });

package/dist/{chunk-KBKALWDX.js → chunk-MGIXKKM6.js}

@@ -59,6 +59,9 @@ var SessionManager = class {
       return `${hours} hour${hours === 1 ? "" : "s"}`;
     }
     const minutes = Math.floor(diffMs / (1e3 * 60));
+    if (minutes === 0) {
+      return "just now";
+    }
     return `${minutes} minute${minutes === 1 ? "" : "s"}`;
   }
   /**

package/dist/cli.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 import {
-  configManager
-} from "./chunk-YMFZWGZO.js";
+  SessionFallbackMarkerSchema,
+  configManager,
+  validateDomainName
+} from "./chunk-D3DHIVER.js";
 import {
+  debug,
+  enableDebug,
   paths
-} from "./chunk-A7YXSI66.js";
+} from "./chunk-F36TGFK2.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -20,7 +24,7 @@ function getVersion() {
     const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
     return packageJson.version;
   } catch {
-    return "0.1.5";
+    return "0.1.6";
   }
 }
 function processSessionFallbackMarker() {
@@ -30,20 +34,19 @@ function processSessionFallbackMarker() {
   }
   try {
     const content = readFileSync(markerPath, "utf-8");
-    const marker = JSON.parse(content);
-    if (marker.domain && marker.sessionId) {
-      const state = configManager.loadState();
-      const session = state.sessions?.[marker.domain];
-      if (session) {
-        session.sessionId = marker.sessionId;
-        session.started = (/* @__PURE__ */ new Date()).toISOString();
-        session.lastActive = (/* @__PURE__ */ new Date()).toISOString();
-        state.activeSession = marker.sessionId;
-        configManager.saveState(state);
-        console.log(pc.yellow(`Note: Previous session for '${marker.domain}' could not be resumed.`));
-        console.log(pc.yellow(`A new session (${marker.sessionId.substring(0, 8)}...) was started automatically.
+    const raw = JSON.parse(content);
+    const marker = SessionFallbackMarkerSchema.parse(raw);
+    const state = configManager.loadState();
+    const session = state.sessions?.[marker.domain];
+    if (session) {
+      session.sessionId = marker.sessionId;
+      session.started = (/* @__PURE__ */ new Date()).toISOString();
+      session.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+      state.activeSession = marker.sessionId;
+      configManager.saveState(state);
+      console.log(pc.yellow(`Note: Previous session for '${marker.domain}' could not be resumed.`));
+      console.log(pc.yellow(`A new session (${marker.sessionId.substring(0, 8)}...) was started automatically.
 `));
-      }
     }
     unlinkSync(markerPath);
   } catch {
@@ -53,8 +56,15 @@ function processSessionFallbackMarker() {
     }
   }
 }
+function requireValidDomainName(name) {
+  const err = validateDomainName(name);
+  if (err) {
+    console.error(pc.red(`\u274C Invalid domain name: ${err}`));
+    process.exit(1);
+  }
+}
 var program = new Command();
-program.name("cs").description("Domain-based context management for Claude Code CLI - Each domain represents a project with its own working directory and configuration").version(getVersion()).addHelpText("after", `
+program.name("cs").description("Domain-based context management for Claude Code CLI - Each domain represents a project with its own working directory and configuration").version(getVersion()).option("--verbose", "Enable debug output for troubleshooting").addHelpText("after", `
 Quick Start:
   cs init                                          Initialize ContextSwitch
   cs domain add myproject -w /path/to/project      Create a domain with a working directory
@@ -62,7 +72,18 @@ Quick Start:
   cs list                                          See all your domains
 
 The --working-dir (-w) flag sets where Claude will run. If omitted, the current directory is used.
-Run "cs domain add --help" for more details.`).hook("preAction", () => {
+Run "cs domain add --help" for more details.
+
+Debug:
+  cs --verbose <command>     Show detailed debug output
+  CS_DEBUG=1 cs <command>    Same via environment variable`).hook("preAction", () => {
+  if (program.opts().verbose || process.env.CS_DEBUG === "1") {
+    enableDebug();
+    debug("cli", `ContextSwitch v${getVersion()}`);
+    debug("cli", `Platform: ${process.platform}`);
+    debug("cli", `Node: ${process.version}`);
+    debug("cli", `Config dir: ${paths.baseDir}`);
+  }
   paths.ensureDirectories();
   processSessionFallbackMarker();
 });
@@ -127,6 +148,7 @@ program.command("status").description("Show current domain and session status").
       console.log(pc.yellow('No active domain. Use "cs switch <domain>" to activate one.'));
       return;
     }
+    requireValidDomainName(domain);
     const domainConfig = configManager.loadDomain(domain);
     const session = state.sessions?.[domain];
     console.log(pc.cyan(`\u{1F4CA} Domain Status: ${domain}
@@ -138,7 +160,7 @@ program.command("status").description("Show current domain and session status").
     if (session) {
       console.log(`
 ${pc.cyan("Session Information:")}`);
-      const { SessionManager } = await import("./session-IWXAKW6Z.js");
+      const { SessionManager } = await import("./session-H5HPE5OT.js");
       console.log(SessionManager.formatSessionInfo(session));
     } else {
       console.log(pc.gray("\nNo active session for this domain."));
@@ -149,20 +171,47 @@ ${pc.cyan("Session Information:")}`);
   }
 });
 program.command("switch <domain>").description("Switch to a different domain").option("-f, --force", "Force new session even if one exists").action(async (domain, options) => {
-  const { switchCommand } = await import("./switch-RZCXBTPC.js");
+  requireValidDomainName(domain);
+  const { switchCommand } = await import("./switch-CM6GRYEA.js");
   await switchCommand(domain, options);
 });
-program.command("reset <domain>").description("Reset a domain session (archives current session)").option("--skip-archive", "Skip archiving the current session").action(async (domain, options) => {
-  const { resetCommand } = await import("./reset-GZKUYPZR.js");
+program.command("reset <domain>").description("Reset a domain session (archives current session)").option("--skip-archive", "Skip archiving the current session").option("-f, --force", "Skip confirmation prompt").action(async (domain, options) => {
+  requireValidDomainName(domain);
+  if (!options.force) {
+    const enquirer = await import("enquirer");
+    const response = await enquirer.default.prompt({
+      type: "confirm",
+      name: "confirmed",
+      message: `Reset session for '${domain}'? This will clear the current session${options.skipArchive ? "" : " (session will be archived first)"}.`
+    });
+    const confirmed = response.confirmed;
+    if (!confirmed) {
+      console.log(pc.gray("Cancelled."));
+      return;
+    }
+  }
+  const { resetCommand } = await import("./reset-TSWWNV2Y.js");
   await resetCommand(domain, options);
 });
 program.command("archive <domain>").description("Archive the current session for a domain").action(async (domain) => {
-  const { archiveCommand } = await import("./archive-64CFJ3P5.js");
-  await archiveCommand(domain);
+  requireValidDomainName(domain);
+  try {
+    const { archiveCommand } = await import("./archive-MN425GUR.js");
+    await archiveCommand(domain);
+  } catch (error) {
+    console.error(pc.red(`\u274C ${error}`));
+    process.exit(1);
+  }
 });
 var domainCmd = program.command("domain").description("Manage domains");
 domainCmd.command("add <name>").description('Create a new domain\n\nExamples:\n  cs domain add myapi --working-dir /path/to/project\n  cs domain add frontend -w C:\\Users\\you\\app -d "React frontend"\n\nIf --working-dir is not specified, the current directory is used.').option("-w, --working-dir <path>", "Working directory for this domain (defaults to current directory)").option("-d, --description <text>", "Domain description").option("--extends <parent>", "Inherit from parent domain").action(async (name, options) => {
   try {
+    const nameError = validateDomainName(name);
+    if (nameError) {
+      console.error(pc.red(`\u274C Invalid domain name: ${nameError}`));
+      console.log(pc.gray("Valid examples: myproject, backend-api, app_v2, my.project"));
+      process.exit(1);
+    }
     if (configManager.domainExists(name)) {
       console.error(pc.red(`\u274C Domain '${name}' already exists`));
       process.exit(1);
@@ -190,7 +239,7 @@ Next steps:`));
     process.exit(1);
   }
 });
-domainCmd.command("remove <name>").alias("rm").description("Remove a domain from ContextSwitch (does not affect working directory)").action(async (name) => {
+domainCmd.command("remove <name>").alias("rm").description("Remove a domain from ContextSwitch (does not affect working directory)").option("-f, --force", "Skip confirmation prompt").action(async (name, options) => {
   try {
     if (!configManager.domainExists(name)) {
       console.error(pc.red(`\u274C Domain '${name}' not found`));
@@ -202,6 +251,19 @@ domainCmd.command("remove <name>").alias("rm").description("Remove a domain from
       console.log(pc.gray("Switch to a different domain first."));
       process.exit(1);
     }
+    if (!options.force) {
+      const enquirer = await import("enquirer");
+      const response = await enquirer.default.prompt({
+        type: "confirm",
+        name: "confirmed",
+        message: `Remove domain '${name}'? This will delete the domain configuration and session data.`
+      });
+      const confirmed = response.confirmed;
+      if (!confirmed) {
+        console.log(pc.gray("Cancelled."));
+        return;
+      }
+    }
     if (state.sessions?.[name]) {
       delete state.sessions[name];
       configManager.saveState(state);
@@ -216,7 +278,7 @@ domainCmd.command("remove <name>").alias("rm").description("Remove a domain from
   }
 });
 program.command("doctor").description("Check system configuration and diagnose issues").action(async () => {
-  const { processManager } = await import("./process-E35QFSO6.js");
+  const { processManager } = await import("./process-X2SYCF5V.js");
   console.log(pc.cyan("\u{1FA7A} Running diagnostics...\n"));
   const failures = [];
   const claudeInstalled = processManager.verifyClaudeInstalled();

package/dist/{process-E35QFSO6.js → process-X2SYCF5V.js}

@@ -1,8 +1,8 @@
 import {
   ProcessManager,
   processManager
-} from "./chunk-756VUR5T.js";
-import "./chunk-A7YXSI66.js";
+} from "./chunk-K7ISIY3Q.js";
+import "./chunk-F36TGFK2.js";
 export {
   ProcessManager,
   processManager

package/dist/{reset-GZKUYPZR.js → reset-TSWWNV2Y.js}

@@ -1,10 +1,10 @@
 import {
   archiveCommand
-} from "./chunk-GHF4FLJV.js";
+} from "./chunk-BGARUR7R.js";
 import {
   configManager
-} from "./chunk-YMFZWGZO.js";
-import "./chunk-A7YXSI66.js";
+} from "./chunk-D3DHIVER.js";
+import "./chunk-F36TGFK2.js";
 
 // src/commands/reset.ts
 import picocolors from "picocolors";
@@ -21,11 +21,15 @@ async function resetCommand(domainName, options = {}) {
       return;
     }
     console.log(pc.cyan(`\u{1F504} Resetting domain '${domainName}'...`));
-    if (!options.skipArchive) {
+    if (options.skipArchive) {
+      console.log(pc.gray("Skipping archive (--skip-archive)."));
+    } else {
       const globalConfig = configManager.loadGlobalConfig();
       if (globalConfig.autoArchive) {
         console.log(pc.gray("Archiving current session..."));
         await archiveCommand(domainName);
+      } else {
+        console.log(pc.gray("Skipping archive (autoArchive is disabled in global config)."));
       }
     }
     const newState = {

package/dist/{session-IWXAKW6Z.js → session-H5HPE5OT.js}

@@ -1,6 +1,6 @@
 import {
   SessionManager
-} from "./chunk-KBKALWDX.js";
+} from "./chunk-MGIXKKM6.js";
 export {
   SessionManager
 };

package/dist/{switch-RZCXBTPC.js → switch-CM6GRYEA.js}

@@ -1,27 +1,36 @@
 import {
   SessionManager
-} from "./chunk-KBKALWDX.js";
+} from "./chunk-MGIXKKM6.js";
 import {
   processManager
-} from "./chunk-756VUR5T.js";
+} from "./chunk-K7ISIY3Q.js";
 import {
-  configManager
-} from "./chunk-YMFZWGZO.js";
+  configManager,
+  validateEnvVarName
+} from "./chunk-D3DHIVER.js";
 import {
+  debug,
   paths
-} from "./chunk-A7YXSI66.js";
+} from "./chunk-F36TGFK2.js";
 
 // src/commands/switch.ts
 import picocolors from "picocolors";
-import { existsSync, writeFileSync, readFileSync, unlinkSync, copyFileSync, mkdirSync, readdirSync, statSync } from "fs";
+import { existsSync, writeFileSync, readFileSync, unlinkSync, copyFileSync, mkdirSync, symlinkSync, lstatSync, readlinkSync } from "fs";
 import { join, dirname, basename } from "path";
 var pc = picocolors;
 function shellEscapeArg(arg) {
   return "'" + arg.replace(/'/g, "'\\''") + "'";
 }
+function isSymlinkBroken(path) {
+  try {
+    const lst = lstatSync(path);
+    return lst.isSymbolicLink() && !existsSync(path);
+  } catch {
+    return false;
+  }
+}
 async function switchCommand(domainName, options = {}) {
   try {
-    processSessionFallback();
     console.log(pc.cyan(`\u{1F504} Switching to domain '${domainName}'...`));
     if (!processManager.verifyClaudeInstalled()) {
       printClaudeInstallHelp();
@@ -58,21 +67,18 @@ async function switchCommand(domainName, options = {}) {
       isNewSession = true;
       console.log(pc.gray(`Creating new session ${sessionId.substring(0, 8)}...`));
     }
+    debug("switch", `Session ID: ${sessionId} (${isNewSession ? "new" : "resuming"})`);
+    debug("switch", `Working directory: ${domain.workingDirectory}`);
     await updateMCPConfig(domain);
     await handleMemoryFiles(domain);
     console.log(pc.gray("Starting Claude with new configuration..."));
-    let pid;
     if (!isNewSession) {
       const fallbackSessionId = SessionManager.generateSessionId(domainName, true);
-      pid = spawnClaudeWithFallback(domain, sessionId, fallbackSessionId);
+      debug("switch", `Resume with fallback: resume=${sessionId.substring(0, 8)}, fallback=${fallbackSessionId.substring(0, 8)}`);
+      spawnClaudeWithFallback(domain, sessionId, fallbackSessionId);
     } else {
-      pid = processManager.spawnClaude(["--session-id", sessionId], {
-        cwd: domain.workingDirectory,
-        env: {
-          ...process.env,
-          ...domain.env
-        }
-      });
+      debug("switch", `New session: ${sessionId.substring(0, 8)}`);
+      spawnClaudeNewSession(domain, sessionId);
     }
     const newState = {
       ...state,
@@ -81,13 +87,10 @@ async function switchCommand(domainName, options = {}) {
       lastSwitch: (/* @__PURE__ */ new Date()).toISOString(),
       sessions: {
         ...state.sessions,
-        [domainName]: SessionManager.createSessionRecord(domainName, sessionId, pid)
+        [domainName]: SessionManager.createSessionRecord(domainName, sessionId)
       }
     };
     configManager.saveState(newState);
-    if (pid) {
-      processManager.writePidFile(domainName, pid);
-    }
     console.log(pc.green(`\u2705 Switched to domain '${domainName}'`));
     console.log(pc.gray(`Working directory: ${domain.workingDirectory}`));
     if (domain.mcpServers && Object.keys(domain.mcpServers).length > 0) {
@@ -120,6 +123,7 @@ async function updateMCPConfig(domain) {
     }
   };
   writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  debug("switch", `MCP config written to ${mcpConfigPath} with servers: ${Object.keys(mcpConfig.servers || {}).join(", ") || "none"}`);
   console.log(pc.gray("Updated MCP configuration"));
 }
 async function handleMemoryFiles(domain) {
@@ -131,38 +135,79 @@ async function handleMemoryFiles(domain) {
   if (!existsSync(memoryDir)) {
     mkdirSync(memoryDir, { recursive: true });
   }
-  const incomingFileNames = /* @__PURE__ */ new Set();
   for (const memoryPath of domain.claudeConfig.memory) {
     const expandedPath = paths.expandPath(memoryPath);
-    incomingFileNames.add(basename(expandedPath));
-  }
-  if (existsSync(memoryDir)) {
-    const entries = readdirSync(memoryDir);
-    for (const entry of entries) {
-      const entryPath = join(memoryDir, entry);
+    if (!existsSync(expandedPath)) {
+      console.log(pc.yellow(`Warning: Memory file not found: ${memoryPath}`));
+      continue;
+    }
+    const fileName = basename(expandedPath);
+    const destPath = join(memoryDir, fileName);
+    if (existsSync(destPath) || isSymlinkBroken(destPath)) {
       try {
-        const stat = statSync(entryPath);
-        if (stat.isDirectory()) {
-          continue;
-        }
-        if (incomingFileNames.has(entry)) {
-          unlinkSync(entryPath);
+        const lst = lstatSync(destPath);
+        if (lst.isSymbolicLink()) {
+          const target = readlinkSync(destPath);
+          if (target === expandedPath) {
+            console.log(pc.gray(`Memory file already linked: ${fileName}`));
+            continue;
+          }
         }
+        unlinkSync(destPath);
       } catch {
+        try {
+          unlinkSync(destPath);
+        } catch {
+        }
       }
     }
+    try {
+      symlinkSync(expandedPath, destPath);
+      debug("switch", `Symlinked memory file: ${expandedPath} -> ${destPath}`);
+      console.log(pc.gray(`Linked memory file: ${fileName}`));
+    } catch (symlinkErr) {
+      debug("switch", `Symlink failed (${symlinkErr}), falling back to copy`);
+      copyFileSync(expandedPath, destPath);
+      console.log(pc.gray(`Copied memory file: ${fileName} (symlink not supported)`));
+    }
   }
-  for (const memoryPath of domain.claudeConfig.memory) {
-    const expandedPath = paths.expandPath(memoryPath);
-    if (!existsSync(expandedPath)) {
-      console.log(pc.yellow(`Warning: Memory file not found: ${memoryPath}`));
-      continue;
+}
+function escapeShellValue(val) {
+  return String(val).replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/`/g, "\\`").replace(/\$/g, "\\$");
+}
+function buildEnvLines(env) {
+  if (!env) return "";
+  const lines = [];
+  for (const [k, v] of Object.entries(env)) {
+    const err = validateEnvVarName(k);
+    if (err) {
+      throw new Error(err);
     }
-    const fileName = basename(expandedPath);
-    const destPath = join(memoryDir, fileName);
-    copyFileSync(expandedPath, destPath);
-    console.log(pc.gray(`Loaded memory file: ${fileName}`));
+    lines.push(`export ${k}="${escapeShellValue(v)}"`);
   }
+  return lines.join("\n");
+}
+function spawnClaudeNewSession(domain, sessionId) {
+  const claudeCmd = processManager.getClaudeExecutable();
+  if (!claudeCmd) {
+    throw new Error("Claude CLI not found");
+  }
+  const cwd = domain.workingDirectory;
+  const domainName = domain.name;
+  const pidFile = shellEscapeArg(join(paths.baseDir, `${domainName}.pid`));
+  const envLines = buildEnvLines(domain.env);
+  const script = [
+    "#!/bin/bash",
+    `cd ${shellEscapeArg(cwd)}`,
+    envLines,
+    "",
+    "# Launch Claude and capture its real PID",
+    `${shellEscapeArg(claudeCmd)} --session-id ${shellEscapeArg(sessionId)} &`,
+    "CLAUDE_PID=$!",
+    `echo $CLAUDE_PID > ${pidFile}`,
+    "wait $CLAUDE_PID"
+  ].join("\n");
+  return processManager.spawnTerminalScript(script, cwd);
 }
 function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
   const claudeCmd = processManager.getClaudeExecutable();
@@ -172,10 +217,7 @@ function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
   const cwd = domain.workingDirectory;
   const markerFile = getSessionFallbackPath();
   const domainName = domain.name;
-  const escapeShellValue = (val) => {
-    return String(val).replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/`/g, "\\`").replace(/\$/g, "\\$");
-  };
-  const envLines = domain.env ? Object.entries(domain.env).map(([k, v]) => `export ${k}="${escapeShellValue(v)}"`).join("\n") : "";
+  const envLines = buildEnvLines(domain.env);
   const markerJson = JSON.stringify({ domain: domainName, sessionId: fallbackSessionId });
   const markerJsonEscaped = markerJson.replace(/'/g, "'\\''");
   const escapedCwd = shellEscapeArg(cwd);
@@ -183,13 +225,17 @@ function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
   const escapedResumeId = shellEscapeArg(resumeSessionId);
   const escapedFallbackId = shellEscapeArg(fallbackSessionId);
   const escapedMarkerFile = shellEscapeArg(markerFile);
+  const pidFile = shellEscapeArg(join(paths.baseDir, `${domainName}.pid`));
   const script = [
     "#!/bin/bash",
     `cd ${escapedCwd}`,
     envLines,
     "",
-    "# Try to resume the existing session",
-    `${escapedClaudeCmd} --resume ${escapedResumeId}`,
+    "# Try to resume the existing session (background + wait to capture PID)",
+    `${escapedClaudeCmd} --resume ${escapedResumeId} &`,
+    "CLAUDE_PID=$!",
+    `echo $CLAUDE_PID > ${pidFile}`,
+    "wait $CLAUDE_PID",
     "RESUME_EXIT=$?",
     "",
     "# If resume failed (non-zero exit), fall back to a new session",
@@ -201,7 +247,10 @@ function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
     "  # Write marker so cs can update state with the new session ID",
     `  echo '${markerJsonEscaped}' > ${escapedMarkerFile}`,
     "",
-    `  ${escapedClaudeCmd} --session-id ${escapedFallbackId}`,
+    `  ${escapedClaudeCmd} --session-id ${escapedFallbackId} &`,
+    "  CLAUDE_PID=$!",
+    `  echo $CLAUDE_PID > ${pidFile}`,
+    "  wait $CLAUDE_PID",
     "fi"
   ].join("\n");
   return processManager.spawnTerminalScript(script, cwd);
@@ -209,36 +258,6 @@ function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
 function getSessionFallbackPath() {
   return join(paths.baseDir, "session-fallback.json");
 }
-function processSessionFallback() {
-  const markerPath = getSessionFallbackPath();
-  if (!existsSync(markerPath)) {
-    return;
-  }
-  try {
-    const content = readFileSync(markerPath, "utf-8");
-    const marker = JSON.parse(content);
-    if (marker.domain && marker.sessionId) {
-      const state = configManager.loadState();
-      const session = state.sessions?.[marker.domain];
-      if (session) {
-        session.sessionId = marker.sessionId;
-        session.started = (/* @__PURE__ */ new Date()).toISOString();
-        session.lastActive = (/* @__PURE__ */ new Date()).toISOString();
-        state.activeSession = marker.sessionId;
-        configManager.saveState(state);
-        console.log(pc.yellow(`Note: Previous session for '${marker.domain}' could not be resumed.`));
-        console.log(pc.yellow(`A new session (${marker.sessionId.substring(0, 8)}...) was started automatically.
-`));
-      }
-    }
-    unlinkSync(markerPath);
-  } catch {
-    try {
-      unlinkSync(markerPath);
-    } catch {
-    }
-  }
-}
 function printClaudeInstallHelp() {
   console.error(pc.red("\u274C Claude Code CLI not found\n"));
   console.log(pc.white("ContextSwitch requires the Claude Code CLI to be installed.\n"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextswitch",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Domain-based context management for Claude Code CLI",
   "main": "dist/cli.js",
   "type": "module",

package/dist/archive-64CFJ3P5.js

@@ -1,10 +0,0 @@
-import {
-  archiveCommand,
-  listArchives
-} from "./chunk-GHF4FLJV.js";
-import "./chunk-YMFZWGZO.js";
-import "./chunk-A7YXSI66.js";
-export {
-  archiveCommand,
-  listArchives
-};