contextswitch 0.1.6 → 0.1.8

package/dist/{archive-MN425GUR.js → archive-HW56NYMR.js}

@@ -1,8 +1,8 @@
 import {
   archiveCommand,
   listArchives
-} from "./chunk-BGARUR7R.js";
-import "./chunk-D3DHIVER.js";
+} from "./chunk-GDWJEQJQ.js";
+import "./chunk-72MK25T3.js";
 import "./chunk-F36TGFK2.js";
 export {
   archiveCommand,

package/dist/{chunk-D3DHIVER.js → chunk-72MK25T3.js}

@@ -12,6 +12,7 @@ var MCPServerSchema = z.object({
 });
 var DOMAIN_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 var ENV_VAR_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var LAUNCH_MODES = ["window", "tab", "inline"];
 function validateDomainName(name) {
   if (!name || name.length === 0) {
     return "Domain name cannot be empty";
@@ -39,6 +40,7 @@ var DomainConfigSchema = z.object({
     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"),
+  launchMode: z.enum(LAUNCH_MODES).optional().describe("How to open Claude: window, tab, or inline"),
   extends: z.string().optional().describe("Parent domain to inherit from"),
   metadata: z.object({
     description: z.string().optional(),
@@ -66,6 +68,7 @@ var GlobalConfigSchema = z.object({
   autoArchive: z.boolean().default(true),
   archiveDirectory: z.string().optional(),
   claudePath: z.string().optional().describe("Path to Claude CLI executable"),
+  defaultLaunchMode: z.enum(LAUNCH_MODES).optional().describe("Default launch mode: window, tab, or inline"),
   logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
   platform: z.object({
     forceType: z.enum(["darwin", "linux", "win32"]).optional(),
@@ -329,6 +332,7 @@ var ConfigManager = class {
 var configManager = new ConfigManager();
 
 export {
+  LAUNCH_MODES,
   validateDomainName,
   SessionFallbackMarkerSchema,
   validateEnvVarName,

package/dist/{chunk-K7ISIY3Q.js → chunk-7GF2GND2.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-F36TGFK2.js";
 
 // src/core/process.ts
-import { execSync, spawn } from "child_process";
+import { execFileSync, execSync, spawn } from "child_process";
 import { platform } from "os";
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
@@ -142,17 +142,37 @@ var ProcessManager = class {
     }
   }
   /**
-   * Spawn a shell script in a new terminal window
+   * Spawn a shell script in a terminal.
+   * @param mode - 'window' (new window), 'tab' (new tab), or 'inline' (current terminal)
    */
-  spawnTerminalScript(script, _cwd) {
+  spawnTerminalScript(script, _cwd, mode = "window") {
     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", `Writing launch script to ${scriptFile} (mode: ${mode})`);
     debug("process", `Script contents:
 ${script}`);
     writeFileSync(scriptFile, script, { mode: 493 });
+    if (mode === "inline") {
+      debug("process", "Running inline \u2014 taking over current terminal");
+      try {
+        execFileSync("bash", [scriptFile], { stdio: "inherit" });
+      } catch {
+      }
+      return 0;
+    }
     if (this.platform === "darwin") {
       const escapedPath = scriptFile.replace(/"/g, '\\"');
-      const appleScript = `tell app "Terminal" to do script "bash \\"${escapedPath}\\""`;
+      let appleScript;
+      if (mode === "tab") {
+        appleScript = [
+          'tell application "Terminal"',
+          "  activate",
+          `  tell application "System Events" to keystroke "t" using command down`,
+          `  do script "bash \\"${escapedPath}\\"" in front window`,
+          "end tell"
+        ].join("\n");
+      } else {
+        appleScript = `tell app "Terminal" to do script "bash \\"${escapedPath}\\""`;
+      }
       const proc2 = spawn("osascript", ["-e", appleScript], {
         detached: true,
         stdio: "ignore"
@@ -161,10 +181,12 @@ ${script}`);
       return proc2.pid || 0;
     }
     if (this.platform === "linux") {
+      const tabFlag = mode === "tab";
       const terminals = ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"];
       for (const term of terminals) {
         try {
-          const proc2 = spawn(term, ["--", "bash", scriptFile], {
+          const args = term === "gnome-terminal" && tabFlag ? ["--tab", "--", "bash", scriptFile] : ["--", "bash", scriptFile];
+          const proc2 = spawn(term, args, {
             detached: true,
             stdio: "ignore"
           });
@@ -175,16 +197,49 @@ ${script}`);
       }
     }
     if (this.platform === "win32") {
+      const psScriptFile = scriptFile.replace(/\.sh$/, ".ps1");
+      const psScript = this.convertToPowerShell(script);
+      writeFileSync(psScriptFile, psScript, { mode: 493 });
+      debug("process", `PowerShell script:
+${psScript}`);
+      const useTab = mode === "tab";
+      try {
+        const wtArgs = useTab ? ["-w", "0", "nt", "powershell", "-ExecutionPolicy", "Bypass", "-File", psScriptFile] : ["powershell", "-ExecutionPolicy", "Bypass", "-File", psScriptFile];
+        const proc2 = spawn("wt.exe", wtArgs, {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: false
+        });
+        proc2.unref();
+        debug("process", "Launched via Windows Terminal (wt.exe)");
+        return proc2.pid || 0;
+      } catch {
+        debug("process", "Windows Terminal not available, falling back");
+      }
+      try {
+        const proc2 = spawn("cmd.exe", ["/c", "start", "powershell", "-ExecutionPolicy", "Bypass", "-File", psScriptFile], {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: false
+        });
+        proc2.unref();
+        debug("process", "Launched via PowerShell (cmd start)");
+        return proc2.pid || 0;
+      } catch {
+        debug("process", "PowerShell launch failed, trying Git Bash");
+      }
       const gitBash = this.findGitBash();
-      const bashCmd = gitBash || "bash";
-      const scriptPath = scriptFile.replace(/\\/g, "/");
-      const proc2 = spawn("cmd.exe", ["/c", "start", "", bashCmd, scriptPath], {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: false
-      });
-      proc2.unref();
-      return proc2.pid || 0;
+      if (gitBash) {
+        const scriptPath = scriptFile.replace(/\\/g, "/");
+        const proc2 = spawn("cmd.exe", ["/c", "start", "", gitBash, scriptPath], {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: false
+        });
+        proc2.unref();
+        debug("process", "Launched via Git Bash");
+        return proc2.pid || 0;
+      }
     }
     const proc = spawn("bash", [scriptFile], {
       detached: true,
@@ -196,12 +251,124 @@ ${script}`);
   /**
    * Get the Claude executable path (public accessor)
    */
-  getClaudeExecutable() {
+  getClaudeExecutable(configClaudePath) {
+    if (configClaudePath && existsSync(configClaudePath)) {
+      debug("process", `Using claudePath from config: ${configClaudePath}`);
+      return configClaudePath;
+    }
     return this.findClaudeExecutable();
   }
   /**
    * Find Git Bash executable on Windows
    */
+  /**
+   * Convert a simple bash launch script to PowerShell.
+   * Handles: cd, export, exec, echo, if/fi, and comments.
+   */
+  convertToPowerShell(bashScript) {
+    const lines = bashScript.split("\n");
+    const psLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#!/")) continue;
+      if (trimmed.startsWith("#")) {
+        psLines.push(trimmed);
+        continue;
+      }
+      if (trimmed === "") {
+        psLines.push("");
+        continue;
+      }
+      const cdMatch = trimmed.match(/^cd\s+(.+)$/);
+      if (cdMatch) {
+        const dir = cdMatch[1].replace(/^'|'$/g, "").replace(/'\\''/g, "'");
+        psLines.push(`Set-Location "${dir}"`);
+        continue;
+      }
+      const exportMatch = trimmed.match(/^export\s+([A-Za-z_][A-Za-z0-9_]*)="(.*)"$/);
+      if (exportMatch) {
+        psLines.push(`$env:${exportMatch[1]} = "${exportMatch[2]}"`);
+        continue;
+      }
+      if (trimmed.startsWith("exec ")) {
+        const cmd = trimmed.slice(5);
+        const parts = this.parseBashCommand(cmd);
+        psLines.push(`& ${parts.map((p) => `"${p}"`).join(" ")}`);
+        continue;
+      }
+      if (trimmed.startsWith("echo ")) {
+        const msg = trimmed.slice(5).replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+        psLines.push(`Write-Host "${msg}"`);
+        continue;
+      }
+      if (trimmed.match(/^if\s+\[.*\];\s*then$/)) {
+        psLines.push("if ($LASTEXITCODE -ne 0) {");
+        continue;
+      }
+      if (trimmed === "fi") {
+        psLines.push("}");
+        continue;
+      }
+      if (trimmed === "RESUME_EXIT=$?") {
+        psLines.push("# Exit code captured automatically as $LASTEXITCODE");
+        continue;
+      }
+      const cmdLine = trimmed;
+      if (cmdLine.match(/^'?[A-Za-z\/\\:]/)) {
+        const parts = this.parseBashCommand(cmdLine);
+        psLines.push(`& ${parts.map((p) => `"${p}"`).join(" ")}`);
+        continue;
+      }
+      psLines.push(`# ${trimmed}`);
+    }
+    return psLines.join("\r\n");
+  }
+  /**
+   * Parse a bash command with shell-escaped single-quoted arguments into parts.
+   */
+  parseBashCommand(cmd) {
+    const parts = [];
+    let current = "";
+    let inSingleQuote = false;
+    let i = 0;
+    while (i < cmd.length) {
+      const ch = cmd[i];
+      if (inSingleQuote) {
+        if (ch === "'") {
+          if (cmd.slice(i, i + 4) === "'\\''") {
+            current += "'";
+            i += 4;
+            continue;
+          }
+          inSingleQuote = false;
+          i++;
+          continue;
+        }
+        current += ch;
+        i++;
+      } else {
+        if (ch === "'") {
+          inSingleQuote = true;
+          i++;
+          continue;
+        }
+        if (ch === " " || ch === "	") {
+          if (current.length > 0) {
+            parts.push(current);
+            current = "";
+          }
+          i++;
+          continue;
+        }
+        current += ch;
+        i++;
+      }
+    }
+    if (current.length > 0) {
+      parts.push(current);
+    }
+    return parts;
+  }
   findGitBash() {
     if (this.platform !== "win32") return null;
     const candidates = [
@@ -232,9 +399,26 @@ ${script}`);
     try {
       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;
+        const candidates = output.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+        debug("process", `'where claude' returned ${candidates.length} result(s): ${candidates.join(", ")}`);
+        const cliIndicators = ["npm", "node_modules", "bun", "nvm", ".volta", "Roaming"];
+        const guiIndicators = ["Program Files", "AppData\\Local\\claude", "AppData\\Local\\Programs\\claude"];
+        for (const candidate of candidates) {
+          const isLikelyCLI = cliIndicators.some((ind) => candidate.toLowerCase().includes(ind.toLowerCase()));
+          if (isLikelyCLI) {
+            debug("process", `Selected CLI candidate: ${candidate}`);
+            return candidate;
+          }
+        }
+        for (const candidate of candidates) {
+          const isLikelyGUI = guiIndicators.some((ind) => candidate.toLowerCase().includes(ind.toLowerCase()));
+          if (!isLikelyGUI) {
+            debug("process", `Selected non-GUI candidate: ${candidate}`);
+            return candidate;
+          }
+        }
+        debug("process", `Falling back to first 'where' result: ${candidates[0]}`);
+        return candidates[0] || null;
       } else {
         const output = execSync("which claude", { encoding: "utf-8" }).trim();
         debug("process", `Found Claude via 'which': ${output}`);
@@ -243,11 +427,13 @@ ${script}`);
     } 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"),
-        join(process.env.PROGRAMFILES || "C:\\Program Files", "Claude", "claude.exe"),
-        "C:\\Program Files\\Claude Code\\claude.exe",
-        "C:\\Program Files\\Claude\\claude.exe"
+        // npm global installs
+        join(process.env.APPDATA || "", "npm", "claude.cmd"),
+        join(process.env.APPDATA || "", "npm", "claude"),
+        // bun installs
+        join(process.env.USERPROFILE || "", ".bun", "bin", "claude.exe"),
+        // Volta
+        join(process.env.USERPROFILE || "", ".volta", "bin", "claude.exe")
       ] : [
         "/usr/local/bin/claude",
         "/usr/bin/claude",

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

@@ -1,6 +1,6 @@
 import {
   configManager
-} from "./chunk-D3DHIVER.js";
+} from "./chunk-72MK25T3.js";
 import {
   paths
 } from "./chunk-F36TGFK2.js";

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   SessionFallbackMarkerSchema,
   configManager,
   validateDomainName
-} from "./chunk-D3DHIVER.js";
+} from "./chunk-72MK25T3.js";
 import {
   debug,
   enableDebug,
@@ -24,7 +24,7 @@ function getVersion() {
     const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
     return packageJson.version;
   } catch {
-    return "0.1.6";
+    return "0.1.8";
   }
 }
 function processSessionFallbackMarker() {
@@ -66,17 +66,34 @@ function requireValidDomainName(name) {
 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()).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
-  cs switch myproject                              Switch to the domain (launches Claude)
-  cs list                                          See all your domains
+  cs init                                    Initialize ContextSwitch
+  cs domain add myproject -w ~/projects/app  Create a domain
+  cs switch myproject                        Switch to domain (launches Claude)
+  cs list                                    See all 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.
+Launch Modes:
+  cs switch myproject                        Opens Claude in a new terminal window (default)
+  cs switch myproject --mode tab             Opens Claude in a new terminal tab
+  cs switch myproject --mode inline           Runs Claude in the current terminal
 
-Debug:
-  cs --verbose <command>     Show detailed debug output
-  CS_DEBUG=1 cs <command>    Same via environment variable`).hook("preAction", () => {
+  Set a default in domain YAML (launchMode: tab) or global config (defaultLaunchMode: inline).
+  Priority: --mode flag > domain config > global config > window.
+
+Session Management:
+  cs status [domain]                         Show session info and age
+  cs reset <domain>                          Reset session (archives first)
+  cs reset <domain> --skip-archive           Reset without archiving
+  cs archive <domain>                        Snapshot the current session
+
+Domain Management:
+  cs domain add <name> -w <path>             Create a domain (uses cwd if -w omitted)
+  cs domain add <name> --extends <parent>    Inherit from a parent domain
+  cs domain remove <name>                    Remove a domain (prompts for confirmation)
+
+Diagnostics:
+  cs doctor                                  Check Claude install and system config
+  cs --verbose <command>                     Show 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()}`);
@@ -170,12 +187,16 @@ ${pc.cyan("Session Information:")}`);
     process.exit(1);
   }
 });
-program.command("switch <domain>").description("Switch to a different domain").option("-f, --force", "Force new session even if one exists").action(async (domain, options) => {
+program.command("switch <domain>").description("Switch to a domain and launch Claude\n\nResumes the existing session if one exists, or creates a new one.\nUse --force to discard the current session and start fresh.").option("-f, --force", "Force new session even if one exists").option("-m, --mode <mode>", "Launch mode: window (default), tab, or inline").action(async (domain, options) => {
   requireValidDomainName(domain);
-  const { switchCommand } = await import("./switch-CM6GRYEA.js");
+  if (options.mode && !["window", "tab", "inline"].includes(options.mode)) {
+    console.error(pc.red(`\u274C Invalid launch mode '${options.mode}'. Must be: window, tab, or inline`));
+    process.exit(1);
+  }
+  const { switchCommand } = await import("./switch-HUW2NAZD.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").option("-f, --force", "Skip confirmation prompt").action(async (domain, options) => {
+program.command("reset <domain>").description("Reset a domain session (archives current session by default)").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");
@@ -190,20 +211,20 @@ program.command("reset <domain>").description("Reset a domain session (archives
       return;
     }
   }
-  const { resetCommand } = await import("./reset-TSWWNV2Y.js");
+  const { resetCommand } = await import("./reset-O67AMVTV.js");
   await resetCommand(domain, options);
 });
 program.command("archive <domain>").description("Archive the current session for a domain").action(async (domain) => {
   requireValidDomainName(domain);
   try {
-    const { archiveCommand } = await import("./archive-MN425GUR.js");
+    const { archiveCommand } = await import("./archive-HW56NYMR.js");
     await archiveCommand(domain);
   } catch (error) {
     console.error(pc.red(`\u274C ${error}`));
     process.exit(1);
   }
 });
-var domainCmd = program.command("domain").description("Manage domains");
+var domainCmd = program.command("domain").alias("domains").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);
@@ -278,7 +299,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-X2SYCF5V.js");
+  const { processManager } = await import("./process-AKHWPKQE.js");
   console.log(pc.cyan("\u{1FA7A} Running diagnostics...\n"));
   const failures = [];
   const claudeInstalled = processManager.verifyClaudeInstalled();

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

@@ -1,7 +1,7 @@
 import {
   ProcessManager,
   processManager
-} from "./chunk-K7ISIY3Q.js";
+} from "./chunk-7GF2GND2.js";
 import "./chunk-F36TGFK2.js";
 export {
   ProcessManager,

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

@@ -1,9 +1,9 @@
 import {
   archiveCommand
-} from "./chunk-BGARUR7R.js";
+} from "./chunk-GDWJEQJQ.js";
 import {
   configManager
-} from "./chunk-D3DHIVER.js";
+} from "./chunk-72MK25T3.js";
 import "./chunk-F36TGFK2.js";
 
 // src/commands/reset.ts

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

@@ -3,11 +3,12 @@ import {
 } from "./chunk-MGIXKKM6.js";
 import {
   processManager
-} from "./chunk-K7ISIY3Q.js";
+} from "./chunk-7GF2GND2.js";
 import {
+  LAUNCH_MODES,
   configManager,
   validateEnvVarName
-} from "./chunk-D3DHIVER.js";
+} from "./chunk-72MK25T3.js";
 import {
   debug,
   paths
@@ -67,18 +68,21 @@ async function switchCommand(domainName, options = {}) {
       isNewSession = true;
       console.log(pc.gray(`Creating new session ${sessionId.substring(0, 8)}...`));
     }
+    const globalConfig = configManager.loadGlobalConfig();
+    const launchMode = (options.mode && LAUNCH_MODES.includes(options.mode) ? options.mode : void 0) || domain.launchMode || globalConfig.defaultLaunchMode || "window";
     debug("switch", `Session ID: ${sessionId} (${isNewSession ? "new" : "resuming"})`);
     debug("switch", `Working directory: ${domain.workingDirectory}`);
+    debug("switch", `Launch mode: ${launchMode}`);
     await updateMCPConfig(domain);
     await handleMemoryFiles(domain);
     console.log(pc.gray("Starting Claude with new configuration..."));
     if (!isNewSession) {
       const fallbackSessionId = SessionManager.generateSessionId(domainName, true);
       debug("switch", `Resume with fallback: resume=${sessionId.substring(0, 8)}, fallback=${fallbackSessionId.substring(0, 8)}`);
-      spawnClaudeWithFallback(domain, sessionId, fallbackSessionId);
+      spawnClaudeWithFallback(domain, sessionId, fallbackSessionId, launchMode, globalConfig.claudePath);
     } else {
       debug("switch", `New session: ${sessionId.substring(0, 8)}`);
-      spawnClaudeNewSession(domain, sessionId);
+      spawnClaudeNewSession(domain, sessionId, launchMode, globalConfig.claudePath);
     }
     const newState = {
       ...state,
@@ -187,30 +191,24 @@ function buildEnvLines(env) {
   }
   return lines.join("\n");
 }
-function spawnClaudeNewSession(domain, sessionId) {
-  const claudeCmd = processManager.getClaudeExecutable();
+function spawnClaudeNewSession(domain, sessionId, mode = "window", configClaudePath) {
+  const claudeCmd = processManager.getClaudeExecutable(configClaudePath);
   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"
+    `exec ${shellEscapeArg(claudeCmd)} --session-id ${shellEscapeArg(sessionId)}`
   ].join("\n");
-  return processManager.spawnTerminalScript(script, cwd);
+  return processManager.spawnTerminalScript(script, cwd, mode);
 }
-function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
-  const claudeCmd = processManager.getClaudeExecutable();
+function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId, mode = "window", configClaudePath) {
+  const claudeCmd = processManager.getClaudeExecutable(configClaudePath);
   if (!claudeCmd) {
     throw new Error("Claude CLI not found");
   }
@@ -225,20 +223,16 @@ 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 (background + wait to capture PID)",
-    `${escapedClaudeCmd} --resume ${escapedResumeId} &`,
-    "CLAUDE_PID=$!",
-    `echo $CLAUDE_PID > ${pidFile}`,
-    "wait $CLAUDE_PID",
+    "# Try to resume existing session (foreground to preserve TTY)",
+    `${escapedClaudeCmd} --resume ${escapedResumeId}`,
     "RESUME_EXIT=$?",
     "",
-    "# If resume failed (non-zero exit), fall back to a new session",
+    "# If resume failed, fall back to a new session",
     "if [ $RESUME_EXIT -ne 0 ]; then",
     '  echo ""',
     '  echo "Previous session could not be resumed. Starting a fresh session..."',
@@ -247,26 +241,27 @@ function spawnClaudeWithFallback(domain, resumeSessionId, fallbackSessionId) {
     "  # Write marker so cs can update state with the new session ID",
     `  echo '${markerJsonEscaped}' > ${escapedMarkerFile}`,
     "",
-    `  ${escapedClaudeCmd} --session-id ${escapedFallbackId} &`,
-    "  CLAUDE_PID=$!",
-    `  echo $CLAUDE_PID > ${pidFile}`,
-    "  wait $CLAUDE_PID",
+    `  exec ${escapedClaudeCmd} --session-id ${escapedFallbackId}`,
     "fi"
   ].join("\n");
-  return processManager.spawnTerminalScript(script, cwd);
+  return processManager.spawnTerminalScript(script, cwd, mode);
 }
 function getSessionFallbackPath() {
   return join(paths.baseDir, "session-fallback.json");
 }
 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"));
-  console.log(pc.cyan("Install via npm (recommended):"));
+  console.log(pc.white("ContextSwitch requires the Claude Code CLI (not the desktop app).\n"));
+  console.log(pc.cyan("Install via npm:"));
   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"));
   console.log(pc.white("After installing, verify it works:"));
-  console.log(pc.gray("  claude --version\n"));
+  console.log(pc.gray("  claude --version"));
+  console.log(pc.gray('  (should show "Claude Code" not the desktop app)\n'));
+  console.log(pc.white('If "claude" opens the desktop GUI instead, set the CLI path explicitly:'));
+  console.log(pc.gray("  Edit your config.yml and add:"));
+  console.log(pc.gray("    claudePath: /path/to/claude-code/claude\n"));
   console.log(pc.gray("Then try your command again."));
 }
 export {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "contextswitch",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Domain-based context management for Claude Code CLI",
   "main": "dist/cli.js",
   "type": "module",
   "bin": {
-    "cs": "./dist/cli.js",
-    "contextswitch": "./dist/cli.js"
+    "cs": "dist/cli.js",
+    "contextswitch": "dist/cli.js"
   },
   "files": [
     "dist",