happy-coder 0.9.0-6 → 0.9.0

package/dist/index.mjs

@@ -1,16 +1,16 @@
 import chalk from 'chalk';
-import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, c as configuration, f as encodeBase64, g as encodeBase64Url, h as decodeBase64, A as ApiClient } from './types-DJOX-XG-.mjs';
+import os$1, { homedir } from 'node:os';
 import { randomUUID, randomBytes } from 'node:crypto';
+import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, r as readDaemonState, c as configuration, f as clearDaemonState, p as packageJson, g as readSettings, h as readCredentials, i as encodeBase64, u as updateSettings, j as encodeBase64Url, k as decodeBase64, w as writeCredentials, m as acquireDaemonLock, n as writeDaemonState, A as ApiClient, o as releaseDaemonLock, q as clearCredentials, s as clearMachineId, t as getLatestDaemonLog } from './types-Cezp_n6O.mjs';
 import { spawn, execSync } from 'node:child_process';
 import { resolve, join, dirname as dirname$1 } from 'node:path';
 import { createInterface } from 'node:readline';
 import { fileURLToPath as fileURLToPath$1 } from 'node:url';
-import { existsSync, readFileSync, mkdirSync, watch, constants, readdirSync, statSync, rmSync } from 'node:fs';
-import os$1, { homedir } from 'node:os';
+import { existsSync, readFileSync, mkdirSync, watch, readdirSync, statSync, rmSync } from 'node:fs';
 import { dirname, resolve as resolve$1, join as join$1 } from 'path';
 import { fileURLToPath } from 'url';
-import { readFile, unlink, mkdir, writeFile as writeFile$1, open, stat as stat$1, rename } from 'node:fs/promises';
-import { watch as watch$1, access, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
+import { readFile } from 'node:fs/promises';
+import fs, { watch as watch$1, access, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import axios from 'axios';
@@ -21,17 +21,16 @@ import 'expo-server-sdk';
 import { spawn as spawn$1, exec, execSync as execSync$1 } from 'child_process';
 import { promisify } from 'util';
 import { createHash } from 'crypto';
-import * as z from 'zod';
-import { z as z$1 } from 'zod';
-import fastify from 'fastify';
-import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
 import os from 'os';
 import qrcode from 'qrcode-terminal';
-import open$1 from 'open';
+import open from 'open';
+import fastify from 'fastify';
+import { z } from 'zod';
+import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
+import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
 
 class Session {
   path;
@@ -2698,7 +2697,7 @@ async function claudeRemoteLauncher(session) {
 }
 
 async function loop(opts) {
-  const logPath = await logger.logFilePathPromise;
+  const logPath = logger.logFilePath;
   let session = new Session({
     api: opts.api,
     client: opts.session,
@@ -2743,133 +2742,6 @@ async function loop(opts) {
   }
 }
 
-var name = "happy-coder";
-var version = "0.9.0-6";
-var description = "Claude Code session sharing CLI";
-var author = "Kirill Dubovitskiy";
-var license = "MIT";
-var type = "module";
-var homepage = "https://github.com/slopus/happy-cli";
-var bugs = "https://github.com/slopus/happy-cli/issues";
-var repository = "slopus/happy-cli";
-var bin = {
-	happy: "./bin/happy.mjs"
-};
-var main = "./dist/index.cjs";
-var module = "./dist/index.mjs";
-var types = "./dist/index.d.cts";
-var exports = {
-	".": {
-		require: {
-			types: "./dist/index.d.cts",
-			"default": "./dist/index.cjs"
-		},
-		"import": {
-			types: "./dist/index.d.mts",
-			"default": "./dist/index.mjs"
-		}
-	},
-	"./lib": {
-		require: {
-			types: "./dist/lib.d.cts",
-			"default": "./dist/lib.cjs"
-		},
-		"import": {
-			types: "./dist/lib.d.mts",
-			"default": "./dist/lib.mjs"
-		}
-	}
-};
-var files = [
-	"dist",
-	"bin",
-	"scripts",
-	"ripgrep",
-	"package.json"
-];
-var scripts = {
-	"why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary - we don't want them to go out of sync or have custom spawn logic depending how we started happy",
-	typecheck: "tsc --noEmit",
-	build: "shx rm -rf dist && npx tsc --noEmit && pkgroll",
-	test: "yarn build && vitest run",
-	"test:watch": "vitest",
-	"test:integration-test-env": "yarn build && tsx --env-file .env.integration-test node_modules/.bin/vitest run",
-	dev: "yarn build && DEBUG=1 npx tsx src/index.ts",
-	"dev:local-server": "yarn build && tsx --env-file .env.dev-local-server src/index.ts",
-	"dev:integration-test-env": "yarn build && tsx --env-file .env.integration-test src/index.ts",
-	prepublishOnly: "yarn build && yarn test",
-	release: "release-it"
-};
-var dependencies = {
-	"@anthropic-ai/claude-code": "^1.0.89",
-	"@anthropic-ai/sdk": "^0.56.0",
-	"@modelcontextprotocol/sdk": "^1.15.1",
-	"@stablelib/base64": "^2.0.1",
-	"@types/http-proxy": "^1.17.16",
-	"@types/qrcode-terminal": "^0.12.2",
-	"@types/react": "^19.1.9",
-	axios: "^1.10.0",
-	chalk: "^5.4.1",
-	"expo-server-sdk": "^3.15.0",
-	fastify: "^5.5.0",
-	"fastify-type-provider-zod": "4.0.2",
-	"http-proxy": "^1.18.1",
-	"http-proxy-middleware": "^3.0.5",
-	ink: "^6.1.0",
-	open: "^10.2.0",
-	"qrcode-terminal": "^0.12.0",
-	react: "^19.1.1",
-	"socket.io-client": "^4.8.1",
-	tweetnacl: "^1.0.3",
-	zod: "^3.23.8"
-};
-var devDependencies = {
-	"@eslint/compat": "^1",
-	"@types/node": ">=20",
-	"cross-env": "^10.0.0",
-	eslint: "^9",
-	"eslint-config-prettier": "^10",
-	pkgroll: "^2.14.2",
-	"release-it": "^19.0.4",
-	shx: "^0.3.3",
-	"ts-node": "^10",
-	tsx: "^4.20.3",
-	typescript: "^5",
-	vitest: "^3.2.4"
-};
-var resolutions = {
-	"whatwg-url": "14.2.0",
-	"parse-path": "7.0.3",
-	"@types/parse-path": "7.0.3"
-};
-var publishConfig = {
-	registry: "https://registry.npmjs.org"
-};
-var packageManager = "yarn@1.22.22";
-var packageJson = {
-	name: name,
-	version: version,
-	description: description,
-	author: author,
-	license: license,
-	type: type,
-	homepage: homepage,
-	bugs: bugs,
-	repository: repository,
-	bin: bin,
-	main: main,
-	module: module,
-	types: types,
-	exports: exports,
-	files: files,
-	scripts: scripts,
-	dependencies: dependencies,
-	devDependencies: devDependencies,
-	resolutions: resolutions,
-	publishConfig: publishConfig,
-	packageManager: packageManager
-};
-
 function run(args, options) {
   const RUNNER_PATH = resolve$1(join$1(projectPath(), "scripts", "ripgrep_launcher.cjs"));
   return new Promise((resolve2, reject) => {
@@ -3129,129 +3001,6 @@ function registerHandlers(session) {
   });
 }
 
-const defaultSettings = {
-  onboardingCompleted: false
-};
-async function readSettings() {
-  if (!existsSync(configuration.settingsFile)) {
-    return { ...defaultSettings };
-  }
-  try {
-    const content = await readFile(configuration.settingsFile, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return { ...defaultSettings };
-  }
-}
-async function updateSettings(updater) {
-  const LOCK_RETRY_INTERVAL_MS = 100;
-  const MAX_LOCK_ATTEMPTS = 50;
-  const STALE_LOCK_TIMEOUT_MS = 1e4;
-  const lockFile = configuration.settingsFile + ".lock";
-  const tmpFile = configuration.settingsFile + ".tmp";
-  let fileHandle;
-  let attempts = 0;
-  while (attempts < MAX_LOCK_ATTEMPTS) {
-    try {
-      fileHandle = await open(lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
-      break;
-    } catch (err) {
-      if (err.code === "EEXIST") {
-        attempts++;
-        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
-        try {
-          const stats = await stat$1(lockFile);
-          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
-            await unlink(lockFile).catch(() => {
-            });
-          }
-        } catch {
-        }
-      } else {
-        throw err;
-      }
-    }
-  }
-  if (!fileHandle) {
-    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
-  }
-  try {
-    const current = await readSettings() || { ...defaultSettings };
-    const updated = await updater(current);
-    if (!existsSync(configuration.happyHomeDir)) {
-      await mkdir(configuration.happyHomeDir, { recursive: true });
-    }
-    await writeFile$1(tmpFile, JSON.stringify(updated, null, 2));
-    await rename(tmpFile, configuration.settingsFile);
-    return updated;
-  } finally {
-    await fileHandle.close();
-    await unlink(lockFile).catch(() => {
-    });
-  }
-}
-const credentialsSchema = z.object({
-  secret: z.string().base64(),
-  token: z.string()
-});
-async function readCredentials() {
-  if (!existsSync(configuration.privateKeyFile)) {
-    return null;
-  }
-  try {
-    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
-    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
-    return {
-      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
-      token: credentials.token
-    };
-  } catch {
-    return null;
-  }
-}
-async function writeCredentials(credentials) {
-  if (!existsSync(configuration.happyHomeDir)) {
-    await mkdir(configuration.happyHomeDir, { recursive: true });
-  }
-  await writeFile$1(configuration.privateKeyFile, JSON.stringify({
-    secret: encodeBase64(credentials.secret),
-    token: credentials.token
-  }, null, 2));
-}
-async function clearCredentials() {
-  if (existsSync(configuration.privateKeyFile)) {
-    await unlink(configuration.privateKeyFile);
-  }
-}
-async function clearMachineId() {
-  await updateSettings((settings) => ({
-    ...settings,
-    machineId: void 0
-  }));
-}
-async function readDaemonState() {
-  try {
-    if (!existsSync(configuration.daemonStateFile)) {
-      return null;
-    }
-    const content = await readFile(configuration.daemonStateFile, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    return null;
-  }
-}
-async function writeDaemonState(state) {
-  if (!existsSync(configuration.happyHomeDir)) {
-    await mkdir(configuration.happyHomeDir, { recursive: true });
-  }
-  await writeFile$1(configuration.daemonStateFile, JSON.stringify(state, null, 2));
-}
-async function clearDaemonState() {
-  if (existsSync(configuration.daemonStateFile)) {
-    await unlink(configuration.daemonStateFile);
-  }
-}
-
 class MessageQueue2 {
   queue = [];
   // Made public for testing
@@ -3619,8 +3368,9 @@ function startCaffeinate() {
   }
 }
 let isStopping = false;
-function stopCaffeinate() {
+async function stopCaffeinate() {
   if (isStopping) {
+    logger.debug("[caffeinate] Already stopping, skipping");
     return;
   }
   if (caffeinateProcess && !caffeinateProcess.killed) {
@@ -3628,14 +3378,13 @@ function stopCaffeinate() {
     logger.debug(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
     try {
       caffeinateProcess.kill("SIGTERM");
-      setTimeout(() => {
-        if (caffeinateProcess && !caffeinateProcess.killed) {
-          logger.debug("[caffeinate] Force killing caffeinate process");
-          caffeinateProcess.kill("SIGKILL");
-        }
-        caffeinateProcess = null;
-        isStopping = false;
-      }, 1e3);
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      if (caffeinateProcess && !caffeinateProcess.killed) {
+        logger.debug("[caffeinate] Force killing caffeinate process");
+        caffeinateProcess.kill("SIGKILL");
+      }
+      caffeinateProcess = null;
+      isStopping = false;
     } catch (error) {
       logger.debug("[caffeinate] Error stopping caffeinate:", error);
       isStopping = false;
@@ -3659,12 +3408,10 @@ function setupCleanupHandlers() {
   process.on("uncaughtException", (error) => {
     logger.debug("[caffeinate] Uncaught exception, cleaning up:", error);
     cleanup();
-    process.exit(1);
   });
   process.on("unhandledRejection", (reason, promise) => {
     logger.debug("[caffeinate] Unhandled rejection, cleaning up:", reason);
     cleanup();
-    process.exit(1);
   });
 }
 
@@ -3713,37 +3460,97 @@ function extractSDKMetadataAsync(onComplete) {
   });
 }
 
-async function isDaemonRunning() {
+async function daemonPost(path, body) {
+  const state = await readDaemonState();
+  if (!state?.httpPort) {
+    const errorMessage = "No daemon running, no state file found";
+    logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
   try {
-    const state = await getDaemonState();
-    if (!state) {
-      return false;
-    }
-    const isRunning = await isDaemonProcessRunning(state.pid);
-    if (!isRunning) {
-      logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
-      await cleanupDaemonState();
-      return false;
-    }
-    return true;
+    process.kill(state.pid, 0);
   } catch (error) {
-    logger.debug("[DAEMON RUN] Error checking daemon status", error);
-    return false;
+    const errorMessage = "Daemon is not running, file is stale";
+    logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
   }
-}
-async function getDaemonState() {
   try {
-    return await readDaemonState();
+    const timeout = process.env.HAPPY_DAEMON_HTTP_TIMEOUT ? parseInt(process.env.HAPPY_DAEMON_HTTP_TIMEOUT) : 1e4;
+    const response = await fetch(`http://127.0.0.1:${state.httpPort}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body || {}),
+      // Mostly increased for stress test
+      signal: AbortSignal.timeout(timeout)
+    });
+    if (!response.ok) {
+      const errorMessage = `Request failed: ${path}, HTTP ${response.status}`;
+      logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+      return {
+        error: errorMessage
+      };
+    }
+    return await response.json();
   } catch (error) {
-    logger.debug("[DAEMON RUN] Error reading daemon metadata", error);
-    return null;
+    const errorMessage = `Request failed: ${path}, ${error instanceof Error ? error.message : "Unknown error"}`;
+    logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
   }
 }
-async function isDaemonProcessRunning(pid) {
+async function notifyDaemonSessionStarted(sessionId, metadata) {
+  return await daemonPost("/session-started", {
+    sessionId,
+    metadata
+  });
+}
+async function listDaemonSessions() {
+  const result = await daemonPost("/list");
+  return result.children || [];
+}
+async function stopDaemonSession(sessionId) {
+  const result = await daemonPost("/stop-session", { sessionId });
+  return result.success || false;
+}
+async function stopDaemonHttp() {
+  await daemonPost("/stop");
+}
+async function checkIfDaemonRunningAndCleanupStaleState() {
+  const state = await readDaemonState();
+  if (!state) {
+    return false;
+  }
   try {
-    process.kill(pid, 0);
+    process.kill(state.pid, 0);
     return true;
   } catch {
+    logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+}
+async function isDaemonRunningSameVersion() {
+  logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
+  if (!runningDaemon) {
+    logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    return false;
+  }
+  const state = await readDaemonState();
+  if (!state) {
+    logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  try {
+    logger.debug(`[DAEMON CONTROL] Current CLI version: ${configuration.currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+    return configuration.currentCliVersion === state.startedWithCliVersion;
+  } catch (error) {
+    logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
     return false;
   }
 }
@@ -3755,47 +3562,102 @@ async function cleanupDaemonState() {
     logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
   }
 }
+async function stopDaemon() {
+  try {
+    const state = await readDaemonState();
+    if (!state) {
+      logger.debug("No daemon state found");
+      return;
+    }
+    logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 2e3);
+      logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      logger.debug("Force killed daemon");
+    } catch (error) {
+      logger.debug("Daemon already dead");
+    }
+  } catch (error) {
+    logger.debug("Error stopping daemon", error);
+  }
+}
+async function waitForProcessDeath(pid, timeout) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } catch {
+      return;
+    }
+  }
+  throw new Error("Process did not die within timeout");
+}
+
 function findAllHappyProcesses() {
   try {
-    const output = execSync('ps aux | grep "happy.mjs" | grep -v grep', { encoding: "utf8" });
-    const lines = output.trim().split("\n").filter((line) => line.trim());
     const allProcesses = [];
-    for (const line of lines) {
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 11) continue;
-      const pid = parseInt(parts[1]);
-      const command = parts.slice(10).join(" ");
-      let type = "unknown";
-      if (pid === process.pid) {
-        type = "current";
-      } else if (command.includes("daemon start-sync") || command.includes("daemon start")) {
-        type = "daemon";
-      } else if (command.includes("--started-by daemon")) {
-        type = "daemon-spawned-session";
-      } else if (command.includes("doctor")) {
-        type = "doctor";
-      } else {
-        type = "user-session";
+    try {
+      const happyOutput = execSync('ps aux | grep -E "(happy\\.mjs|happy-coder|happy-cli.*dist/index\\.mjs)" | grep -v grep', { encoding: "utf8" });
+      const happyLines = happyOutput.trim().split("\n").filter((line) => line.trim());
+      for (const line of happyLines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 11) continue;
+        const pid = parseInt(parts[1]);
+        const command = parts.slice(10).join(" ");
+        let type = "unknown";
+        if (pid === process.pid) {
+          type = "current";
+        } else if (command.includes("--version")) {
+          type = "daemon-version-check";
+        } else if (command.includes("daemon start-sync") || command.includes("daemon start")) {
+          type = "daemon";
+        } else if (command.includes("--started-by daemon")) {
+          type = "daemon-spawned-session";
+        } else if (command.includes("doctor")) {
+          type = "doctor";
+        } else {
+          type = "user-session";
+        }
+        allProcesses.push({ pid, command, type });
       }
-      allProcesses.push({ pid, command, type });
+    } catch {
     }
     try {
-      const devOutput = execSync('ps aux | grep -E "(tsx.*src/index.ts|yarn.*tsx)" | grep -v grep', { encoding: "utf8" });
+      const devOutput = execSync('ps aux | grep -E "tsx.*src/index\\.ts" | grep -v grep', { encoding: "utf8" });
       const devLines = devOutput.trim().split("\n").filter((line) => line.trim());
       for (const line of devLines) {
         const parts = line.trim().split(/\s+/);
         if (parts.length < 11) continue;
         const pid = parseInt(parts[1]);
         const command = parts.slice(10).join(" ");
-        let workingDir = "";
-        try {
-          const pwdOutput = execSync(`pwdx ${pid} 2>/dev/null`, { encoding: "utf8" });
-          workingDir = pwdOutput.replace(`${pid}:`, "").trim();
-        } catch {
+        if (!command.includes("happy-cli/node_modules/tsx") && !command.includes("/bin/tsx src/index.ts")) {
+          continue;
         }
-        if (workingDir.includes("happy-cli")) {
-          allProcesses.push({ pid, command, type: "dev-session" });
+        let type = "unknown";
+        if (pid === process.pid) {
+          type = "current";
+        } else if (command.includes("--version")) {
+          type = "dev-daemon-version-check";
+        } else if (command.includes("daemon start-sync") || command.includes("daemon start")) {
+          type = "dev-daemon";
+        } else if (command.includes("--started-by daemon")) {
+          type = "dev-daemon-spawned";
+        } else if (command.includes("doctor")) {
+          type = "dev-doctor";
+        } else if (command.includes("--yolo")) {
+          type = "dev-session";
+        } else {
+          type = "dev-related";
         }
+        allProcesses.push({ pid, command, type });
       }
     } catch {
     }
@@ -3806,18 +3668,39 @@ function findAllHappyProcesses() {
 }
 function findRunawayHappyProcesses() {
   try {
-    const output = execSync('ps aux | grep "happy.mjs" | grep -v grep', { encoding: "utf8" });
-    const lines = output.trim().split("\n").filter((line) => line.trim());
     const processes = [];
-    for (const line of lines) {
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 11) continue;
-      const pid = parseInt(parts[1]);
-      const command = parts.slice(10).join(" ");
-      if (pid === process.pid) continue;
-      if (command.includes("--started-by daemon") || command.includes("daemon start-sync") || command.includes("daemon start")) {
-        processes.push({ pid, command });
+    try {
+      const output = execSync('ps aux | grep -E "(happy\\.mjs|happy-coder|happy-cli.*dist/index\\.mjs)" | grep -v grep', { encoding: "utf8" });
+      const lines = output.trim().split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 11) continue;
+        const pid = parseInt(parts[1]);
+        const command = parts.slice(10).join(" ");
+        if (pid === process.pid) continue;
+        if (command.includes("--started-by daemon") || command.includes("daemon start-sync") || command.includes("daemon start") || command.includes("--version")) {
+          processes.push({ pid, command });
+        }
+      }
+    } catch {
+    }
+    try {
+      const devOutput = execSync('ps aux | grep -E "tsx.*src/index\\.ts" | grep -v grep', { encoding: "utf8" });
+      const devLines = devOutput.trim().split("\n").filter((line) => line.trim());
+      for (const line of devLines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 11) continue;
+        const pid = parseInt(parts[1]);
+        const command = parts.slice(10).join(" ");
+        if (pid === process.pid) continue;
+        if (!command.includes("happy-cli/node_modules/tsx") && !command.includes("/bin/tsx src/index.ts")) {
+          continue;
+        }
+        if (command.includes("--started-by daemon") || command.includes("daemon start-sync") || command.includes("daemon start") || command.includes("--version")) {
+          processes.push({ pid, command });
+        }
       }
+    } catch {
     }
     return processes;
   } catch (error) {
@@ -3827,10 +3710,10 @@ function findRunawayHappyProcesses() {
 async function killRunawayHappyProcesses() {
   const runawayProcesses = findRunawayHappyProcesses();
   const errors = [];
-  let killed = 0;
-  for (const { pid, command } of runawayProcesses) {
+  const killPromises = runawayProcesses.map(async ({ pid, command }) => {
     try {
       process.kill(pid, "SIGTERM");
+      console.log(`Sent SIGTERM to runaway process PID ${pid}: ${command}`);
       await new Promise((resolve) => setTimeout(resolve, 1e3));
       try {
         process.kill(pid, 0);
@@ -3838,66 +3721,19 @@ async function killRunawayHappyProcesses() {
         process.kill(pid, "SIGKILL");
       } catch {
       }
-      killed++;
-      console.log(`Killed runaway process PID ${pid}: ${command}`);
+      console.log(`Successfully killed runaway process PID ${pid}`);
+      return { success: true, pid, command };
     } catch (error) {
-      errors.push({ pid, error: error.message });
+      const errorMessage = error.message;
+      errors.push({ pid, error: errorMessage });
+      console.log(`Failed to kill process PID ${pid}: ${errorMessage}`);
+      return { success: false, pid, command };
     }
-  }
+  });
+  const results = await Promise.all(killPromises);
+  const killed = results.filter((r) => r.success).length;
   return { killed, errors };
 }
-async function stopDaemon() {
-  try {
-    stopCaffeinate();
-    logger.debug("Stopped sleep prevention");
-    const state = await getDaemonState();
-    if (!state) {
-      logger.debug("No daemon state found");
-      return;
-    }
-    logger.debug(`Stopping daemon with PID ${state.pid}`);
-    try {
-      const { stopDaemonHttp } = await Promise.resolve().then(function () { return controlClient; });
-      await stopDaemonHttp();
-      await waitForProcessDeath(state.pid, 5e3);
-      logger.debug("Daemon stopped gracefully via HTTP");
-      return;
-    } catch (error) {
-      logger.debug("HTTP stop failed, will force kill", error);
-    }
-    try {
-      process.kill(state.pid, "SIGKILL");
-      logger.debug("Force killed daemon");
-    } catch (error) {
-      logger.debug("Daemon already dead");
-    }
-  } catch (error) {
-    logger.debug("Error stopping daemon", error);
-  }
-}
-async function waitForProcessDeath(pid, timeout) {
-  const start = Date.now();
-  while (Date.now() - start < timeout) {
-    try {
-      process.kill(pid, 0);
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    } catch {
-      return;
-    }
-  }
-  throw new Error("Process did not die within timeout");
-}
-
-var utils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    cleanupDaemonState: cleanupDaemonState,
-    findAllHappyProcesses: findAllHappyProcesses,
-    findRunawayHappyProcesses: findRunawayHappyProcesses,
-    getDaemonState: getDaemonState,
-    isDaemonRunning: isDaemonRunning,
-    killRunawayHappyProcesses: killRunawayHappyProcesses,
-    stopDaemon: stopDaemon
-});
 
 function getEnvironmentInfo() {
   return {
@@ -3912,7 +3748,15 @@ function getEnvironmentInfo() {
     processArgv: process.argv,
     happyDir: configuration?.happyHomeDir,
     serverUrl: configuration?.serverUrl,
-    logsDir: configuration?.logsDir
+    logsDir: configuration?.logsDir,
+    processPid: process.pid,
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    user: process.env.USER,
+    home: process.env.HOME,
+    shell: process.env.SHELL,
+    terminal: process.env.TERM
   };
 }
 function getLogFiles(logDir) {
@@ -3924,62 +3768,67 @@ function getLogFiles(logDir) {
       const path = join(logDir, file);
       const stats = statSync(path);
       return { file, path, modified: stats.mtime };
-    }).sort((a, b) => b.modified.getTime() - a.modified.getTime()).slice(0, 10);
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
   } catch {
     return [];
   }
 }
-async function runDoctorCommand() {
-  console.log(chalk.bold.cyan("\n\u{1FA7A} Happy CLI Doctor\n"));
-  console.log(chalk.bold("\u{1F4CB} Basic Information"));
-  console.log(`Happy CLI Version: ${chalk.green(packageJson.version)}`);
-  console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
-  console.log(`Node.js Version: ${chalk.green(process.version)}`);
-  console.log("");
-  console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
-  const projectRoot = projectPath();
-  const wrapperPath = join(projectRoot, "bin", "happy.mjs");
-  const cliEntrypoint = join(projectRoot, "dist", "index.mjs");
-  console.log(`Project Root: ${chalk.blue(projectRoot)}`);
-  console.log(`Wrapper Script: ${chalk.blue(wrapperPath)}`);
-  console.log(`CLI Entrypoint: ${chalk.blue(cliEntrypoint)}`);
-  console.log(`Wrapper Exists: ${existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
-  console.log(`CLI Exists: ${existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
-  console.log("");
-  console.log(chalk.bold("\u2699\uFE0F  Configuration"));
-  console.log(`Happy Home: ${chalk.blue(configuration.happyHomeDir)}`);
-  console.log(`Server URL: ${chalk.blue(configuration.serverUrl)}`);
-  console.log(`Logs Dir: ${chalk.blue(configuration.logsDir)}`);
-  console.log(chalk.bold("\n\u{1F30D} Environment Variables"));
-  const env = getEnvironmentInfo();
-  console.log(`HAPPY_HOME_DIR: ${env.HAPPY_HOME_DIR ? chalk.green(env.HAPPY_HOME_DIR) : chalk.gray("not set")}`);
-  console.log(`HAPPY_SERVER_URL: ${env.HAPPY_SERVER_URL ? chalk.green(env.HAPPY_SERVER_URL) : chalk.gray("not set")}`);
-  console.log(`DANGEROUSLY_LOG_TO_SERVER: ${env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING ? chalk.yellow("ENABLED") : chalk.gray("not set")}`);
-  console.log(`DEBUG: ${env.DEBUG ? chalk.green(env.DEBUG) : chalk.gray("not set")}`);
-  console.log(`NODE_ENV: ${env.NODE_ENV ? chalk.green(env.NODE_ENV) : chalk.gray("not set")}`);
-  try {
-    const settings = await readSettings();
-    console.log(chalk.bold("\n\u{1F4C4} Settings (settings.json):"));
-    console.log(chalk.gray(JSON.stringify(settings, null, 2)));
-  } catch (error) {
-    console.log(chalk.bold("\n\u{1F4C4} Settings:"));
-    console.log(chalk.red("\u274C Failed to read settings"));
+async function runDoctorCommand(filter) {
+  if (!filter) {
+    filter = "all";
   }
-  console.log(chalk.bold("\n\u{1F510} Authentication"));
-  try {
-    const credentials = await readCredentials();
-    if (credentials) {
-      console.log(chalk.green("\u2713 Authenticated (credentials found)"));
-    } else {
-      console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated (no credentials)"));
+  console.log(chalk.bold.cyan("\n\u{1FA7A} Happy CLI Doctor\n"));
+  if (filter === "all") {
+    console.log(chalk.bold("\u{1F4CB} Basic Information"));
+    console.log(`Happy CLI Version: ${chalk.green(packageJson.version)}`);
+    console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
+    console.log(`Node.js Version: ${chalk.green(process.version)}`);
+    console.log("");
+    console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
+    const projectRoot = projectPath();
+    const wrapperPath = join(projectRoot, "bin", "happy.mjs");
+    const cliEntrypoint = join(projectRoot, "dist", "index.mjs");
+    console.log(`Project Root: ${chalk.blue(projectRoot)}`);
+    console.log(`Wrapper Script: ${chalk.blue(wrapperPath)}`);
+    console.log(`CLI Entrypoint: ${chalk.blue(cliEntrypoint)}`);
+    console.log(`Wrapper Exists: ${existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log(`CLI Exists: ${existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log("");
+    console.log(chalk.bold("\u2699\uFE0F  Configuration"));
+    console.log(`Happy Home: ${chalk.blue(configuration.happyHomeDir)}`);
+    console.log(`Server URL: ${chalk.blue(configuration.serverUrl)}`);
+    console.log(`Logs Dir: ${chalk.blue(configuration.logsDir)}`);
+    console.log(chalk.bold("\n\u{1F30D} Environment Variables"));
+    const env = getEnvironmentInfo();
+    console.log(`HAPPY_HOME_DIR: ${env.HAPPY_HOME_DIR ? chalk.green(env.HAPPY_HOME_DIR) : chalk.gray("not set")}`);
+    console.log(`HAPPY_SERVER_URL: ${env.HAPPY_SERVER_URL ? chalk.green(env.HAPPY_SERVER_URL) : chalk.gray("not set")}`);
+    console.log(`DANGEROUSLY_LOG_TO_SERVER: ${env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING ? chalk.yellow("ENABLED") : chalk.gray("not set")}`);
+    console.log(`DEBUG: ${env.DEBUG ? chalk.green(env.DEBUG) : chalk.gray("not set")}`);
+    console.log(`NODE_ENV: ${env.NODE_ENV ? chalk.green(env.NODE_ENV) : chalk.gray("not set")}`);
+    try {
+      const settings = await readSettings();
+      console.log(chalk.bold("\n\u{1F4C4} Settings (settings.json):"));
+      console.log(chalk.gray(JSON.stringify(settings, null, 2)));
+    } catch (error) {
+      console.log(chalk.bold("\n\u{1F4C4} Settings:"));
+      console.log(chalk.red("\u274C Failed to read settings"));
     }
-  } catch (error) {
-    console.log(chalk.red("\u274C Error reading credentials"));
-  }
-  console.log(chalk.bold("\n\u{1F916} Daemon Status"));
+    console.log(chalk.bold("\n\u{1F510} Authentication"));
+    try {
+      const credentials = await readCredentials();
+      if (credentials) {
+        console.log(chalk.green("\u2713 Authenticated (credentials found)"));
+      } else {
+        console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated (no credentials)"));
+      }
+    } catch (error) {
+      console.log(chalk.red("\u274C Error reading credentials"));
+    }
+  }
+  console.log(chalk.bold("\n\u{1F916} Daemon Status"));
   try {
-    const isRunning = await isDaemonRunning();
-    const state = await getDaemonState();
+    const isRunning = await checkIfDaemonRunningAndCleanupStaleState();
+    const state = await readDaemonState();
     if (isRunning && state) {
       console.log(chalk.green("\u2713 Daemon is running"));
       console.log(`  PID: ${state.pid}`);
@@ -4010,9 +3859,11 @@ async function runDoctorCommand() {
         const typeLabels = {
           "current": "\u{1F4CD} Current Process",
           "daemon": "\u{1F916} Daemon",
+          "daemon-version-check": "\u{1F50D} Daemon Version Check (stuck)",
           "daemon-spawned-session": "\u{1F517} Daemon-Spawned Sessions",
           "user-session": "\u{1F464} User Sessions",
           "dev-daemon": "\u{1F6E0}\uFE0F  Dev Daemon",
+          "dev-daemon-version-check": "\u{1F6E0}\uFE0F  Dev Daemon Version Check (stuck)",
           "dev-session": "\u{1F6E0}\uFE0F  Dev Sessions",
           "dev-doctor": "\u{1F6E0}\uFE0F  Dev Doctor",
           "dev-related": "\u{1F6E0}\uFE0F  Dev Related",
@@ -4026,190 +3877,54 @@ ${typeLabels[type] || type}:`));
           console.log(`  ${color(`PID ${pid}`)}: ${chalk.gray(command)}`);
         });
       });
+    } else {
+      console.log(chalk.red("\u274C No happy processes found"));
     }
-    const runawayProcesses = findRunawayHappyProcesses();
-    if (runawayProcesses.length > 0) {
-      console.log(chalk.bold("\n\u{1F6A8} Runaway Happy processes detected"));
-      console.log(chalk.gray("These processes were left running after daemon crashes."));
-      runawayProcesses.forEach(({ pid, command }) => {
-        console.log(`  ${chalk.yellow(`PID ${pid}`)}: ${chalk.gray(command)}`);
-      });
-      console.log(chalk.blue("\nTo clean up: happy daemon kill-runaway"));
-    }
-    if (allProcesses.length > 1) {
+    if (filter === "all" && allProcesses.length > 1) {
       console.log(chalk.bold("\n\u{1F4A1} Process Management"));
-      console.log(chalk.gray("To kill runaway processes: happy daemon kill-runaway"));
+      console.log(chalk.gray("To clean up runaway processes: happy doctor clean"));
     }
   } catch (error) {
     console.log(chalk.red("\u274C Error checking daemon status"));
   }
-  console.log(chalk.bold("\n\u{1F4DD} Log Files"));
-  const mainLogs = getLogFiles(configuration.logsDir);
-  if (mainLogs.length > 0) {
-    console.log(chalk.blue("\nMain Logs:"));
-    mainLogs.forEach(({ file, path, modified }) => {
-      console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
-      console.log(chalk.gray(`    ${path}`));
-    });
-  } else {
-    console.log(chalk.yellow("No main log files found"));
-  }
-  const daemonLogs = mainLogs.filter(({ file }) => file.includes("daemon"));
-  if (daemonLogs.length > 0) {
-    console.log(chalk.blue("\nDaemon Logs:"));
-    daemonLogs.forEach(({ file, path, modified }) => {
-      console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
-      console.log(chalk.gray(`    ${path}`));
-    });
-  } else {
-    console.log(chalk.yellow("No daemon log files found"));
-  }
-  console.log(chalk.bold("\n\u{1F41B} Support & Bug Reports"));
-  console.log(`Report issues: ${chalk.blue("https://github.com/slopus/happy-cli/issues")}`);
-  console.log(`Documentation: ${chalk.blue("https://happy.engineering/")}`);
-  console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
-}
-
-async function daemonPost(path, body) {
-  const state = await getDaemonState();
-  if (!state?.httpPort) {
-    throw new Error("No daemon running");
-  }
-  try {
-    const response = await fetch(`http://127.0.0.1:${state.httpPort}${path}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body || {}),
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-    return await response.json();
-  } catch (error) {
-    logger.debug(`[CONTROL CLIENT] Request failed: ${path}`, error);
-    throw error;
-  }
-}
-async function notifyDaemonSessionStarted(sessionId, metadata) {
-  await daemonPost("/session-started", {
-    sessionId,
-    metadata
-  });
-}
-async function listDaemonSessions() {
-  const result = await daemonPost("/list");
-  return result.children || [];
-}
-async function stopDaemonSession(sessionId) {
-  const result = await daemonPost("/stop-session", { sessionId });
-  return result.success || false;
-}
-async function stopDaemonHttp() {
-  await daemonPost("/stop");
-}
-
-var controlClient = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    listDaemonSessions: listDaemonSessions,
-    notifyDaemonSessionStarted: notifyDaemonSessionStarted,
-    stopDaemonHttp: stopDaemonHttp,
-    stopDaemonSession: stopDaemonSession
-});
-
-function startDaemonControlServer({
-  getChildren,
-  stopSession,
-  spawnSession,
-  requestShutdown,
-  onHappySessionWebhook
-}) {
-  return new Promise((resolve) => {
-    const app = fastify({
-      logger: false
-      // We use our own logger
-    });
-    app.setValidatorCompiler(validatorCompiler);
-    app.setSerializerCompiler(serializerCompiler);
-    const typed = app.withTypeProvider();
-    typed.post("/session-started", {
-      schema: {
-        body: z$1.object({
-          sessionId: z$1.string(),
-          metadata: z$1.any()
-          // Metadata type from API
-        })
-      }
-    }, async (request, reply) => {
-      const { sessionId, metadata } = request.body;
-      logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
-      onHappySessionWebhook(sessionId, metadata);
-      return { status: "ok" };
-    });
-    typed.post("/list", async (request, reply) => {
-      const children = getChildren();
-      logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
-      return { children };
-    });
-    typed.post("/stop-session", {
-      schema: {
-        body: z$1.object({
-          sessionId: z$1.string()
-        })
-      }
-    }, async (request, reply) => {
-      const { sessionId } = request.body;
-      logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
-      const success = stopSession(sessionId);
-      return { success };
-    });
-    typed.post("/spawn-session", {
-      schema: {
-        body: z$1.object({
-          directory: z$1.string(),
-          sessionId: z$1.string().optional()
-        })
+  if (filter === "all") {
+    console.log(chalk.bold("\n\u{1F4DD} Log Files"));
+    const allLogs = getLogFiles(configuration.logsDir);
+    if (allLogs.length > 0) {
+      const daemonLogs = allLogs.filter(({ file }) => file.includes("daemon"));
+      const regularLogs = allLogs.filter(({ file }) => !file.includes("daemon"));
+      if (regularLogs.length > 0) {
+        console.log(chalk.blue("\nRecent Logs:"));
+        const logsToShow = regularLogs.slice(0, 10);
+        logsToShow.forEach(({ file, path, modified }) => {
+          console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
+          console.log(chalk.gray(`    ${path}`));
+        });
+        if (regularLogs.length > 10) {
+          console.log(chalk.gray(`  ... and ${regularLogs.length - 10} more log files`));
+        }
       }
-    }, async (request, reply) => {
-      const { directory, sessionId } = request.body;
-      logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}`);
-      const session = await spawnSession(directory, sessionId);
-      if (session) {
-        return {
-          success: true,
-          pid: session.pid,
-          sessionId: session.happySessionId || "pending"
-        };
+      if (daemonLogs.length > 0) {
+        console.log(chalk.blue("\nDaemon Logs:"));
+        const daemonLogsToShow = daemonLogs.slice(0, 5);
+        daemonLogsToShow.forEach(({ file, path, modified }) => {
+          console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
+          console.log(chalk.gray(`    ${path}`));
+        });
+        if (daemonLogs.length > 5) {
+          console.log(chalk.gray(`  ... and ${daemonLogs.length - 5} more daemon log files`));
+        }
       } else {
-        reply.code(500);
-        return { error: "Failed to spawn session" };
+        console.log(chalk.yellow("\nNo daemon log files found"));
       }
-    });
-    typed.post("/stop", async (request, reply) => {
-      logger.debug("[CONTROL SERVER] Stop daemon request received");
-      setTimeout(() => {
-        logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
-        requestShutdown();
-      }, 50);
-      return { status: "stopping" };
-    });
-    app.listen({ port: 0, host: "127.0.0.1" }, (err, address) => {
-      if (err) {
-        logger.debug("[CONTROL SERVER] Failed to start:", err);
-        throw err;
-      }
-      const port = parseInt(address.split(":").pop());
-      logger.debug(`[CONTROL SERVER] Started on port ${port}`);
-      resolve({
-        port,
-        stop: async () => {
-          logger.debug("[CONTROL SERVER] Stopping server");
-          await app.close();
-          logger.debug("[CONTROL SERVER] Server stopped");
-        }
-      });
-    });
-  });
+    } else {
+      console.log(chalk.yellow("No log files found"));
+    }
+    console.log(chalk.bold("\n\u{1F41B} Support & Bug Reports"));
+    console.log(`Report issues: ${chalk.blue("https://github.com/slopus/happy-cli/issues")}`);
+    console.log(`Documentation: ${chalk.blue("https://happy.engineering/")}`);
+  }
+  console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
 }
 
 function displayQRCode(url) {
@@ -4236,7 +3951,7 @@ async function openBrowser(url) {
       return false;
     }
     logger.debug(`[browser] Attempting to open URL: ${url}`);
-    await open$1(url);
+    await open(url);
     logger.debug("[browser] Browser opened successfully");
     return true;
   } catch (error) {
@@ -4452,16 +4167,140 @@ function spawnHappyCLI(args, options = {}) {
     directory = process.cwd();
   }
   const fullCommand = `happy ${args.join(" ")}`;
-  logger.debug(`[DAEMON RUN] Spawning: ${fullCommand} in ${directory}`);
+  logger.debug(`[SPAWN HAPPY CLI] Spawning: ${fullCommand} in ${directory}`);
   const nodeArgs = [
     "--no-warnings",
     "--no-deprecation",
     entrypoint,
     ...args
   ];
+  if (!existsSync(entrypoint)) {
+    const errorMessage = `Entrypoint ${entrypoint} does not exist`;
+    logger.debug(`[SPAWN HAPPY CLI] ${errorMessage}`);
+    throw new Error(errorMessage);
+  }
   return spawn$1("node", nodeArgs, options);
 }
 
+function startDaemonControlServer({
+  getChildren,
+  stopSession,
+  spawnSession,
+  requestShutdown,
+  onHappySessionWebhook
+}) {
+  return new Promise((resolve) => {
+    const app = fastify({
+      logger: false
+      // We use our own logger
+    });
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+    const typed = app.withTypeProvider();
+    typed.post("/session-started", {
+      schema: {
+        body: z.object({
+          sessionId: z.string(),
+          metadata: z.any()
+          // Metadata type from API
+        })
+      }
+    }, async (request, reply) => {
+      const { sessionId, metadata } = request.body;
+      logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
+      onHappySessionWebhook(sessionId, metadata);
+      return { status: "ok" };
+    });
+    typed.post("/list", async (request, reply) => {
+      const children = getChildren();
+      logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
+      return {
+        children: children.map((child) => {
+          delete child.childProcess;
+          return child;
+        })
+      };
+    });
+    typed.post("/stop-session", {
+      schema: {
+        body: z.object({
+          sessionId: z.string()
+        })
+      }
+    }, async (request, reply) => {
+      const { sessionId } = request.body;
+      logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
+      const success = stopSession(sessionId);
+      return { success };
+    });
+    typed.post("/spawn-session", {
+      schema: {
+        body: z.object({
+          directory: z.string(),
+          sessionId: z.string().optional()
+        })
+      }
+    }, async (request, reply) => {
+      const { directory, sessionId } = request.body;
+      logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}`);
+      const session = await spawnSession(directory, sessionId);
+      if (session) {
+        return {
+          success: true,
+          pid: session.pid,
+          sessionId: session.happySessionId || "pending",
+          message: session.message
+        };
+      } else {
+        reply.code(500);
+        return {
+          success: false,
+          error: "Failed to spawn session. Check the directory path and permissions."
+        };
+      }
+    });
+    typed.post("/stop", async (request, reply) => {
+      logger.debug("[CONTROL SERVER] Stop daemon request received");
+      setTimeout(() => {
+        logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
+        requestShutdown();
+      }, 50);
+      return { status: "stopping" };
+    });
+    typed.post("/dev-simulate-error", {
+      schema: {
+        body: z.object({
+          error: z.string()
+        })
+      }
+    }, async (request, reply) => {
+      const { error } = request.body;
+      logger.debug(`[CONTROL SERVER] Dev: Simulating error: ${error}`);
+      setTimeout(() => {
+        logger.debug(`[CONTROL SERVER] Dev: Throwing simulated error now`);
+        throw new Error(error);
+      }, 100);
+      return { status: "error will be thrown" };
+    });
+    app.listen({ port: 0, host: "127.0.0.1" }, (err, address) => {
+      if (err) {
+        logger.debug("[CONTROL SERVER] Failed to start:", err);
+        throw err;
+      }
+      const port = parseInt(address.split(":").pop());
+      logger.debug(`[CONTROL SERVER] Started on port ${port}`);
+      resolve({
+        port,
+        stop: async () => {
+          logger.debug("[CONTROL SERVER] Stopping server");
+          await app.close();
+          logger.debug("[CONTROL SERVER] Server stopped");
+        }
+      });
+    });
+  });
+}
+
 const initialMachineMetadata = {
   host: os.hostname(),
   platform: os.platform(),
@@ -4470,37 +4309,79 @@ const initialMachineMetadata = {
   happyHomeDir: configuration.happyHomeDir
 };
 async function startDaemon() {
+  let requestShutdown;
+  let resolvesWhenShutdownRequested = new Promise((resolve2) => {
+    requestShutdown = (source, errorMessage) => {
+      logger.debug(`[DAEMON RUN] Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
+      setTimeout(async () => {
+        logger.debug("[DAEMON RUN] Startup malfunctioned, forcing exit with code 1");
+        await new Promise((resolve3) => setTimeout(resolve3, 100));
+        process.exit(1);
+      }, 1e3);
+      resolve2({ source, errorMessage });
+    };
+  });
+  process.on("SIGINT", () => {
+    logger.debug("[DAEMON RUN] Received SIGINT");
+    requestShutdown("os-signal");
+  });
+  process.on("SIGTERM", () => {
+    logger.debug("[DAEMON RUN] Received SIGTERM");
+    requestShutdown("os-signal");
+  });
+  process.on("uncaughtException", (error) => {
+    logger.debug("[DAEMON RUN] FATAL: Uncaught exception", error);
+    logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  process.on("unhandledRejection", (reason, promise) => {
+    logger.debug("[DAEMON RUN] FATAL: Unhandled promise rejection", reason);
+    logger.debug(`[DAEMON RUN] Rejected promise:`, promise);
+    const error = reason instanceof Error ? reason : new Error(`Unhandled promise rejection: ${reason}`);
+    logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  process.on("exit", (code) => {
+    logger.debug(`[DAEMON RUN] Process exiting with code: ${code}`);
+  });
+  process.on("beforeExit", (code) => {
+    logger.debug(`[DAEMON RUN] Process about to exit with code: ${code}`);
+  });
   logger.debug("[DAEMON RUN] Starting daemon process...");
   logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
-  const runningDaemon = await getDaemonState();
-  if (runningDaemon) {
-    try {
-      process.kill(runningDaemon.pid, 0);
-      logger.debug("[DAEMON RUN] Daemon already running");
-      console.log(`Daemon already running (PID: ${runningDaemon.pid})`);
-      process.exit(0);
-    } catch {
-      logger.debug("[DAEMON RUN] Stale state found, cleaning up");
-      await cleanupDaemonState();
-    }
+  const runningDaemonVersionMatches = await isDaemonRunningSameVersion();
+  if (!runningDaemonVersionMatches) {
+    logger.debug("[DAEMON RUN] Daemon version mismatch detected, restarting daemon with current CLI version");
+    await stopDaemon();
+  } else {
+    logger.debug("[DAEMON RUN] Daemon version matches, keeping existing daemon");
+    console.log("Daemon already running with matching version");
+    process.exit(0);
   }
-  const caffeinateStarted = startCaffeinate();
-  if (caffeinateStarted) {
-    logger.debug("[DAEMON RUN] Sleep prevention enabled");
+  const daemonLockHandle = await acquireDaemonLock(5, 200);
+  if (!daemonLockHandle) {
+    logger.debug("[DAEMON RUN] Daemon lock file already held, another daemon is running");
+    process.exit(0);
   }
   try {
+    const caffeinateStarted = startCaffeinate();
+    if (caffeinateStarted) {
+      logger.debug("[DAEMON RUN] Sleep prevention enabled");
+    }
     const { credentials, machineId } = await authAndSetupMachineIfNeeded();
     logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const pidToAwaiter = /* @__PURE__ */ new Map();
     const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
     const onHappySessionWebhook = (sessionId, sessionMetadata) => {
+      logger.debugLargeJson(`[DAEMON RUN] Session reported`, sessionMetadata);
       const pid = sessionMetadata.hostPid;
       if (!pid) {
-        logger.debug(`[DAEMON RUN] Session webhook missing hostPid for session ${sessionId}`);
+        logger.debug(`[DAEMON RUN] Session webhook missing hostPid for sessionId: ${sessionId}`);
         return;
       }
       logger.debug(`[DAEMON RUN] Session webhook: ${sessionId}, PID: ${pid}, started by: ${sessionMetadata.startedBy || "unknown"}`);
+      logger.debug(`[DAEMON RUN] Current tracked sessions before webhook: ${Array.from(pidToTrackedSession.keys()).join(", ")}`);
       const existingSession = pidToTrackedSession.get(pid);
       if (existingSession && existingSession.startedBy === "daemon") {
         existingSession.happySessionId = sessionId;
@@ -4524,8 +4405,37 @@ async function startDaemon() {
       }
     };
     const spawnSession = async (directory, sessionId) => {
+      let directoryCreated = false;
+      if (directory.startsWith("~")) {
+        directory = resolve$1(os.homedir(), directory.replace("~", ""));
+      }
+      try {
+        await fs.access(directory);
+        logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
+      } catch (error) {
+        logger.debug(`[DAEMON RUN] Directory doesn't exist, creating: ${directory}`);
+        try {
+          await fs.mkdir(directory, { recursive: true });
+          logger.debug(`[DAEMON RUN] Successfully created directory: ${directory}`);
+          directoryCreated = true;
+        } catch (mkdirError) {
+          let errorMessage = `Unable to create directory at '${directory}'. `;
+          if (mkdirError.code === "EACCES") {
+            errorMessage += `Permission denied. You don't have write access to create a folder at this location. Try using a different path or check your permissions.`;
+          } else if (mkdirError.code === "ENOTDIR") {
+            errorMessage += `A file already exists at this path or in the parent path. Cannot create a directory here. Please choose a different location.`;
+          } else if (mkdirError.code === "ENOSPC") {
+            errorMessage += `No space left on device. Your disk is full. Please free up some space and try again.`;
+          } else if (mkdirError.code === "EROFS") {
+            errorMessage += `The file system is read-only. Cannot create directories here. Please choose a writable location.`;
+          } else {
+            errorMessage += `System error: ${mkdirError.message || mkdirError}. Please verify the path is valid and you have the necessary permissions.`;
+          }
+          logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
+          return null;
+        }
+      }
       try {
-        const happyBinPath = join$1(projectPath(), "bin", "happy.mjs");
         const args = [
           "--happy-starting-mode",
           "remote",
@@ -4540,12 +4450,14 @@ async function startDaemon() {
           // Capture stdout/stderr for debugging
           // env is inherited automatically from parent process
         });
-        happyProcess.stdout?.on("data", (data) => {
-          logger.debug(`[DAEMON RUN] Child stdout: ${data.toString()}`);
-        });
-        happyProcess.stderr?.on("data", (data) => {
-          logger.debug(`[DAEMON RUN] Child stderr: ${data.toString()}`);
-        });
+        if (process.env.DEBUG) {
+          happyProcess.stdout?.on("data", (data) => {
+            logger.debug(`[DAEMON RUN] Child stdout: ${data.toString()}`);
+          });
+          happyProcess.stderr?.on("data", (data) => {
+            logger.debug(`[DAEMON RUN] Child stderr: ${data.toString()}`);
+          });
+        }
         if (!happyProcess.pid) {
           logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
           return null;
@@ -4554,7 +4466,9 @@ async function startDaemon() {
         const trackedSession = {
           startedBy: "daemon",
           pid: happyProcess.pid,
-          childProcess: happyProcess
+          childProcess: happyProcess,
+          directoryCreated,
+          message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session there.` : void 0
         };
         pidToTrackedSession.set(happyProcess.pid, trackedSession);
         happyProcess.on("exit", (code, signal) => {
@@ -4570,16 +4484,16 @@ async function startDaemon() {
           }
         });
         logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const timeout = setTimeout(() => {
             pidToAwaiter.delete(happyProcess.pid);
             logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
-            resolve(trackedSession);
+            resolve2(trackedSession);
           }, 1e4);
           pidToAwaiter.set(happyProcess.pid, (completedSession) => {
             clearTimeout(timeout);
             logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
-            resolve(completedSession);
+            resolve2(completedSession);
           });
         });
       } catch (error) {
@@ -4618,10 +4532,6 @@ async function startDaemon() {
       logger.debug(`[DAEMON RUN] Removing exited process PID ${pid} from tracking`);
       pidToTrackedSession.delete(pid);
     };
-    let requestShutdown;
-    let resolvesWhenShutdownRequested = new Promise((resolve) => {
-      requestShutdown = resolve;
-    });
     const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
       getChildren: getCurrentChildren,
       stopSession,
@@ -4632,10 +4542,11 @@ async function startDaemon() {
     const fileState = {
       pid: process.pid,
       httpPort: controlPort,
-      startTime: (/* @__PURE__ */ new Date()).toISOString(),
-      startedWithCliVersion: packageJson.version
+      startTime: (/* @__PURE__ */ new Date()).toLocaleString(),
+      startedWithCliVersion: packageJson.version,
+      daemonLogPath: logger.logFilePath
     };
-    await writeDaemonState(fileState);
+    writeDaemonState(fileState);
     logger.debug("[DAEMON RUN] Daemon state written");
     const initialDaemonState = {
       status: "offline",
@@ -4657,56 +4568,89 @@ async function startDaemon() {
       requestShutdown: () => requestShutdown("happy-app")
     });
     apiMachine.connect();
-    const cleanupAndShutdown = async (source) => {
-      logger.debug(`[DAEMON RUN] Starting cleanup (source: ${source})...`);
-      if (apiMachine) {
-        await apiMachine.updateDaemonState((state) => ({
-          ...state,
-          status: "shutting-down",
-          shutdownRequestedAt: Date.now(),
-          shutdownSource: source === "happy-app" ? "mobile-app" : source === "happy-cli" ? "cli" : source
-        }));
-        await new Promise((resolve) => setTimeout(resolve, 100));
+    const heartbeatIntervalMs = parseInt(process.env.HAPPY_DAEMON_HEARTBEAT_INTERVAL || "60000");
+    let heartbeatRunning = false;
+    const restartOnStaleVersionAndHeartbeat = setInterval(async () => {
+      if (heartbeatRunning) {
+        return;
       }
-      if (apiMachine) {
-        apiMachine.shutdown();
+      heartbeatRunning = true;
+      if (process.env.DEBUG) {
+        logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
       }
-      logger.debug("[DAEMON RUN] Machine session shutdown");
+      for (const [pid, _] of pidToTrackedSession.entries()) {
+        try {
+          process.kill(pid, 0);
+        } catch (error) {
+          logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
+          pidToTrackedSession.delete(pid);
+        }
+      }
+      const projectVersion = JSON.parse(readFileSync$1(join$1(projectPath(), "package.json"), "utf-8")).version;
+      if (projectVersion !== configuration.currentCliVersion) {
+        logger.debug("[DAEMON RUN] Daemon is outdated, triggering self-restart with latest version, clearing heartbeat interval");
+        clearInterval(restartOnStaleVersionAndHeartbeat);
+        try {
+          spawnHappyCLI(["daemon", "start"], {
+            detached: true,
+            stdio: "ignore"
+          });
+        } catch (error) {
+          logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
+        }
+        logger.debug("[DAEMON RUN] Hanging for a bit - waiting for CLI to kill us because we are running outdated version of the code");
+        await new Promise((resolve2) => setTimeout(resolve2, 1e4));
+        process.exit(0);
+      }
+      const daemonState = await readDaemonState();
+      if (daemonState && daemonState.pid !== process.pid) {
+        logger.debug("[DAEMON RUN] Somehow a different daemon was started without killing us. We should kill ourselves.");
+        requestShutdown("exception", "A different daemon was started without killing us. We should kill ourselves.");
+      }
+      try {
+        const updatedState = {
+          pid: process.pid,
+          httpPort: controlPort,
+          startTime: fileState.startTime,
+          startedWithCliVersion: packageJson.version,
+          lastHeartbeat: (/* @__PURE__ */ new Date()).toLocaleString(),
+          daemonLogPath: fileState.daemonLogPath
+        };
+        writeDaemonState(updatedState);
+        if (process.env.DEBUG) {
+          logger.debug(`[DAEMON RUN] Health check completed at ${updatedState.lastHeartbeat}`);
+        }
+      } catch (error) {
+        logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+      }
+      heartbeatRunning = false;
+    }, heartbeatIntervalMs);
+    const cleanupAndShutdown = async (source, errorMessage) => {
+      logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
+      if (restartOnStaleVersionAndHeartbeat) {
+        clearInterval(restartOnStaleVersionAndHeartbeat);
+        logger.debug("[DAEMON RUN] Health check interval cleared");
+      }
+      await apiMachine.updateDaemonState((state) => ({
+        ...state,
+        status: "shutting-down",
+        shutdownRequestedAt: Date.now(),
+        shutdownSource: source
+      }));
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      apiMachine.shutdown();
       await stopControlServer();
-      logger.debug("[DAEMON RUN] Control server stopped");
       await cleanupDaemonState();
-      logger.debug("[DAEMON RUN] State cleaned up");
-      stopCaffeinate();
-      logger.debug("[DAEMON RUN] Caffeinate stopped");
+      await stopCaffeinate();
+      await releaseDaemonLock(daemonLockHandle);
+      logger.debug("[DAEMON RUN] Cleanup completed, exiting process");
       process.exit(0);
     };
-    process.on("SIGINT", () => {
-      logger.debug("[DAEMON RUN] Received SIGINT");
-      cleanupAndShutdown("os-signal");
-    });
-    process.on("SIGTERM", () => {
-      logger.debug("[DAEMON RUN] Received SIGTERM");
-      cleanupAndShutdown("os-signal");
-    });
-    process.on("uncaughtException", (error) => {
-      logger.debug("[DAEMON RUN] Uncaught exception - cleaning up before crash", error);
-      cleanupAndShutdown("unknown");
-    });
-    process.on("unhandledRejection", (reason) => {
-      logger.debug("[DAEMON RUN] Unhandled rejection - cleaning up before crash", reason);
-      cleanupAndShutdown("unknown");
-    });
-    process.on("exit", () => {
-      logger.debug("[DAEMON RUN] Process exit, not killing any children");
-    });
-    logger.debug("[DAEMON RUN] Daemon started successfully");
-    const shutdownSource = await resolvesWhenShutdownRequested;
-    logger.debug(`[DAEMON RUN] Shutdown requested (source: ${shutdownSource})`);
-    await cleanupAndShutdown(shutdownSource);
+    logger.debug("[DAEMON RUN] Daemon started successfully, waiting for shutdown request");
+    const shutdownRequest = await resolvesWhenShutdownRequested;
+    await cleanupAndShutdown(shutdownRequest.source, shutdownRequest.errorMessage);
   } catch (error) {
-    logger.debug("[DAEMON RUN] Failed to start daemon", error);
-    await cleanupDaemonState();
-    stopCaffeinate();
+    logger.debug("[DAEMON RUN][FATAL] Failed somewhere unexpectedly - exiting with code 1", error);
     process.exit(1);
   }
 }
@@ -4734,7 +4678,7 @@ async function startHappyServer(client) {
     description: "Change the title of the current chat session",
     title: "Change Chat Title",
     inputSchema: {
-      title: z$1.string().describe("The new title for the chat session")
+      title: z.string().describe("The new title for the chat session")
     }
   }, async (args) => {
     const response = await handler(args.title);
@@ -4807,10 +4751,14 @@ async function start(credentials, options = {}) {
   const settings = await readSettings();
   let machineId = settings?.machineId;
   if (!machineId) {
-    console.error(`[START] No machine ID found in settings, which is unexepcted since authAndSetupMachineIfNeeded should have created it, using 'unknown' id instead`);
-    machineId = "unknown";
+    console.error(`[START] No machine ID found in settings, which is unexepcted since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/slopus/happy-cli/issues`);
+    process.exit(1);
   }
   logger.debug(`Using machineId: ${machineId}`);
+  await api.createMachineOrGetExistingAsIs({
+    machineId,
+    metadata: initialMachineMetadata
+  });
   let metadata = {
     path: workingDirectory,
     host: os$1.hostname(),
@@ -4825,14 +4773,12 @@ async function start(credentials, options = {}) {
   };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   logger.debug(`Session created: ${response.id}`);
-  await api.createMachineOrGetExistingAsIs({
-    machineId,
-    metadata: initialMachineMetadata
-  });
   try {
-    const daemonState = await getDaemonState();
-    if (daemonState?.httpPort) {
-      await notifyDaemonSessionStarted(response.id, metadata);
+    logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await notifyDaemonSessionStarted(response.id, metadata);
+    if (result.error) {
+      logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+    } else {
       logger.debug(`[START] Reported session ${response.id} to daemon`);
     }
   } catch (error) {
@@ -4854,7 +4800,7 @@ async function start(credentials, options = {}) {
   const session = api.sessionSyncClient(response);
   const happyServer = await startHappyServer(session);
   logger.debug(`[START] Happy MCP server started at ${happyServer.url}`);
-  const logPath = await logger.logFilePathPromise;
+  const logPath = logger.logFilePath;
   logger.infoDeveloper(`Session: ${response.id}`);
   logger.infoDeveloper(`Logs: ${logPath}`);
   session.updateAgentState((currentState) => ({
@@ -5367,8 +5313,7 @@ async function handleAuthStatus() {
   console.log(chalk.gray(`
   Data directory: ${configuration.happyHomeDir}`));
   try {
-    const { isDaemonRunning } = await Promise.resolve().then(function () { return utils; });
-    const running = await isDaemonRunning();
+    const running = await checkIfDaemonRunningAndCleanupStaleState();
     if (running) {
       console.log(chalk.green("\u2713 Daemon running"));
     } else {
@@ -5409,9 +5354,19 @@ const DaemonPrompt = ({ onSelect }) => {
 
 (async () => {
   const args = process.argv.slice(2);
-  logger.debug("Starting happy CLI with args: ", process.argv);
+  if (!args.includes("--version")) {
+    logger.debug("Starting happy CLI with args: ", process.argv);
+  }
   const subcommand = args[0];
   if (subcommand === "doctor") {
+    if (args[1] === "clean") {
+      const result = await killRunawayHappyProcesses();
+      console.log(`Cleaned up ${result.killed} runaway processes`);
+      if (result.errors.length > 0) {
+        console.log("Errors:", result.errors);
+      }
+      process.exit(0);
+    }
     await runDoctorCommand();
     return;
   } else if (subcommand === "auth") {
@@ -5454,16 +5409,10 @@ const DaemonPrompt = ({ onSelect }) => {
       try {
         const sessions = await listDaemonSessions();
         if (sessions.length === 0) {
-          console.log("No active sessions");
+          console.log("No active sessions this daemon is aware of (they might have been started by a previous version of the daemon)");
         } else {
           console.log("Active sessions:");
-          const cleanSessions = sessions.map((s) => ({
-            pid: s.pid,
-            sessionId: s.happySessionId || `PID-${s.pid}`,
-            startedBy: s.startedBy,
-            directory: s.happySessionMetadataFromLocalWebhook?.directory || "unknown"
-          }));
-          console.log(JSON.stringify(cleanSessions, null, 2));
+          console.log(JSON.stringify(sessions, null, 2));
         }
       } catch (error) {
         console.log("No daemon running");
@@ -5491,7 +5440,7 @@ const DaemonPrompt = ({ onSelect }) => {
       child.unref();
       let started = false;
       for (let i = 0; i < 50; i++) {
-        if (await isDaemonRunning()) {
+        if (await checkIfDaemonRunningAndCleanupStaleState()) {
           started = true;
           break;
         }
@@ -5511,28 +5460,14 @@ const DaemonPrompt = ({ onSelect }) => {
       await stopDaemon();
       process.exit(0);
     } else if (daemonSubcommand === "status") {
-      const state = await getDaemonState();
-      if (!state) {
-        console.log("Daemon is not running");
-      } else {
-        const isRunning = await isDaemonRunning();
-        if (isRunning) {
-          console.log("Daemon is running");
-          console.log(`  PID: ${state.pid}`);
-          console.log(`  Port: ${state.httpPort}`);
-          console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
-          console.log(`  CLI Version: ${state.startedWithCliVersion}`);
-        } else {
-          console.log("Daemon state file exists but daemon is not running (stale)");
-        }
-      }
+      await runDoctorCommand("daemon");
       process.exit(0);
-    } else if (daemonSubcommand === "kill-runaway") {
-      const { killRunawayHappyProcesses } = await Promise.resolve().then(function () { return utils; });
-      const result = await killRunawayHappyProcesses();
-      console.log(`Killed ${result.killed} runaway processes`);
-      if (result.errors.length > 0) {
-        console.log("Errors:", result.errors);
+    } else if (daemonSubcommand === "logs") {
+      const latest = await getLatestDaemonLog();
+      if (!latest) {
+        console.log("No daemon logs found");
+      } else {
+        console.log(latest.path);
       }
       process.exit(0);
     } else if (daemonSubcommand === "install") {
@@ -5556,14 +5491,15 @@ ${chalk.bold("happy daemon")} - Daemon management
 ${chalk.bold("Usage:")}
   happy daemon start              Start the daemon (detached)
   happy daemon stop               Stop the daemon (sessions stay alive)
-  happy daemon stop --kill-managed  Stop daemon and kill managed sessions
   happy daemon status             Show daemon status
   happy daemon list               List active sessions
-  happy daemon stop-session <id> Stop a specific session
-  happy daemon kill-runaway       Kill all runaway Happy processes
+
+  If you want to kill all happy related processes run 
+  ${chalk.cyan("happy doctor clean")}
 
 ${chalk.bold("Note:")} The daemon runs in the background and manages Claude sessions.
-Sessions spawned by the daemon will continue running after daemon stops unless --kill-managed is used.
+
+${chalk.bold("To clean up runaway processes:")} Use ${chalk.cyan("happy doctor clean")}
 `);
     }
     return;
@@ -5571,8 +5507,6 @@ Sessions spawned by the daemon will continue running after daemon stops unless -
     const options = {};
     let showHelp = false;
     let showVersion = false;
-    let forceAuth = false;
-    let forceAuthNew = false;
     const unknownArgs = [];
     for (let i = 0; i < args.length; i++) {
       const arg = args[i];
@@ -5582,12 +5516,8 @@ Sessions spawned by the daemon will continue running after daemon stops unless -
       } else if (arg === "-v" || arg === "--version") {
         showVersion = true;
         unknownArgs.push(arg);
-      } else if (arg === "--auth" || arg === "--login") {
-        forceAuth = true;
-      } else if (arg === "--force-auth") {
-        forceAuthNew = true;
-      } else if (arg === "--happy-starting-mode") {
-        options.startingMode = z$1.enum(["local", "remote"]).parse(args[++i]);
+      } else if (arg === "--auth" || arg === "--login") ; else if (arg === "--force-auth") ; else if (arg === "--happy-starting-mode") {
+        options.startingMode = z.enum(["local", "remote"]).parse(args[++i]);
       } else if (arg === "--yolo") {
         unknownArgs.push("--dangerously-skip-permissions");
       } else if (arg === "--started-by") {
@@ -5607,29 +5537,23 @@ Sessions spawned by the daemon will continue running after daemon stops unless -
 ${chalk.bold("happy")} - Claude Code On the Go
 
 ${chalk.bold("Usage:")}
-  happy [options]          Start Claude with mobile control
-  happy auth              Manage authentication  
-  happy notify            Send push notification
-  happy daemon            Manage background service
-
-${chalk.bold("Happy Options:")}
-  --help                  Show this help message
-  --yolo                  Skip all permissions (--dangerously-skip-permissions)
-  --force-auth            Force re-authentication
-
-${chalk.bold("\u{1F3AF} Happy supports ALL Claude options!")}
-  Use any claude flag exactly as you normally would.
+  happy [options]         Start Claude with mobile control
+  happy auth              Manage authentication
+  happy daemon            Manage background service that allows
+                            to spawn new sessions away from your computer
+  happy doctor            System diagnostics & troubleshooting
 
 ${chalk.bold("Examples:")}
-  happy                   Start session
-  happy --yolo            Start without permissions
-  happy --verbose         Enable verbose mode
-  happy -c                Continue last conversation
-  happy auth login        Authenticate
-  happy notify -p "Done!" Send notification
+  happy                    Start session
+  happy --yolo             Bypass permissions
+  happy --verbose          Enable verbose mode
+  happy auth login --force Authenticate
+  happy doctor             Run diagnostics
 
 ${chalk.bold("Happy is a wrapper around Claude Code that enables remote control via mobile app.")}
-${chalk.bold('Use "happy daemon" for background service management.')}
+
+${chalk.bold("Happy supports ALL Claude options!")}
+  Use any claude flag exactly as you normally would.
 
 ${chalk.gray("\u2500".repeat(60))}
 ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
@@ -5647,30 +5571,9 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
       console.log(packageJson.version);
       process.exit(0);
     }
-    let credentials;
-    if (forceAuthNew) {
-      console.log(chalk.yellow("Force authentication requested..."));
-      try {
-        await stopDaemon();
-      } catch {
-      }
-      await clearCredentials();
-      await clearMachineId();
-      const result = await authAndSetupMachineIfNeeded();
-      credentials = result.credentials;
-    } else if (forceAuth) {
-      console.log(chalk.yellow('Note: --auth is deprecated. Use "happy auth login" or --force-auth instead.\n'));
-      const res = await doAuth();
-      if (!res) {
-        process.exit(1);
-      }
-      await writeCredentials(res);
-      const result = await authAndSetupMachineIfNeeded();
-      credentials = result.credentials;
-    } else {
-      const result = await authAndSetupMachineIfNeeded();
-      credentials = result.credentials;
-    }
+    const {
+      credentials
+    } = await authAndSetupMachineIfNeeded();
     let settings = await readSettings();
     if (settings && settings.daemonAutoStartWhenRunningHappy === void 0) {
       const shouldAutoStart = await new Promise((resolve) => {
@@ -5699,15 +5602,18 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
       }
     }
     if (settings && settings.daemonAutoStartWhenRunningHappy) {
-      logger.debug("Starting Happy background service...");
-      if (!await isDaemonRunning()) {
+      logger.debug("Ensuring Happy background service is running & matches our version...");
+      if (!await isDaemonRunningSameVersion()) {
+        logger.debug("Starting Happy background service...");
         const daemonProcess = spawnHappyCLI(["daemon", "start-sync"], {
           detached: true,
           stdio: "ignore",
           env: process.env
         });
         daemonProcess.unref();
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      } else {
+        logger.debug("Happy background service is running & matches our version");
       }
     }
     try {