contextswitch 0.1.3 → 0.1.5

package/README.md

@@ -1,100 +1,123 @@
 # ContextSwitch
 
-Domain-based context management for Claude Code CLI. Switch between different project contexts while preserving session history.
+Manage domain-based contexts for Claude Code CLI. Switch between projects without losing session history -- each domain remembers where you left off via Claude's `--resume` flag.
 
-## Features
+## Installation
 
-✅ **Session Persistence** - Resume previous Claude sessions when switching domains
-✅ **Domain Management** - Organize projects with separate configurations
-✅ **MCP Server Support** - Configure Model Context Protocol servers per domain
-✅ **Cross-Platform** - Works on macOS, Linux, and Windows
-✅ **Session Archives** - Save and restore session snapshots
-✅ **Process Management** - Clean switching between Claude instances
+**Prerequisites**: Node.js 18 or later, [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)
 
-## Installation
+```bash
+npm install -g contextswitch
+```
+
+This installs the `cs` command globally.
+
+## Quick Start
 
-### Quick Install
 ```bash
-# Clone the repository
-git clone https://github.com/yourusername/contextswitch.git
-cd contextswitch
+# Initialize ContextSwitch (creates a default domain)
+cs init
+
+# Create a domain for a project
+cs domain add backend --working-dir ~/projects/api
+
+# Switch to that domain (launches Claude in the domain's working directory)
+cs switch backend
 
-# Run the installation script
-chmod +x install.sh
-./install.sh
+# See all domains
+cs list
 ```
 
-This sets up the `cs` command for easy use. For other installation methods, see [INSTALLATION.md](INSTALLATION.md).
+## Commands
 
-### Manual Install
-```bash
-# Install dependencies
-npm install
+### Core
 
-# Build the project
-npm run build:node
+| Command | Description |
+|---|---|
+| `cs init` | Initialize ContextSwitch and create a default domain |
+| `cs switch <domain>` | Switch to a domain (kills any running Claude, launches a new one) |
+| `cs list` | List all domains (`ls` also works) |
+| `cs status [domain]` | Show session info for the current or specified domain |
 
-# Add alias to your shell
-echo "alias cs='node $(pwd)/dist/cli.js'" >> ~/.zshrc
-source ~/.zshrc
+**switch** accepts an optional flag:
 
-# Now you can use 'cs' command
-cs --help
+```bash
+cs switch backend            # Resume existing session if one exists
+cs switch backend --force    # Force a brand-new session
 ```
 
-## Quick Start
+### Domain Management
+
+| Command | Description |
+|---|---|
+| `cs domain add <name>` | Create a new domain |
+| `cs domain remove <name>` | Delete a domain (`rm` also works) |
+| `cs reset <domain>` | Reset a domain's session, archiving the current one first |
+| `cs archive <domain>` | Snapshot the current session without resetting |
+
+**domain add** options:
 
 ```bash
-# Initialize ContextSwitch
-node dist/cli.js init
+# Unix
+cs domain add backend --working-dir ~/projects/api
+cs domain add frontend -w ~/projects/app --description "React frontend"
+
+# Windows (Git Bash)
+cs domain add backend --working-dir C:/Users/you/projects/api
+cs domain add frontend -w C:/Users/you/projects/app -d "React frontend"
 
-# Create a new domain for your project (working directory is REQUIRED)
-node dist/cli.js domain add backend --working-dir ~/projects/api
+# Inherit settings from another domain
+cs domain add staging --extends backend
+```
 
-# The working directory is where Claude will operate when you switch to this domain
-node dist/cli.js switch backend
+If `--working-dir` is omitted, the current directory is used.
 
-# Check status
-node dist/cli.js status
+**reset** options:
 
-# List all domains
-node dist/cli.js list
+```bash
+cs reset backend               # Archive current session, then reset
+cs reset backend --skip-archive  # Reset without archiving
 ```
 
-## Commands
+### Diagnostics
 
-### Core Commands
+| Command | Description |
+|---|---|
+| `cs doctor` | Check Claude CLI installation, config directory, running processes |
+| `cs --help` | Show help |
+| `cs --version` | Show version |
 
-- `cs init` - Initialize ContextSwitch configuration
-- `cs switch <domain>` - Switch to a different domain
-- `cs list` - List all available domains
-- `cs status [domain]` - Show current domain and session status
+## Platform Support
 
-### Domain Management
+| Platform | Status | Notes |
+|---|---|---|
+| macOS | Supported | Primary development platform |
+| Linux | Supported | |
+| Windows | Partial | Git Bash required; some process management features may not work |
 
-- `cs domain add <name>` - Create a new domain
-- `cs domain remove <name>` - Delete a domain
-- `cs reset <domain>` - Reset domain session (with auto-archive)
-- `cs archive <domain>` - Archive current session
+Config and state are stored in the platform-appropriate location:
 
-### Diagnostics
+- macOS: `~/Library/Application Support/contextswitch/`
+- Linux: `~/.config/contextswitch/`
+- Windows: `%APPDATA%\contextswitch\`
 
-- `cs doctor` - Check system configuration
-- `cs --help` - Show help information
-- `cs --version` - Show version
+## How It Works
 
-## Domain Configuration
+**Domains** are named project contexts. Each domain has a working directory, an optional description, optional MCP server configuration, and a session history. Domain config is stored as a YAML file and can be edited directly.
 
-Domains are stored as YAML files in the configuration directory. Example domain:
+**Sessions** are Claude conversation sessions identified by a UUID. When you run `cs switch`, ContextSwitch generates (or retrieves) a session ID for that domain and launches Claude with `--resume <sessionId>`, so Claude picks up where the previous conversation left off. Session IDs are deterministic -- the same domain always maps to the same base session ID.
+
+**MCP config** at `~/.config/claude/mcp/config.json` is updated on each switch to reflect the MCP servers defined in the active domain's config. This lets each domain have its own set of MCP tools.
+
+### Domain Config Example
+
+Domains are YAML files in the config directory. You can edit them directly after creating a domain with `cs domain add`:
 
 ```yaml
 name: backend
 workingDirectory: ~/projects/api
-
-claudeConfig:
-  instructions: ./CLAUDE.md
-  memory:
-    - ./context/api-overview.md
+metadata:
+  description: Backend API project
 
 mcpServers:
   filesystem:
@@ -107,79 +130,6 @@ env:
   NODE_ENV: development
 ```
 
-## Project Structure
-
-```
-contextswitch/
-├── src/
-│   ├── cli.ts              # Main CLI entry point
-│   ├── commands/           # Command implementations
-│   │   ├── switch.ts       # Domain switching logic
-│   │   ├── reset.ts        # Session reset
-│   │   └── archive.ts      # Session archiving
-│   └── core/               # Core modules
-│       ├── domain.ts       # Domain schemas (Zod)
-│       ├── config.ts       # Configuration management
-│       ├── session.ts      # Session ID generation
-│       ├── process.ts      # Process management
-│       └── paths.ts        # Cross-platform paths
-├── domains/                # Domain templates
-├── package.json
-├── tsconfig.json
-└── README.md
-```
-
-## Configuration Files
-
-- **Domains**: `~/Library/Application Support/contextswitch/domains/*.yml` (macOS)
-- **State**: `~/Library/Application Support/contextswitch/state.json`
-- **Archives**: `~/Library/Application Support/contextswitch/archives/`
-
-## Development
-
-```bash
-# Run TypeScript compiler check
-npx tsc --noEmit
-
-# Run in development mode
-npm run dev
-
-# Build for production
-npm run build:node
-
-# Run tests (when implemented)
-npm test
-```
-
-## Technical Details
-
-- Built with TypeScript and Commander.js
-- Uses Zod for runtime validation
-- Deterministic session IDs via UUID v5
-- Atomic file operations for data safety
-- Cross-platform process management
-
-## Status
-
-**Current Version**: 0.1.0 (MVP)
-
-### Implemented
-- ✅ Core domain management
-- ✅ Session persistence with `--resume`
-- ✅ Process management (kill/spawn Claude)
-- ✅ State tracking and atomic writes
-- ✅ Cross-platform path resolution
-- ✅ Basic CLI commands
-- ✅ Archive functionality
-
-### Not Yet Implemented
-- ⏳ Git sync for team sharing
-- ⏳ Token usage estimation
-- ⏳ Advanced diagnostics
-- ⏳ Binary compilation with Bun
-- ⏳ Automated tests
-- ⏳ Shell integration scripts
-
 ## License
 
-MIT
+MIT

package/dist/archive-64CFJ3P5.js

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

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

@@ -37,16 +37,17 @@ var ProcessManager = class {
       const lines = output.split("\n");
       const processes = [];
       for (const line of lines) {
-        if (line.includes("claude") && !line.includes("cs switch")) {
-          const parts = line.split(/\s+/);
-          if (parts.length >= 11 && parts[1]) {
-            const pid = parseInt(parts[1], 10);
-            const command = parts[10] || "";
-            const args = parts.slice(11);
-            if (command && (command.includes("claude") || args.some((arg) => arg && arg.includes("claude")))) {
-              processes.push({ pid, command, args });
-            }
-          }
+        if (!line.trim()) continue;
+        const parts = line.split(/\s+/);
+        if (parts.length < 11 || !parts[1]) continue;
+        const pid = parseInt(parts[1], 10);
+        const command = parts[10] || "";
+        const args = parts.slice(11);
+        if (line.includes("cs switch")) continue;
+        const basename = command.split("/").pop() || "";
+        const isClaudeBinary = basename === "claude" || basename === "claude.exe";
+        if (isClaudeBinary) {
+          processes.push({ pid, command, args });
         }
       }
       return processes;
@@ -163,7 +164,7 @@ var ProcessManager = class {
       const cwd = options?.cwd || process.cwd();
       const gitBash = this.findGitBash();
       if (gitBash) {
-        const claudeCommand = `cd "${cwd.replace(/\\/g, "/")}" && ${claudeCmd} ${args.join(" ")}`;
+        const claudeCommand = `cd "${String(cwd).replace(/\\/g, "/")}" && ${claudeCmd} ${args.join(" ")}`;
         const cmdProcess = spawn("cmd.exe", ["/c", "start", "", gitBash, "-c", claudeCommand], {
           detached: true,
           stdio: "ignore",
@@ -193,7 +194,7 @@ var ProcessManager = class {
   /**
    * Spawn a shell script in a new terminal window
    */
-  spawnTerminalScript(script, cwd) {
+  spawnTerminalScript(script, _cwd) {
     const scriptFile = join(paths.baseDir, "launch.sh");
     writeFileSync(scriptFile, script, { mode: 493 });
     if (this.platform === "darwin") {

package/dist/{chunk-2LUEUGBV.js → chunk-GHF4FLJV.js}

@@ -1,16 +1,9 @@
 import {
   configManager
-} from "./chunk-XGE4JP55.js";
-import {
-  init_session,
-  session_exports
-} from "./chunk-UKMZ4CUZ.js";
+} from "./chunk-YMFZWGZO.js";
 import {
   paths
 } from "./chunk-A7YXSI66.js";
-import {
-  __toCommonJS
-} from "./chunk-PNKVD2UK.js";
 
 // src/commands/archive.ts
 import picocolors from "picocolors";
@@ -63,7 +56,8 @@ 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`));
-    console.log(pc.gray(`Session age: ${(init_session(), __toCommonJS(session_exports)).SessionManager.getSessionAge(session.started)}`));
+    const { SessionManager } = await import("./session-IWXAKW6Z.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);

package/dist/chunk-KBKALWDX.js

@@ -0,0 +1,100 @@
+// src/core/session.ts
+import { v5 as uuidv5 } from "uuid";
+import { createHash } from "crypto";
+var SessionManager = class {
+  // Namespace UUID for ContextSwitch sessions
+  static NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+  /**
+   * Generate a deterministic session ID for a domain
+   * Uses UUID v5 to ensure same domain always gets same base session ID
+   */
+  static generateSessionId(domainName, reset = false) {
+    const seed = reset ? `${domainName}:${Date.now()}` : domainName;
+    return uuidv5(seed, this.NAMESPACE);
+  }
+  /**
+   * Generate a session hash for verification
+   * Useful for checking if a session is still valid
+   */
+  static generateSessionHash(sessionId, domainName) {
+    const hash = createHash("sha256");
+    hash.update(`${sessionId}:${domainName}`);
+    return hash.digest("hex").substring(0, 8);
+  }
+  /**
+   * Create a session record
+   */
+  static createSessionRecord(domainName, sessionId, processId) {
+    return {
+      domain: domainName,
+      sessionId,
+      started: (/* @__PURE__ */ new Date()).toISOString(),
+      lastActive: (/* @__PURE__ */ new Date()).toISOString(),
+      processId
+    };
+  }
+  /**
+   * Check if a session is likely expired based on age
+   * Claude sessions typically last 1-2 weeks
+   */
+  static isSessionLikelyExpired(startedAt) {
+    const started = new Date(startedAt);
+    const now = /* @__PURE__ */ new Date();
+    const daysSinceStart = (now.getTime() - started.getTime()) / (1e3 * 60 * 60 * 24);
+    return daysSinceStart > 7;
+  }
+  /**
+   * Get session age in human-readable format
+   */
+  static getSessionAge(startedAt) {
+    const started = new Date(startedAt);
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - started.getTime();
+    const days = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+    const hours = Math.floor(diffMs % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60));
+    if (days > 0) {
+      return `${days} day${days === 1 ? "" : "s"}, ${hours} hour${hours === 1 ? "" : "s"}`;
+    }
+    if (hours > 0) {
+      return `${hours} hour${hours === 1 ? "" : "s"}`;
+    }
+    const minutes = Math.floor(diffMs / (1e3 * 60));
+    return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+  }
+  /**
+   * Get session risk level based on age
+   */
+  static getSessionRisk(startedAt) {
+    const started = new Date(startedAt);
+    const now = /* @__PURE__ */ new Date();
+    const daysSinceStart = (now.getTime() - started.getTime()) / (1e3 * 60 * 60 * 24);
+    if (daysSinceStart < 3) return "low";
+    if (daysSinceStart < 5) return "medium";
+    if (daysSinceStart < 7) return "high";
+    return "critical";
+  }
+  /**
+   * Format session info for display
+   */
+  static formatSessionInfo(session) {
+    const age = this.getSessionAge(session.started);
+    const risk = this.getSessionRisk(session.started);
+    const riskColors = {
+      low: "\u{1F7E2}",
+      medium: "\u{1F7E1}",
+      high: "\u{1F7E0}",
+      critical: "\u{1F534}"
+    };
+    return [
+      `Domain: ${session.domain}`,
+      `Session ID: ${session.sessionId.substring(0, 8)}...`,
+      `Age: ${age}`,
+      `Risk: ${riskColors[risk]} ${risk}`,
+      risk === "high" || risk === "critical" ? "\u26A0\uFE0F  Consider resetting soon" : ""
+    ].filter(Boolean).join("\n");
+  }
+};
+
+export {
+  SessionManager
+};

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

@@ -94,9 +94,6 @@ var ConfigManager = class {
    * Load global configuration
    */
   loadGlobalConfig() {
-    if (this.globalConfig) {
-      return this.globalConfig;
-    }
     const configPath = paths.globalConfigFile;
     if (!existsSync(configPath)) {
       this.globalConfig = {
@@ -122,17 +119,16 @@ var ConfigManager = class {
    */
   saveGlobalConfig(config) {
     const configPath = paths.globalConfigFile;
+    const tempPath = `${configPath}.tmp`;
     const content = stringify(config, { indent: 2 });
-    writeFileSync(configPath, content, "utf-8");
+    writeFileSync(tempPath, content, "utf-8");
+    renameSync(tempPath, configPath);
     this.globalConfig = config;
   }
   /**
    * Load state file
    */
   loadState() {
-    if (this.state) {
-      return this.state;
-    }
     const statePath = paths.stateFile;
     if (!existsSync(statePath)) {
       this.state = createInitialState();
@@ -196,8 +192,10 @@ var ConfigManager = class {
    */
   saveDomain(domain) {
     const domainPath = paths.domainConfigFile(domain.name);
+    const tempPath = `${domainPath}.tmp`;
     const content = stringify(domain, { indent: 2 });
-    writeFileSync(domainPath, content, "utf-8");
+    writeFileSync(tempPath, content, "utf-8");
+    renameSync(tempPath, domainPath);
     this.domainCache.set(domain.name, domain);
   }
   /**

package/dist/cli.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 import {
   configManager
-} from "./chunk-XGE4JP55.js";
+} from "./chunk-YMFZWGZO.js";
 import {
   paths
 } from "./chunk-A7YXSI66.js";
-import "./chunk-PNKVD2UK.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -21,7 +20,7 @@ function getVersion() {
     const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
     return packageJson.version;
   } catch {
-    return "0.1.3";
+    return "0.1.5";
   }
 }
 function processSessionFallbackMarker() {
@@ -34,10 +33,11 @@ function processSessionFallbackMarker() {
     const marker = JSON.parse(content);
     if (marker.domain && marker.sessionId) {
       const state = configManager.loadState();
-      if (state.sessions?.[marker.domain]) {
-        state.sessions[marker.domain].sessionId = marker.sessionId;
-        state.sessions[marker.domain].started = (/* @__PURE__ */ new Date()).toISOString();
-        state.sessions[marker.domain].lastActive = (/* @__PURE__ */ new Date()).toISOString();
+      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.`));
@@ -54,7 +54,15 @@ function processSessionFallbackMarker() {
   }
 }
 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()).hook("preAction", () => {
+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", `
+Quick Start:
+  cs init                                          Initialize ContextSwitch
+  cs domain add myproject -w /path/to/project      Create a domain with a working directory
+  cs switch myproject                              Switch to the domain (launches Claude)
+  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", () => {
   paths.ensureDirectories();
   processSessionFallbackMarker();
 });
@@ -130,7 +138,7 @@ program.command("status").description("Show current domain and session status").
     if (session) {
       console.log(`
 ${pc.cyan("Session Information:")}`);
-      const { SessionManager } = await import("./session-YAMF4YD7.js");
+      const { SessionManager } = await import("./session-IWXAKW6Z.js");
       console.log(SessionManager.formatSessionInfo(session));
     } else {
       console.log(pc.gray("\nNo active session for this domain."));
@@ -141,15 +149,15 @@ ${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-MWKYEYHE.js");
+  const { switchCommand } = await import("./switch-RZCXBTPC.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-3DSXZKRH.js");
+  const { resetCommand } = await import("./reset-GZKUYPZR.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-3IGWZBSO.js");
+  const { archiveCommand } = await import("./archive-64CFJ3P5.js");
   await archiveCommand(domain);
 });
 var domainCmd = program.command("domain").description("Manage domains");
@@ -208,8 +216,9 @@ 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-WBBCEFGG.js");
+  const { processManager } = await import("./process-E35QFSO6.js");
   console.log(pc.cyan("\u{1FA7A} Running diagnostics...\n"));
+  const failures = [];
   const claudeInstalled = processManager.verifyClaudeInstalled();
   if (claudeInstalled) {
     console.log(pc.green("\u2713 Claude CLI is installed"));
@@ -219,6 +228,7 @@ program.command("doctor").description("Check system configuration and diagnose i
     console.log(pc.gray("    npm install -g @anthropic-ai/claude-code\n"));
     console.log(pc.cyan("  Or see the official docs:"));
     console.log(pc.gray("    https://docs.anthropic.com/en/docs/claude-code\n"));
+    failures.push("Claude Code CLI not found");
   }
   console.log(pc.green(`\u2713 Config directory: ${paths.baseDir}`));
   const domains = configManager.listDomains();
@@ -226,7 +236,15 @@ program.command("doctor").description("Check system configuration and diagnose i
   const processes = processManager.findClaudeProcesses();
   console.log(pc.green(`\u2713 Claude processes running: ${processes.length}`));
   console.log(pc.green(`\u2713 Platform: ${paths.platform}`));
-  console.log(pc.cyan("\n\u2728 All checks passed!"));
+  if (failures.length === 0) {
+    console.log(pc.cyan("\n\u2728 All checks passed!"));
+  } else {
+    console.log(pc.red(`
+\u2717 ${failures.length} check(s) failed:`));
+    for (const failure of failures) {
+      console.log(pc.red(`  - ${failure}`));
+    }
+  }
 });
 program.action(() => {
   program.outputHelp();

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

@@ -1,9 +1,8 @@
 import {
   ProcessManager,
   processManager
-} from "./chunk-56TY2J6E.js";
+} from "./chunk-756VUR5T.js";
 import "./chunk-A7YXSI66.js";
-import "./chunk-PNKVD2UK.js";
 export {
   ProcessManager,
   processManager

package/dist/{reset-3DSXZKRH.js → reset-GZKUYPZR.js}

@@ -1,19 +1,13 @@
 import {
   archiveCommand
-} from "./chunk-2LUEUGBV.js";
+} from "./chunk-GHF4FLJV.js";
 import {
   configManager
-} from "./chunk-XGE4JP55.js";
-import {
-  SessionManager,
-  init_session
-} from "./chunk-UKMZ4CUZ.js";
+} from "./chunk-YMFZWGZO.js";
 import "./chunk-A7YXSI66.js";
-import "./chunk-PNKVD2UK.js";
 
 // src/commands/reset.ts
 import picocolors from "picocolors";
-init_session();
 var pc = picocolors;
 async function resetCommand(domainName, options = {}) {
   try {
@@ -34,7 +28,6 @@ async function resetCommand(domainName, options = {}) {
         await archiveCommand(domainName);
       }
     }
-    const newSessionId = SessionManager.generateSessionId(domainName, true);
     const newState = {
       ...state,
       sessions: {
@@ -48,8 +41,7 @@ async function resetCommand(domainName, options = {}) {
     }
     configManager.saveState(newState);
     console.log(pc.green(`\u2705 Domain '${domainName}' has been reset`));
-    console.log(pc.gray(`New session will be created on next switch`));
-    console.log(pc.gray(`Session ID: ${newSessionId.substring(0, 8)}...`));
+    console.log(pc.gray(`A new session will be created on next "cs switch ${domainName}"`));
   } catch (error) {
     console.error(pc.red(`\u274C Failed to reset domain: ${error}`));
     process.exit(1);

package/dist/session-IWXAKW6Z.js

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

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

@@ -1,24 +1,24 @@
+import {
+  SessionManager
+} from "./chunk-KBKALWDX.js";
 import {
   processManager
-} from "./chunk-56TY2J6E.js";
+} from "./chunk-756VUR5T.js";
 import {
   configManager
-} from "./chunk-XGE4JP55.js";
-import {
-  SessionManager,
-  init_session
-} from "./chunk-UKMZ4CUZ.js";
+} from "./chunk-YMFZWGZO.js";
 import {
   paths
 } from "./chunk-A7YXSI66.js";
-import "./chunk-PNKVD2UK.js";
 
 // src/commands/switch.ts
 import picocolors from "picocolors";
-init_session();
-import { existsSync, writeFileSync, readFileSync, unlinkSync, copyFileSync, mkdirSync, readdirSync } from "fs";
+import { existsSync, writeFileSync, readFileSync, unlinkSync, copyFileSync, mkdirSync, readdirSync, statSync } from "fs";
 import { join, dirname, basename } from "path";
 var pc = picocolors;
+function shellEscapeArg(arg) {
+  return "'" + arg.replace(/'/g, "'\\''") + "'";
+}
 async function switchCommand(domainName, options = {}) {
   try {
     processSessionFallback();
@@ -104,8 +104,20 @@ async function updateMCPConfig(domain) {
   if (!existsSync(mcpDir)) {
     mkdirSync(mcpDir, { recursive: true });
   }
+  let existingConfig = {};
+  if (existsSync(mcpConfigPath)) {
+    try {
+      existingConfig = JSON.parse(readFileSync(mcpConfigPath, "utf-8"));
+    } catch {
+      existingConfig = {};
+    }
+  }
   const mcpConfig = {
-    servers: domain.mcpServers || {}
+    ...existingConfig,
+    servers: {
+      ...existingConfig.servers || {},
+      ...domain.mcpServers || {}
+    }
   };
   writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
   console.log(pc.gray("Updated MCP configuration"));
@@ -119,10 +131,25 @@ 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 files = readdirSync(memoryDir);
-    for (const file of files) {
-      unlinkSync(join(memoryDir, file));
+    const entries = readdirSync(memoryDir);
+    for (const entry of entries) {
+      const entryPath = join(memoryDir, entry);
+      try {
+        const stat = statSync(entryPath);
+        if (stat.isDirectory()) {
+          continue;
+        }
+        if (incomingFileNames.has(entry)) {
+          unlinkSync(entryPath);
+        }
+      } catch {
+      }
     }
   }
   for (const memoryPath of domain.claudeConfig.memory) {
@@ -145,15 +172,24 @@ function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
   const cwd = domain.workingDirectory;
   const markerFile = getSessionFallbackPath();
   const domainName = domain.name;
-  const envLines = domain.env ? Object.entries(domain.env).map(([k, v]) => `export ${k}="${v}"`).join("\n") : "";
+  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 markerJson = JSON.stringify({ domain: domainName, sessionId: fallbackSessionId });
+  const markerJsonEscaped = markerJson.replace(/'/g, "'\\''");
+  const escapedCwd = shellEscapeArg(cwd);
+  const escapedClaudeCmd = shellEscapeArg(claudeCmd);
+  const escapedResumeId = shellEscapeArg(resumeSessionId);
+  const escapedFallbackId = shellEscapeArg(fallbackSessionId);
+  const escapedMarkerFile = shellEscapeArg(markerFile);
   const script = [
     "#!/bin/bash",
-    `cd "${cwd}"`,
+    `cd ${escapedCwd}`,
     envLines,
     "",
     "# Try to resume the existing session",
-    `"${claudeCmd}" --resume "${resumeSessionId}"`,
+    `${escapedClaudeCmd} --resume ${escapedResumeId}`,
     "RESUME_EXIT=$?",
     "",
     "# If resume failed (non-zero exit), fall back to a new session",
@@ -163,9 +199,9 @@ function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
     '  echo ""',
     "",
     "  # Write marker so cs can update state with the new session ID",
-    `  echo '${markerJson}' > "${markerFile}"`,
+    `  echo '${markerJsonEscaped}' > ${escapedMarkerFile}`,
     "",
-    `  "${claudeCmd}" --session-id "${fallbackSessionId}"`,
+    `  ${escapedClaudeCmd} --session-id ${escapedFallbackId}`,
     "fi"
   ].join("\n");
   return processManager.spawnTerminalScript(script, cwd);
@@ -183,10 +219,11 @@ function processSessionFallback() {
     const marker = JSON.parse(content);
     if (marker.domain && marker.sessionId) {
       const state = configManager.loadState();
-      if (state.sessions?.[marker.domain]) {
-        state.sessions[marker.domain].sessionId = marker.sessionId;
-        state.sessions[marker.domain].started = (/* @__PURE__ */ new Date()).toISOString();
-        state.sessions[marker.domain].lastActive = (/* @__PURE__ */ new Date()).toISOString();
+      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.`));

package/package.json

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

package/dist/archive-3IGWZBSO.js

@@ -1,12 +0,0 @@
-import {
-  archiveCommand,
-  listArchives
-} from "./chunk-2LUEUGBV.js";
-import "./chunk-XGE4JP55.js";
-import "./chunk-UKMZ4CUZ.js";
-import "./chunk-A7YXSI66.js";
-import "./chunk-PNKVD2UK.js";
-export {
-  archiveCommand,
-  listArchives
-};

package/dist/chunk-PNKVD2UK.js

@@ -1,26 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-export {
-  __esm,
-  __export,
-  __toCommonJS
-};

package/dist/chunk-UKMZ4CUZ.js

@@ -1,116 +0,0 @@
-import {
-  __esm,
-  __export
-} from "./chunk-PNKVD2UK.js";
-
-// src/core/session.ts
-var session_exports = {};
-__export(session_exports, {
-  SessionManager: () => SessionManager
-});
-import { v5 as uuidv5 } from "uuid";
-import { createHash } from "crypto";
-var SessionManager;
-var init_session = __esm({
-  "src/core/session.ts"() {
-    SessionManager = class {
-      // Namespace UUID for ContextSwitch sessions
-      static NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-      /**
-       * Generate a deterministic session ID for a domain
-       * Uses UUID v5 to ensure same domain always gets same base session ID
-       */
-      static generateSessionId(domainName, reset = false) {
-        const seed = reset ? `${domainName}:${Date.now()}` : domainName;
-        return uuidv5(seed, this.NAMESPACE);
-      }
-      /**
-       * Generate a session hash for verification
-       * Useful for checking if a session is still valid
-       */
-      static generateSessionHash(sessionId, domainName) {
-        const hash = createHash("sha256");
-        hash.update(`${sessionId}:${domainName}`);
-        return hash.digest("hex").substring(0, 8);
-      }
-      /**
-       * Create a session record
-       */
-      static createSessionRecord(domainName, sessionId, processId) {
-        return {
-          domain: domainName,
-          sessionId,
-          started: (/* @__PURE__ */ new Date()).toISOString(),
-          lastActive: (/* @__PURE__ */ new Date()).toISOString(),
-          processId
-        };
-      }
-      /**
-       * Check if a session is likely expired based on age
-       * Claude sessions typically last 1-2 weeks
-       */
-      static isSessionLikelyExpired(startedAt) {
-        const started = new Date(startedAt);
-        const now = /* @__PURE__ */ new Date();
-        const daysSinceStart = (now.getTime() - started.getTime()) / (1e3 * 60 * 60 * 24);
-        return daysSinceStart > 7;
-      }
-      /**
-       * Get session age in human-readable format
-       */
-      static getSessionAge(startedAt) {
-        const started = new Date(startedAt);
-        const now = /* @__PURE__ */ new Date();
-        const diffMs = now.getTime() - started.getTime();
-        const days = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
-        const hours = Math.floor(diffMs % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60));
-        if (days > 0) {
-          return `${days} day${days === 1 ? "" : "s"}, ${hours} hour${hours === 1 ? "" : "s"}`;
-        }
-        if (hours > 0) {
-          return `${hours} hour${hours === 1 ? "" : "s"}`;
-        }
-        const minutes = Math.floor(diffMs / (1e3 * 60));
-        return `${minutes} minute${minutes === 1 ? "" : "s"}`;
-      }
-      /**
-       * Get session risk level based on age
-       */
-      static getSessionRisk(startedAt) {
-        const started = new Date(startedAt);
-        const now = /* @__PURE__ */ new Date();
-        const daysSinceStart = (now.getTime() - started.getTime()) / (1e3 * 60 * 60 * 24);
-        if (daysSinceStart < 3) return "low";
-        if (daysSinceStart < 5) return "medium";
-        if (daysSinceStart < 7) return "high";
-        return "critical";
-      }
-      /**
-       * Format session info for display
-       */
-      static formatSessionInfo(session) {
-        const age = this.getSessionAge(session.started);
-        const risk = this.getSessionRisk(session.started);
-        const riskColors = {
-          low: "\u{1F7E2}",
-          medium: "\u{1F7E1}",
-          high: "\u{1F7E0}",
-          critical: "\u{1F534}"
-        };
-        return [
-          `Domain: ${session.domain}`,
-          `Session ID: ${session.sessionId.substring(0, 8)}...`,
-          `Age: ${age}`,
-          `Risk: ${riskColors[risk]} ${risk}`,
-          risk === "high" || risk === "critical" ? "\u26A0\uFE0F  Consider resetting soon" : ""
-        ].filter(Boolean).join("\n");
-      }
-    };
-  }
-});
-
-export {
-  SessionManager,
-  session_exports,
-  init_session
-};

package/dist/session-YAMF4YD7.js

@@ -1,9 +0,0 @@
-import {
-  SessionManager,
-  init_session
-} from "./chunk-UKMZ4CUZ.js";
-import "./chunk-PNKVD2UK.js";
-init_session();
-export {
-  SessionManager
-};