dev3000 0.0.156 → 0.0.159

package/dist/dev-environment.js

@@ -4,40 +4,20 @@ import { appendFileSync, copyFileSync, existsSync, mkdirSync, readdirSync, readF
 import https from "https";
 import ora from "ora";
 import { homedir, tmpdir } from "os";
-import { dirname, join } from "path";
+import { dirname, join, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { CDPMonitor } from "./cdp-monitor.js";
 import { ScreencastManager } from "./screencast-manager.js";
 import { NextJsErrorDetector, OutputProcessor, StandardLogParser } from "./services/parsers/index.js";
 import { getBundledSkillsPath } from "./skills/index.js";
 import { DevTUI } from "./tui-interface.js";
-import { formatMcpConfigTargets, MCP_CONFIG_TARGETS } from "./utils/mcp-configs.js";
 import { getProjectDir, getProjectDisplayName, getProjectName } from "./utils/project-name.js";
+import { getSkillsPathForLocation } from "./utils/skill-installer.js";
 import { formatTimestamp } from "./utils/timestamp.js";
 import { checkForUpdates, initTelemetrySession, performUpgradeAsync, sendSessionEndTelemetry } from "./utils/version-check.js";
-// MCP names
-const MCP_NAMES = {
-    DEV3000: "dev3000",
-    CHROME_DEVTOOLS: "dev3000-chrome-devtools",
-    NEXTJS_DEV: "dev3000-nextjs-dev",
-    VERCEL: "vercel"
-};
-// Vercel MCP URL (public OAuth-based MCP) - kept for potential future use
+// Vercel tools URL (legacy, kept for potential future use)
 // @ts-expect-error Unused but kept for reference
-const _VERCEL_MCP_URL = "https://mcp.vercel.com";
-/**
- * Patterns for identifying orphaned MCP-related processes to clean up on startup.
- *
- * IMPORTANT: This list must NOT include ".d3k/chrome-profiles" or any pattern
- * that would match Chrome instances from OTHER running d3k instances.
- * Each d3k instance handles its own profile cleanup via killExistingChromeWithProfile().
- *
- * @see cleanupOrphanedPlaywrightProcesses
- */
-export const ORPHANED_PROCESS_CLEANUP_PATTERNS = [
-    "ms-playwright/mcp-chrome", // Playwright MCP Chrome user data dir
-    "mcp-server-playwright" // Playwright MCP server node process
-];
+const _VERCEL_TOOLS_URL = "https://mcp.vercel.com";
 /**
  * Check if the current project has a .vercel directory (indicating a Vercel project)
  * Kept for potential future use
@@ -147,11 +127,7 @@ function isInSandbox() {
  * Returns the count of running d3k processes (excluding the current one if specified).
  *
  * CRITICAL FOR PROCESS CLEANUP:
- * This function determines whether MCP server should be killed on shutdown.
- * Only the LAST d3k instance should kill the MCP server.
- *
- * @see handleShutdown - Uses this to decide MCP cleanup
- * @see SIGHUP handler - Uses this for synchronous MCP cleanup on tmux close
+ * This function is used to reason about multi-instance shutdown behavior.
  */
 export function countActiveD3kInstances(excludeCurrentPid = false) {
     try {
@@ -184,87 +160,6 @@ export function countActiveD3kInstances(excludeCurrentPid = false) {
         return excludeCurrentPid ? 0 : 1;
     }
 }
-/**
- * Clean up orphaned Playwright/MCP Chrome processes from previous d3k sessions.
- * These processes can become orphaned when d3k crashes or is force-killed,
- * leaving Chrome instances that prevent new sessions from starting properly.
- *
- * This function identifies and kills:
- * - Chrome processes spawned by ms-playwright for MCP servers
- * - mcp-server-playwright node processes
- * - Chrome using d3k-specific profile directories
- */
-async function cleanupOrphanedPlaywrightProcesses(debugLog) {
-    // Skip in sandbox environments where ps/grep may not work
-    if (isInSandbox()) {
-        debugLog("Skipping orphaned process cleanup in sandbox environment");
-        return;
-    }
-    try {
-        const { execSync } = await import("child_process");
-        for (const pattern of ORPHANED_PROCESS_CLEANUP_PATTERNS) {
-            try {
-                // Find PIDs matching the pattern
-                const result = execSync(`ps aux | grep -i "${pattern}" | grep -v grep | awk '{print $2}'`, {
-                    encoding: "utf-8",
-                    stdio: ["pipe", "pipe", "pipe"]
-                }).trim();
-                if (result) {
-                    const pids = result.split("\n").filter(Boolean);
-                    debugLog(`Found ${pids.length} orphaned process(es) matching "${pattern}": [${pids.join(", ")}]`);
-                    for (const pid of pids) {
-                        try {
-                            const pidNum = parseInt(pid, 10);
-                            // First try SIGTERM for graceful shutdown
-                            process.kill(pidNum, "SIGTERM");
-                            debugLog(`Sent SIGTERM to orphaned process ${pid}`);
-                            // Give it a moment to terminate
-                            await new Promise((resolve) => setTimeout(resolve, 100));
-                            // Check if still alive and force kill if needed
-                            try {
-                                process.kill(pidNum, 0); // Check if process exists
-                                process.kill(pidNum, "SIGKILL");
-                                debugLog(`Sent SIGKILL to stubborn process ${pid}`);
-                            }
-                            catch {
-                                // Process already dead, good
-                            }
-                        }
-                        catch (error) {
-                            // Process may have already exited or we don't have permission
-                            debugLog(`Could not kill process ${pid}: ${error}`);
-                        }
-                    }
-                }
-            }
-            catch {
-                // grep returns exit code 1 when no matches found, which is fine
-            }
-        }
-        // Also clean up any stale Chrome lock files that might prevent new instances
-        const lockFilePaths = [
-            join(homedir(), "Library/Caches/ms-playwright/mcp-chrome/SingletonLock"),
-            join(homedir(), "Library/Caches/ms-playwright/mcp-chrome/SingletonSocket"),
-            join(homedir(), "Library/Caches/ms-playwright/mcp-chrome/SingletonCookie")
-        ];
-        for (const lockFile of lockFilePaths) {
-            try {
-                if (existsSync(lockFile)) {
-                    unlinkSync(lockFile);
-                    debugLog(`Removed stale lock file: ${lockFile}`);
-                }
-            }
-            catch {
-                // Ignore errors - file might be locked by running process
-            }
-        }
-        debugLog("Orphaned process cleanup completed");
-    }
-    catch (error) {
-        debugLog(`Error during orphaned process cleanup: ${error}`);
-        // Non-fatal - continue with startup
-    }
-}
 /**
  * Check if a port is available for binding (no process is listening on it).
  * Used for finding available ports before starting servers.
@@ -390,170 +285,12 @@ export async function findAvailablePort(startPort) {
     throw new Error(`No available ports found starting from ${startPort}`);
 }
 // REMOVED: isNextjsMcpEnabled check - now using framework detection from cli.ts
-// Framework detection happens in cli.ts and is stored in session files for MCP orchestrator
-/**
- * Check if Chrome version supports chrome-devtools MCP (>= 140.0.7339.214)
- */
-async function isChromeDevtoolsMcpSupported() {
-    try {
-        // Try different Chrome binary paths
-        const chromePaths = [
-            "/tmp/chromium", // Vercel Sandbox (@sparticuz/chromium)
-            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", // macOS
-            "/opt/google/chrome/chrome", // Linux
-            "chrome", // PATH
-            "google-chrome", // Linux PATH
-            "google-chrome-stable" // Linux PATH
-        ];
-        for (const chromePath of chromePaths) {
-            try {
-                const versionOutput = await new Promise((resolve, reject) => {
-                    const chromeProcess = spawn(chromePath, ["--version"], {
-                        stdio: ["ignore", "pipe", "ignore"]
-                    });
-                    let output = "";
-                    chromeProcess.stdout?.on("data", (data) => {
-                        output += data.toString();
-                    });
-                    chromeProcess.on("close", (code) => {
-                        if (code === 0) {
-                            resolve(output.trim());
-                        }
-                        else {
-                            reject(new Error(`Chrome version check failed with code ${code}`));
-                        }
-                    });
-                    chromeProcess.on("error", reject);
-                    // Timeout after 3 seconds
-                    setTimeout(() => {
-                        chromeProcess.kill();
-                        reject(new Error("Chrome version check timeout"));
-                    }, 3000);
-                });
-                // Parse version from output like "Google Chrome 140.0.7339.214"
-                const versionMatch = versionOutput.match(/(\d+)\.(\d+)\.(\d+)\.(\d+)/);
-                if (versionMatch) {
-                    const [, major, minor, build, patch] = versionMatch.map(Number);
-                    const currentVersion = [major, minor, build, patch];
-                    const requiredVersion = [140, 0, 7339, 214];
-                    // Compare version numbers
-                    for (let i = 0; i < 4; i++) {
-                        if (currentVersion[i] > requiredVersion[i])
-                            return true;
-                        if (currentVersion[i] < requiredVersion[i])
-                            return false;
-                    }
-                    return true; // Versions are equal
-                }
-                break; // Found Chrome but couldn't parse version - continue with other paths
-            }
-            catch {
-                // Try next Chrome path
-            }
-        }
-        return false; // Chrome not found or version not supported
-    }
-    catch {
-        return false; // Any error means not supported
-    }
-}
-/**
- * Clean up old dev3000 MCP entries from project's .mcp.json (Claude Code)
- * MCP server has been removed - we now use CLI commands instead
- */
-async function ensureMcpServers(_mcpPort, _appPort, _enableChromeDevtools) {
-    try {
-        const settingsPath = join(process.cwd(), ".mcp.json");
-        if (!existsSync(settingsPath)) {
-            return; // Nothing to clean up
-        }
-        const settingsContent = readFileSync(settingsPath, "utf-8");
-        const settings = JSON.parse(settingsContent);
-        if (!settings.mcpServers) {
-            return; // Nothing to clean up
-        }
-        let removed = false;
-        // Remove dev3000 MCP entry if it exists (MCP server removed)
-        if (settings.mcpServers[MCP_NAMES.DEV3000]) {
-            delete settings.mcpServers[MCP_NAMES.DEV3000];
-            removed = true;
-        }
-        // Write if we removed anything
-        if (removed) {
-            writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
-        }
-    }
-    catch (_error) {
-        // Ignore errors - settings file manipulation is optional
-    }
-}
-/**
- * Clean up old dev3000 MCP entries from project's .cursor/mcp.json
- * MCP server has been removed - we now use CLI commands instead
- */
-async function ensureCursorMcpServers(_mcpPort, _appPort, _enableChromeDevtools) {
-    try {
-        const cursorDir = join(process.cwd(), ".cursor");
-        const settingsPath = join(cursorDir, "mcp.json");
-        if (!existsSync(settingsPath)) {
-            return; // Nothing to clean up
-        }
-        const settingsContent = readFileSync(settingsPath, "utf-8");
-        const settings = JSON.parse(settingsContent);
-        if (!settings.mcpServers) {
-            return; // Nothing to clean up
-        }
-        let removed = false;
-        // Remove dev3000 MCP entry if it exists (MCP server removed)
-        if (settings.mcpServers[MCP_NAMES.DEV3000]) {
-            delete settings.mcpServers[MCP_NAMES.DEV3000];
-            removed = true;
-        }
-        // Write if we removed anything
-        if (removed) {
-            writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
-        }
-    }
-    catch (_error) {
-        // Ignore errors - settings file manipulation is optional
-    }
-}
-/**
- * Clean up old dev3000 MCP entries from project's opencode.json
- * OpenCode uses "mcp" instead of "mcpServers"
- * MCP server has been removed - we now use CLI commands instead
- */
-async function ensureOpenCodeMcpServers(_mcpPort, _appPort, _enableChromeDevtools) {
-    try {
-        const settingsPath = join(process.cwd(), "opencode.json");
-        if (!existsSync(settingsPath)) {
-            return; // Nothing to clean up
-        }
-        const settingsContent = readFileSync(settingsPath, "utf-8");
-        const settings = JSON.parse(settingsContent);
-        if (!settings.mcp) {
-            return; // Nothing to clean up
-        }
-        let removed = false;
-        // Remove dev3000 MCP entry if it exists (MCP server removed)
-        if (settings.mcp[MCP_NAMES.DEV3000]) {
-            delete settings.mcp[MCP_NAMES.DEV3000];
-            removed = true;
-        }
-        // Write if we removed anything
-        if (removed) {
-            writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
-        }
-    }
-    catch (_error) {
-        // Ignore errors - settings file manipulation is optional
-    }
-}
+// Framework detection happens in cli.ts and is stored in session files for CLI integration
 /**
  * Ensure d3k skill is installed in project's .claude/skills/d3k/
  * Claude Code reads from .claude/skills/ (must be real files, not symlinks)
  */
-async function ensureD3kSkill() {
+async function ensureD3kSkill(skillsAgentId) {
     try {
         const bundledSkillsDir = getBundledSkillsPath();
         if (!bundledSkillsDir)
@@ -561,8 +298,13 @@ async function ensureD3kSkill() {
         const bundledSkillPath = join(bundledSkillsDir, "d3k", "SKILL.md");
         if (!existsSync(bundledSkillPath))
             return;
-        // Install directly to .claude/skills/d3k/ (where Claude Code looks)
-        const skillDir = join(process.cwd(), ".claude", "skills", "d3k");
+        const targetSkillsDir = skillsAgentId ? getSkillsPathForLocation(skillsAgentId, "project")?.path : null;
+        // Install directly to the agent-specific skills dir (fallback to .agents)
+        let skillsRoot = join(process.cwd(), ".agents", "skills");
+        if (targetSkillsDir) {
+            skillsRoot = targetSkillsDir;
+        }
+        const skillDir = join(skillsRoot, "d3k");
         const skillPath = join(skillDir, "SKILL.md");
         // Check if already up to date
         const bundledContent = readFileSync(bundledSkillPath, "utf-8");
@@ -583,7 +325,7 @@ async function ensureD3kSkill() {
     }
 }
 // REMOVED: cleanup functions are no longer needed
-// MCP config files are now kept persistent across dev3000 restarts
+// CLI integration config files are now kept persistent across dev3000 restarts
 export function createPersistentLogFile() {
     // Get unique project name
     const projectName = getProjectName();
@@ -605,7 +347,7 @@ export function createPersistentLogFile() {
     }
 }
 /**
- * Write session info for MCP server to discover.
+ * Write session info for external tooling to discover.
  *
  * CRITICAL FOR PROCESS CLEANUP:
  * This writes the session.json file that contains chromePids and serverPid.
@@ -615,7 +357,7 @@ export function createPersistentLogFile() {
  * processes belong to THIS d3k instance so we don't accidentally kill
  * Chrome instances from other d3k sessions.
  */
-export function writeSessionInfo(projectName, logFilePath, appPort, mcpPort, cdpUrl, chromePids, serverCommand, framework, serverPid) {
+export function writeSessionInfo(projectName, logFilePath, appPort, cdpUrl, chromePids, serverCommand, framework, serverPid) {
     const projectDir = getProjectDir();
     try {
         // Create project directory if it doesn't exist
@@ -627,7 +369,6 @@ export function writeSessionInfo(projectName, logFilePath, appPort, mcpPort, cdp
             projectName,
             logFilePath,
             appPort,
-            mcpPort: mcpPort || null,
             cdpUrl: cdpUrl || null,
             startTime: new Date().toISOString(),
             pid: process.pid,
@@ -646,39 +387,16 @@ export function writeSessionInfo(projectName, logFilePath, appPort, mcpPort, cdp
         console.warn(chalk.yellow(`⚠️ Could not write session info: ${error}`));
     }
 }
-/**
- * Get Chrome PIDs for a d3k session from the session.json file.
- *
- * CRITICAL FOR PROCESS CLEANUP:
- * Chrome PIDs are stored in session.json and used during shutdown to kill
- * the specific Chrome instances spawned by THIS d3k instance.
- *
- * The SIGHUP handler uses this to synchronously kill Chrome on tmux close
- * before the process terminates.
- *
- * @param projectName - The project name (used to locate session.json)
- * @returns Array of Chrome PIDs, or empty array if none found
- */
-export function getSessionChromePids(projectName) {
-    const sessionFile = join(homedir(), ".d3k", projectName, "session.json");
-    try {
-        if (existsSync(sessionFile)) {
-            const sessionInfo = JSON.parse(readFileSync(sessionFile, "utf8"));
-            return sessionInfo.chromePids || [];
-        }
-    }
-    catch (_error) {
-        // Non-fatal - return empty array
-    }
-    return [];
-}
-// Get server PID for this instance
-function getSessionServerPid(projectName) {
+function getSessionInfo(projectName) {
     const sessionFile = join(homedir(), ".d3k", projectName, "session.json");
     try {
         if (existsSync(sessionFile)) {
             const sessionInfo = JSON.parse(readFileSync(sessionFile, "utf8"));
-            return sessionInfo.serverPid || null;
+            return {
+                serverPid: sessionInfo.serverPid ?? null,
+                chromePids: sessionInfo.chromePids ?? [],
+                cwd: sessionInfo.cwd ?? null
+            };
         }
     }
     catch (_error) {
@@ -686,6 +404,9 @@ function getSessionServerPid(projectName) {
     }
     return null;
 }
+export function getSessionChromePids(projectName) {
+    return getSessionInfo(projectName)?.chromePids ?? [];
+}
 function createLogFileInDir(baseDir, _projectName) {
     // Create short timestamp: MMDD-HHmmss (e.g., 0106-171301)
     const now = new Date();
@@ -751,22 +472,14 @@ export class DevEnvironment {
     healthCheckTimer = null;
     tui = null;
     portChangeMessage = null;
-    chromeDevtoolsSupported = false;
     portDetected = false;
     serverUsesHttps = false;
-    disabledMcpConfigSet;
     /** Returns "https" or "http" based on detected server protocol */
     get serverProtocol() {
         return this.serverUsesHttps ? "https" : "http";
     }
     constructor(options) {
-        // Handle portMcp vs mcpPort naming
-        this.options = {
-            ...options,
-            mcpPort: options.portMcp || options.mcpPort || "3684",
-            disabledMcpConfigs: options.disabledMcpConfigs || []
-        };
-        this.disabledMcpConfigSet = new Set(this.options.disabledMcpConfigs);
+        this.options = { ...options };
         this.logger = new Logger(options.logFile, options.tail || false, options.dateTimeFormat || "local");
         this.outputProcessor = new OutputProcessor(new StandardLogParser(), new NextJsErrorDetector());
         // Detect if running from compiled binary
@@ -789,6 +502,10 @@ export class DevEnvironment {
         // Use project-specific PID and lock files to allow multiple projects to run simultaneously
         this.pidFile = join(tmpdir(), `dev3000-${projectName}.pid`);
         this.lockFile = join(tmpdir(), `dev3000-${projectName}.lock`);
+        // Allow CLI-level crash handlers to trigger emergency cleanup.
+        globalThis.__d3kEmergencyShutdown = (reason, error) => {
+            this.emergencyShutdown(1, reason, error);
+        };
         // Read version - for compiled binaries, use injected version; otherwise read from package.json
         this.version = "0.0.0";
         // Check for compile-time injected version first
@@ -823,7 +540,7 @@ export class DevEnvironment {
         this.spinner = ora({
             text: "Initializing...",
             spinner: "dots",
-            isEnabled: !options.tui // Disable spinner in TUI mode
+            isEnabled: !options.tui && !options.tail // Disable spinner in TUI mode
         });
         // Ensure screenshot directory exists
         try {
@@ -842,14 +559,7 @@ export class DevEnvironment {
         this.initializeD3KLog();
     }
     async checkPortsAvailable(silent = false) {
-        // Clean up orphaned Playwright/Chrome processes from previous crashed sessions
-        // This prevents "kill EPERM" errors when MCP tries to spawn new browsers
-        await cleanupOrphanedPlaywrightProcesses((msg) => this.debugLog(msg));
-        // MCP server removed - no longer need to kill
-        // if (this.options.mcpPort) {
-        //   this.debugLog(`Ensuring port ${this.options.mcpPort} is free (always kill)`)
-        //   await this.killMcpServer()
-        // }
+        // No legacy server to clean up; continue with port checks.
         // Check if user explicitly set ports via CLI flags
         const userSetAppPort = this.options.userSetPort || false;
         // If user didn't set ports, find available ones first (before checking)
@@ -881,7 +591,7 @@ export class DevEnvironment {
                 throw new Error(`Port ${this.options.port} is already in use. Please free the port and try again.`);
             }
         }
-        // MCP server removed - no longer need to check mcpPort availability
+        // Legacy server removed - only check app port availability
     }
     async checkProcessHealth() {
         if (this.isShuttingDown)
@@ -893,7 +603,7 @@ export class DevEnvironment {
             return true;
         }
         try {
-            // Only check app port - MCP server has been removed
+            // Only check app port - legacy server has been removed
             const ports = [this.options.port];
             for (const port of ports) {
                 const result = await new Promise((resolve, reject) => {
@@ -938,32 +648,51 @@ export class DevEnvironment {
             this.debugLog("Health check timer stopped");
         }
     }
-    async configureMcpConfigs() {
-        const enabledTargets = MCP_CONFIG_TARGETS.filter((target) => !this.disabledMcpConfigSet.has(target));
-        if (enabledTargets.length === 0) {
-            this.logD3K("AI CLI Integration: MCP config generation disabled via --disable-mcp-configs/DEV3000_DISABLE_MCP_CONFIGS");
+    emergencyShutdown(exitCode, reason, error) {
+        if (this.isShuttingDown)
             return;
+        this.isShuttingDown = true;
+        this.debugLog(`Emergency shutdown requested (${reason})`);
+        if (error) {
+            const errorText = error instanceof Error ? error.stack || error.message : String(error);
+            this.debugLog(`Emergency shutdown error: ${errorText}`);
         }
-        const configuredTargets = [];
-        if (enabledTargets.includes("claude")) {
-            await ensureMcpServers(this.options.mcpPort || "3684", this.options.port, this.chromeDevtoolsSupported);
-            await ensureD3kSkill(); // Install d3k skill for Claude Code
-            configuredTargets.push("claude");
-        }
-        if (enabledTargets.includes("cursor")) {
-            await ensureCursorMcpServers(this.options.mcpPort || "3684", this.options.port, this.chromeDevtoolsSupported);
-            configuredTargets.push("cursor");
-        }
-        if (enabledTargets.includes("opencode")) {
-            await ensureOpenCodeMcpServers(this.options.mcpPort || "3684", this.options.port, this.chromeDevtoolsSupported);
-            configuredTargets.push("opencode");
-        }
-        if (configuredTargets.length > 0) {
-            this.logD3K(`AI CLI Integration: Configured MCP servers in ${formatMcpConfigTargets(configuredTargets)}`);
+        // Stop CDP reconnection attempts before killing the app server.
+        if (this.cdpMonitor) {
+            this.cdpMonitor.prepareShutdown();
+        }
+        // Best-effort synchronous cleanup (mirrors SIGHUP handler).
+        const { spawnSync } = require("child_process");
+        const port = this.options.port;
+        this.debugLog(`Synchronous kill for port ${port}`);
+        spawnSync("sh", ["-c", `lsof -ti:${port} | xargs kill -9 2>/dev/null`], {
+            stdio: "pipe",
+            timeout: 5000
+        });
+        const projectName = getProjectName();
+        const sessionInfo = getSessionInfo(projectName);
+        const chromePids = sessionInfo?.chromePids ?? [];
+        if (chromePids.length > 0) {
+            this.debugLog(`Synchronously killing Chrome PIDs: [${chromePids.join(", ")}]`);
+            for (const pid of chromePids) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch {
+                    // Ignore - process may already be dead
+                }
+            }
         }
-        else {
-            this.logD3K("AI CLI Integration: MCP configs already up to date");
+        if (sessionInfo?.serverPid) {
+            this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, `emergency:${reason}`);
         }
+        this.handleShutdown()
+            .then(() => {
+            process.exit(exitCode);
+        })
+            .catch(() => {
+            process.exit(exitCode);
+        });
     }
     async start() {
         // Check if another instance is already running for this project
@@ -974,6 +703,8 @@ export class DevEnvironment {
         }
         // Initialize telemetry session (used by version check)
         initTelemetrySession(this.options.framework);
+        // Kill any orphaned server process from a previous run of this project
+        this.cleanupOrphanedServer();
         // Check if TUI mode is enabled (default) and stdin supports it
         const canUseTUI = this.options.tui && process.stdin.isTTY;
         if (!canUseTUI && this.options.tui) {
@@ -988,7 +719,6 @@ export class DevEnvironment {
             // Start TUI interface with initial status and updated port
             this.tui = new DevTUI({
                 appPort: this.options.port, // This may have been updated by checkPortsAvailable
-                mcpPort: this.options.mcpPort || "3684",
                 logFile: this.options.logFile,
                 commandName: this.options.commandName,
                 serversOnly: this.options.serversOnly,
@@ -1014,6 +744,21 @@ export class DevEnvironment {
                         stdio: "pipe",
                         timeout: 5000
                     });
+                    const projectName = getProjectName();
+                    const chromePids = getSessionChromePids(projectName);
+                    if (chromePids.length > 0) {
+                        this.debugLog(`Synchronous kill for Chrome PIDs: [${chromePids.join(", ")}]`);
+                        for (const pid of chromePids) {
+                            try {
+                                process.kill(pid, "SIGTERM");
+                                process.kill(pid, 0);
+                                process.kill(pid, "SIGKILL");
+                            }
+                            catch {
+                                // Ignore - process may already be dead
+                            }
+                        }
+                    }
                     // Now do the rest of cleanup async
                     this.tui?.updateStatus("Shutting down...");
                     this.handleShutdown()
@@ -1049,6 +794,9 @@ export class DevEnvironment {
             });
             // Show initial status message
             await this.tui.updateStatus("d3k is checking for skill updates...");
+            // Install d3k skill early so it's available when Claude Code starts
+            // This is important for --with-agent where both start simultaneously
+            await ensureD3kSkill(this.options.skillsAgentId);
             // Check ports in background after TUI is visible
             await this.checkPortsAvailable(true); // silent mode for TUI
             // Update the app port in TUI (may have changed during port check)
@@ -1073,7 +821,7 @@ export class DevEnvironment {
             // Start user's dev server
             await this.tui.updateStatus("Starting your dev server...");
             await this.startServer();
-            // MCP server removed - using CLI commands instead
+            // Legacy tools server removed - using CLI commands instead
             // await this.startMcpServer()
             // Wait for servers to be ready
             await this.tui.updateStatus("Waiting for app...");
@@ -1087,21 +835,8 @@ export class DevEnvironment {
             }
             // Update TUI with confirmed port (may have changed during server startup)
             this.tui.updateAppPort(this.options.port);
-            // MCP server removed - using CLI commands instead
+            // Legacy tools server removed - using CLI commands instead
             // await this.waitForMcpServer()
-            // Configure AI CLI integrations (both dev3000 and chrome-devtools MCPs)
-            if (!this.options.serversOnly) {
-                await this.tui.updateStatus("Configuring AI CLI integrations...");
-                // Check if Chrome version supports chrome-devtools MCP
-                if (this.options.chromeDevtoolsMcp !== false) {
-                    this.chromeDevtoolsSupported = await isChromeDevtoolsMcpSupported();
-                    if (!this.chromeDevtoolsSupported) {
-                        this.logD3K("Chrome version < 140.0.7339.214 detected - chrome-devtools MCP will be skipped");
-                    }
-                }
-                // Ensure MCP server configurations in project settings files (instant, local)
-                await this.configureMcpConfigs();
-            }
             // Start CDP monitoring only if server started successfully and not in servers-only mode
             if (!this.options.serversOnly && serverStarted) {
                 await this.tui.updateStatus(`Starting ${this.options.commandName} browser...`);
@@ -1113,16 +848,19 @@ export class DevEnvironment {
             else {
                 this.debugLog("Browser monitoring disabled via --servers-only flag");
             }
-            // Write session info for MCP server discovery (include CDP URL if browser monitoring was started)
+            // Write session info for tooling discovery (include CDP URL if browser monitoring was started)
             const cdpUrl = this.cdpMonitor?.getCdpUrl() || null;
             const chromePids = this.cdpMonitor?.getChromePids() || [];
-            writeSessionInfo(projectName, this.options.logFile, this.options.port, this.options.mcpPort, cdpUrl, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
+            writeSessionInfo(projectName, this.options.logFile, this.options.port, cdpUrl, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
             // Clear status - ready!
             await this.tui.updateStatus(null);
         }
         else {
             // Non-TUI mode - original flow
             console.log(chalk.hex("#A18CE5")(`Starting ${this.options.commandName} (v${this.version})`));
+            // Install d3k skill early so it's available when Claude Code starts
+            // This is important for --with-agent where both start simultaneously
+            await ensureD3kSkill(this.options.skillsAgentId);
             // Start spinner
             this.spinner.start("Checking ports...");
             // Check if ports are available first
@@ -1135,7 +873,7 @@ export class DevEnvironment {
             // Start user's dev server
             this.spinner.text = "Starting your dev server...";
             await this.startServer();
-            // MCP server removed - using CLI commands instead
+            // Legacy server removed - using CLI commands instead
             // await this.startMcpServer()
             // Wait for servers to be ready
             this.spinner.text = "Waiting for app...";
@@ -1147,21 +885,8 @@ export class DevEnvironment {
                 console.error(chalk.yellow("Exiting without launching browser."));
                 process.exit(1);
             }
-            // MCP server removed - using CLI commands instead
+            // Legacy server removed - using CLI commands instead
             // await this.waitForMcpServer()
-            // Configure AI CLI integrations (both dev3000 and chrome-devtools MCPs)
-            if (!this.options.serversOnly) {
-                this.spinner.text = "Configuring AI CLI integrations...";
-                // Check if Chrome version supports chrome-devtools MCP
-                if (this.options.chromeDevtoolsMcp !== false) {
-                    this.chromeDevtoolsSupported = await isChromeDevtoolsMcpSupported();
-                    if (!this.chromeDevtoolsSupported) {
-                        this.logD3K("Chrome version < 140.0.7339.214 detected - chrome-devtools MCP will be skipped");
-                    }
-                }
-                // Ensure MCP server configurations in project settings files (instant, local)
-                await this.configureMcpConfigs();
-            }
             // Start CDP monitoring only if server started successfully and not in servers-only mode
             if (!this.options.serversOnly && serverStarted) {
                 this.spinner.text = `Starting ${this.options.commandName} browser...`;
@@ -1178,7 +903,7 @@ export class DevEnvironment {
             // Include CDP URL if browser monitoring was started
             const cdpUrl = this.cdpMonitor?.getCdpUrl() || null;
             const chromePids = this.cdpMonitor?.getChromePids() || [];
-            writeSessionInfo(projectName, this.options.logFile, this.options.port, this.options.mcpPort, cdpUrl, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
+            writeSessionInfo(projectName, this.options.logFile, this.options.port, cdpUrl, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
             // Complete startup with success message only in non-TUI mode
             this.spinner.succeed("Development environment ready!");
             // Regular console output (when TUI is disabled with --no-tui)
@@ -1187,7 +912,7 @@ export class DevEnvironment {
             console.log(chalk.cyan(`🌐 Your App: ${this.serverProtocol}://localhost:${this.options.port}`));
             console.log(chalk.cyan(`🔧 CLI Tools: d3k fix, d3k crawl, d3k find-component`));
             if (this.options.serversOnly) {
-                console.log(chalk.cyan("🖥️  Servers-only mode - use Chrome extension for browser monitoring"));
+                console.log(chalk.cyan("🖥️  Servers-only mode - browser monitoring disabled"));
             }
             console.log(chalk.cyan("\nUse Ctrl-C to stop.\n"));
             // Auto-upgrade in non-TUI mode (non-blocking)
@@ -1322,6 +1047,83 @@ export class DevEnvironment {
             }
         });
     }
+    isSessionCwdOwned(sessionCwd) {
+        if (!sessionCwd)
+            return false;
+        try {
+            const current = resolve(process.cwd());
+            const session = resolve(sessionCwd);
+            return session === current || current.startsWith(session + sep) || session.startsWith(current + sep);
+        }
+        catch {
+            return false;
+        }
+    }
+    isPidRunning(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    killServerPidIfOwned(pid, sessionCwd, reason) {
+        if (!this.isSessionCwdOwned(sessionCwd)) {
+            this.debugLog(`Skipping server PID ${pid} kill (${reason}): session cwd mismatch`);
+            return;
+        }
+        if (!this.isPidRunning(pid)) {
+            this.debugLog(`Skipping server PID ${pid} kill (${reason}): not running`);
+            return;
+        }
+        this.debugLog(`Killing server PID ${pid} (${reason})`);
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Ignore - process may already be dead
+        }
+        if (process.platform !== "win32") {
+            try {
+                process.kill(-pid, "SIGTERM");
+            }
+            catch {
+                // Ignore - process group may not exist
+            }
+        }
+        try {
+            process.kill(pid, 0);
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // Ignore - process may already be dead
+        }
+        if (process.platform !== "win32") {
+            try {
+                process.kill(-pid, "SIGKILL");
+            }
+            catch {
+                // Ignore - process group may not exist
+            }
+        }
+        if (!isInSandbox()) {
+            try {
+                const { spawnSync } = require("child_process");
+                spawnSync("pkill", ["-P", pid.toString()], { stdio: "ignore" });
+            }
+            catch {
+                // Ignore pkill errors
+            }
+        }
+    }
+    cleanupOrphanedServer() {
+        const projectName = getProjectName();
+        const sessionInfo = getSessionInfo(projectName);
+        if (!sessionInfo?.serverPid)
+            return;
+        this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "startup orphan cleanup");
+    }
     acquireLock() {
         try {
             // Check if lock file exists
@@ -1378,7 +1180,7 @@ export class DevEnvironment {
             const cdpUrl = this.cdpMonitor?.getCdpUrl();
             const chromePids = this.cdpMonitor?.getChromePids() || [];
             if (cdpUrl || chromePids.length > 0) {
-                writeSessionInfo(projectName, this.options.logFile, this.options.port, this.options.mcpPort, cdpUrl || undefined, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
+                writeSessionInfo(projectName, this.options.logFile, this.options.port, cdpUrl || undefined, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
                 this.debugLog(`Updated session info with new port: ${this.options.port}`);
             }
             // Update TUI header with new port
@@ -1557,23 +1359,6 @@ export class DevEnvironment {
             // Ignore D3K log initialization errors - non-critical
         }
     }
-    logD3K(message) {
-        // Write [D3K] logs to project-specific dev3000 debug log, NOT to main project log
-        // This prevents Claude from thinking dev3000's orchestration logic needs to be "fixed"
-        const timestamp = formatTimestamp(new Date(), this.options.dateTimeFormat || "local");
-        const logEntry = `[${timestamp}] [D3K] ${message}\n`;
-        try {
-            const projectDir = getProjectDir();
-            if (!existsSync(projectDir)) {
-                mkdirSync(projectDir, { recursive: true });
-            }
-            const d3kLogFile = join(projectDir, "d3k.log");
-            appendFileSync(d3kLogFile, logEntry);
-        }
-        catch {
-            // Ignore D3K log write errors - non-critical
-        }
-    }
     async startCDPMonitoringSync() {
         // Skip if in servers-only mode
         if (this.options.serversOnly) {
@@ -1603,7 +1388,6 @@ export class DevEnvironment {
         this.cdpMonitor = new CDPMonitor(this.options.profileDir, this.screenshotDir, (_source, message) => {
             this.logger.log("browser", message);
         }, this.options.debug, this.options.browser, this.options.pluginReactScan, this.options.port, // App server port to monitor
-        this.options.mcpPort, // MCP server port to ignore
         this.options.debugPort, // Chrome debug port
         this.options.headless // Headless mode for serverless/CI environments
         );
@@ -1633,7 +1417,7 @@ export class DevEnvironment {
             }
             // Always write session info after CDP monitoring starts - this is critical for
             // sandbox environments where external tools poll for the cdpUrl in the session file
-            writeSessionInfo(projectName, this.options.logFile, this.options.port, this.options.mcpPort, cdpUrl || undefined, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
+            writeSessionInfo(projectName, this.options.logFile, this.options.port, cdpUrl || undefined, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid);
             this.debugLog(`Updated session info with CDP URL: ${cdpUrl}, Chrome PIDs: [${chromePids.join(", ")}]`);
             this.logger.log("browser", `[CDP] Session info written with cdpUrl: ${cdpUrl ? "available" : "null"}`);
             // Navigate to the app
@@ -1657,9 +1441,9 @@ export class DevEnvironment {
             await this.screencastManager.stop();
             this.screencastManager = null;
         }
-        // Read server PID from session file BEFORE deleting it (needed for cleanup)
+        // Read session info BEFORE deleting it (needed for cleanup)
         const projectName = getProjectName();
-        const savedServerPid = getSessionServerPid(projectName);
+        const sessionInfo = getSessionInfo(projectName);
         // Clean up session file
         try {
             const sessionFile = join(homedir(), ".d3k", projectName, "session.json");
@@ -1670,7 +1454,7 @@ export class DevEnvironment {
         catch (_error) {
             // Non-fatal - ignore cleanup errors
         }
-        // Check PID file ownership BEFORE deleting (needed for MCP cleanup decision)
+        // Check PID file ownership BEFORE deleting (needed for cleanup decisions)
         let weOwnPidFile = false;
         try {
             if (existsSync(this.pidFile)) {
@@ -1720,26 +1504,12 @@ export class DevEnvironment {
                 console.log(chalk.gray(`⚠️ Could not kill ${name} on port ${port}`));
             }
         };
-        // Kill app server only (MCP server remains as singleton)
+        // Kill app server only
         console.log(chalk.cyan("🔄 Killing app server..."));
         await killPortProcess(this.options.port, "your app server");
         // Kill server process and its children using the saved PID (from before session file was deleted)
-        if (!isInSandbox() && savedServerPid) {
-            try {
-                const { spawnSync } = await import("child_process");
-                // Kill all child processes of the server
-                spawnSync("pkill", ["-P", savedServerPid.toString()], { stdio: "ignore" });
-                // Kill the server process itself
-                try {
-                    process.kill(savedServerPid, "SIGKILL");
-                }
-                catch {
-                    // Process may already be dead
-                }
-            }
-            catch {
-                // Ignore pkill errors
-            }
+        if (sessionInfo?.serverPid) {
+            this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "graceful shutdown");
         }
         // Shutdown CDP monitor if it was started
         if (this.cdpMonitor) {
@@ -1752,26 +1522,6 @@ export class DevEnvironment {
                 console.log(chalk.gray("⚠️ CDP monitor shutdown failed"));
             }
         }
-        // Kill MCP server only if this is the last d3k instance AND we own the PID file
-        const otherInstances = countActiveD3kInstances(true); // exclude current process
-        this.debugLog(`Other active d3k instances: ${otherInstances}, weOwnPidFile: ${weOwnPidFile}`);
-        if (otherInstances === 0 && this.options.mcpPort && !isInSandbox() && weOwnPidFile) {
-            console.log(chalk.yellow("🔄 Killing MCP server (last d3k instance)..."));
-            try {
-                const { spawnSync } = await import("child_process");
-                spawnSync("sh", ["-c", `lsof -ti:${this.options.mcpPort} -sTCP:LISTEN | xargs kill -9 2>/dev/null`], {
-                    stdio: "pipe",
-                    timeout: 5000
-                });
-                console.log(chalk.green("✅ MCP server stopped"));
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        else if (!weOwnPidFile) {
-            this.debugLog("Skipping MCP cleanup - we don't own the PID file (subprocess will handle it)");
-        }
         console.log(chalk.red(`❌ ${this.options.commandName} exited due to server failure`));
         // Show recent log entries to help diagnose the issue
         this.showRecentLogs();
@@ -1817,6 +1567,25 @@ export class DevEnvironment {
                 stdio: "pipe",
                 timeout: 5000
             });
+            const projectName = getProjectName();
+            const sessionInfo = getSessionInfo(projectName);
+            const chromePids = sessionInfo?.chromePids ?? [];
+            if (chromePids.length > 0) {
+                this.debugLog(`Synchronous kill for Chrome PIDs: [${chromePids.join(", ")}]`);
+                for (const pid of chromePids) {
+                    try {
+                        process.kill(pid, "SIGTERM");
+                        process.kill(pid, 0);
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch {
+                        // Ignore - process may already be dead
+                    }
+                }
+            }
+            if (sessionInfo?.serverPid) {
+                this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "SIGINT");
+            }
             if (this.options.tui && this.tui) {
                 // In TUI mode, show shutting down message
                 this.debugLog("Updating TUI status with shutdown message");
@@ -1858,6 +1627,25 @@ export class DevEnvironment {
                 stdio: "pipe",
                 timeout: 5000
             });
+            const projectName = getProjectName();
+            const sessionInfo = getSessionInfo(projectName);
+            const chromePids = sessionInfo?.chromePids ?? [];
+            if (chromePids.length > 0) {
+                this.debugLog(`Synchronous kill for Chrome PIDs: [${chromePids.join(", ")}]`);
+                for (const pid of chromePids) {
+                    try {
+                        process.kill(pid, "SIGTERM");
+                        process.kill(pid, 0);
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch {
+                        // Ignore - process may already be dead
+                    }
+                }
+            }
+            if (sessionInfo?.serverPid) {
+                this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "SIGTERM");
+            }
             this.handleShutdown()
                 .then(() => {
                 process.exit(0);
@@ -1877,66 +1665,18 @@ export class DevEnvironment {
          * 1. Signal CDP monitor to stop reconnection attempts
          * 2. Kill dev server processes on app port (synchronous via lsof)
          * 3. Kill Chrome PIDs from session.json (synchronous)
-         * 4. Kill MCP server IF we're the last d3k instance (synchronous)
-         * 5. Call handleShutdown() for async cleanup
+         * 4. Call handleShutdown() for async cleanup
          *
          * INVARIANTS (enforced by tests in dev-environment.test.ts):
          * - Chrome PIDs are stored per-session in session.json
          * - We only kill Chrome instances WE spawned (via chromePids array)
-         * - MCP server is only killed when countActiveD3kInstances() returns 0
          * - All cleanup happens BEFORE process.exit()
          *
          * @see dev-environment.test.ts - "SIGHUP handler cleanup" test suite
          */
         process.on("SIGHUP", () => {
             this.debugLog("SIGHUP received (tmux session closing)");
-            if (this.isShuttingDown)
-                return;
-            this.isShuttingDown = true;
-            // 1. Signal CDP monitor to stop reconnection attempts
-            if (this.cdpMonitor) {
-                this.cdpMonitor.prepareShutdown();
-            }
-            // 2. CRITICAL: Kill dev server processes SYNCHRONOUSLY
-            // tmux might kill us quickly, so we can't rely on async cleanup
-            const { spawnSync } = require("child_process");
-            const port = this.options.port;
-            this.debugLog(`Synchronous kill for port ${port}`);
-            spawnSync("sh", ["-c", `lsof -ti:${port} | xargs kill -9 2>/dev/null`], {
-                stdio: "pipe",
-                timeout: 5000
-            });
-            // 3. CRITICAL: Kill Chrome PIDs synchronously
-            // Get Chrome PIDs from session file before it gets deleted
-            const projectName = getProjectName();
-            const chromePids = getSessionChromePids(projectName);
-            if (chromePids.length > 0) {
-                this.debugLog(`Synchronously killing Chrome PIDs: [${chromePids.join(", ")}]`);
-                for (const pid of chromePids) {
-                    try {
-                        process.kill(pid, "SIGTERM");
-                    }
-                    catch {
-                        // Ignore - process may already be dead
-                    }
-                }
-            }
-            // 4. CRITICAL: Kill MCP server only if we're the LAST instance
-            const otherInstances = countActiveD3kInstances(true);
-            if (otherInstances === 0 && this.options.mcpPort) {
-                this.debugLog(`Synchronously killing MCP server on port ${this.options.mcpPort}`);
-                spawnSync("sh", ["-c", `lsof -ti:${this.options.mcpPort} -sTCP:LISTEN | xargs kill -9 2>/dev/null`], {
-                    stdio: "pipe",
-                    timeout: 5000
-                });
-            }
-            this.handleShutdown()
-                .then(() => {
-                process.exit(0);
-            })
-                .catch(() => {
-                process.exit(1);
-            });
+            this.emergencyShutdown(0, "SIGHUP");
         });
     }
     async handleShutdown() {
@@ -1946,9 +1686,9 @@ export class DevEnvironment {
         sendSessionEndTelemetry().catch(() => { });
         // Release the lock file
         this.releaseLock();
-        // Read server PID from session file BEFORE deleting it (needed for cleanup)
+        // Read session info BEFORE deleting it (needed for cleanup)
         const projectName = getProjectName();
-        const savedServerPid = getSessionServerPid(projectName);
+        const sessionInfo = getSessionInfo(projectName);
         // Clean up session file
         try {
             const sessionFile = join(homedir(), ".d3k", projectName, "session.json");
@@ -1959,8 +1699,7 @@ export class DevEnvironment {
         catch (_error) {
             // Non-fatal - ignore cleanup errors
         }
-        // Check PID file ownership BEFORE deleting (needed for MCP cleanup decision)
-        // Only the process that owns the PID file should clean up the MCP server
+        // Check PID file ownership BEFORE deleting (needed for cleanup decisions)
         let weOwnPidFile = false;
         try {
             if (existsSync(this.pidFile)) {
@@ -2013,7 +1752,8 @@ export class DevEnvironment {
                 // Fallback: force kill any remaining Chrome processes for THIS instance only
                 try {
                     const projectName = getProjectName();
-                    const chromePids = getSessionChromePids(projectName);
+                    const sessionInfo = getSessionInfo(projectName);
+                    const chromePids = sessionInfo?.chromePids ?? [];
                     if (chromePids.length > 0) {
                         this.debugLog(`Fallback cleanup: killing Chrome PIDs for this instance: [${chromePids.join(", ")}]`);
                         const { spawn } = await import("child_process");
@@ -2029,16 +1769,18 @@ export class DevEnvironment {
                     else {
                         this.debugLog("Fallback cleanup: no Chrome PIDs found for this instance");
                     }
+                    if (sessionInfo?.serverPid) {
+                        this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "TUI shutdown");
+                    }
                 }
                 catch {
                     // Ignore errors in fallback cleanup
                 }
             }
         }
-        // REMOVED: No longer clean up MCP config files on shutdown
+        // REMOVED: No longer clean up CLI config files on shutdown
         // This was causing Claude Code instances to crash when dev3000 was killed
-        // Now we keep .mcp.json, .cursor/mcp.json, and opencode.json configured
-        // for the next dev3000 run, providing a better developer experience
+        // Config file cleanup removed; keep user config files untouched on shutdown
         // Kill processes on both ports (skip in sandbox - lsof doesn't exist)
         const killPortProcess = async (port, name) => {
             // Skip lsof-based kill in sandbox environments
@@ -2093,7 +1835,7 @@ export class DevEnvironment {
                 }
             }
         };
-        // Kill app server (MCP server remains as singleton)
+        // Kill app server
         if (!this.options.tui) {
             console.log(chalk.yellow("🔄 Killing app server..."));
         }
@@ -2148,18 +1890,8 @@ export class DevEnvironment {
             spawnSync("sh", ["-c", `pkill -f "next-server.*${cwd}"`], { stdio: "ignore" });
             this.debugLog(`Sent pkill signal for next processes in ${cwd}`);
             // Kill server process and its children using the saved PID (from before session file was deleted)
-            if (savedServerPid) {
-                // Kill all child processes of the server
-                spawnSync("pkill", ["-P", savedServerPid.toString()], { stdio: "ignore" });
-                this.debugLog(`Killed children of server PID ${savedServerPid}`);
-                // Kill the server process itself
-                try {
-                    process.kill(savedServerPid, "SIGKILL");
-                    this.debugLog(`Killed server PID ${savedServerPid}`);
-                }
-                catch {
-                    // Process may already be dead
-                }
+            if (sessionInfo?.serverPid) {
+                this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "handleShutdown");
             }
             // Final synchronous lsof kill - most reliable method
             const result = spawnSync("sh", ["-c", `lsof -ti:${this.options.port} | xargs kill -9 2>/dev/null`], {
@@ -2170,35 +1902,6 @@ export class DevEnvironment {
         catch {
             // Ignore pkill errors
         }
-        // Kill MCP server only if this is the last d3k instance AND we own the PID file
-        // (other d3k instances in other projects might still need it)
-        // The TUI parent shouldn't do MCP cleanup - the subprocess (which owns the PID file) will handle it
-        // Note: weOwnPidFile was already determined at the top of handleShutdown()
-        const otherInstances = countActiveD3kInstances(true); // exclude current process
-        this.debugLog(`Other active d3k instances: ${otherInstances}, weOwnPidFile: ${weOwnPidFile}`);
-        if (otherInstances === 0 && this.options.mcpPort && weOwnPidFile) {
-            if (!this.options.tui) {
-                console.log(chalk.yellow("🔄 Killing MCP server (last d3k instance)..."));
-            }
-            this.debugLog(`Killing MCP server on port ${this.options.mcpPort} (no other d3k instances)`);
-            try {
-                const { spawnSync } = await import("child_process");
-                const mcpResult = spawnSync("sh", ["-c", `lsof -ti:${this.options.mcpPort} -sTCP:LISTEN | xargs kill -9 2>/dev/null`], { stdio: "pipe", timeout: 5000 });
-                this.debugLog(`MCP server kill exit code: ${mcpResult.status}`);
-                if (!this.options.tui) {
-                    console.log(chalk.green("✅ MCP server stopped"));
-                }
-            }
-            catch (error) {
-                this.debugLog(`Error killing MCP server: ${error}`);
-            }
-        }
-        else if (otherInstances > 0) {
-            this.debugLog(`Keeping MCP server running for ${otherInstances} other d3k instance(s)`);
-        }
-        else if (!weOwnPidFile) {
-            this.debugLog("Skipping MCP cleanup - we don't own the PID file (subprocess will handle it)");
-        }
         if (!this.options.tui) {
             console.log(chalk.green("✅ Cleanup complete"));
         }