happy-coder 0.9.0-5 → 0.9.0

package/dist/index.cjs

@@ -1,18 +1,18 @@
 'use strict';
 
 var chalk = require('chalk');
-var types$1 = require('./types-a-nJyP-e.cjs');
+var os = require('node:os');
 var node_crypto = require('node:crypto');
+var types = require('./types-CyOnnZ8M.cjs');
 var node_child_process = require('node:child_process');
 var node_path = require('node:path');
 var node_readline = require('node:readline');
 var node_url = require('node:url');
 var node_fs = require('node:fs');
-var os = require('node:os');
 var path = require('path');
 var url = require('url');
-var promises$1 = require('node:fs/promises');
-var promises = require('fs/promises');
+var promises = require('node:fs/promises');
+var fs = require('fs/promises');
 var ink = require('ink');
 var React = require('react');
 var axios = require('axios');
@@ -23,37 +23,18 @@ require('expo-server-sdk');
 var child_process = require('child_process');
 var util = require('util');
 var crypto = require('crypto');
-var z = require('zod');
-var fastify = require('fastify');
-var fastifyTypeProviderZod = require('fastify-type-provider-zod');
 var os$1 = require('os');
 var qrcode = require('qrcode-terminal');
 var open = require('open');
+var fastify = require('fastify');
+var z = require('zod');
+var fastifyTypeProviderZod = require('fastify-type-provider-zod');
+var fs$1 = require('fs');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var node_http = require('node:http');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-var fs = require('fs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
-
 class Session {
   path;
   logPath;
@@ -102,7 +83,7 @@ class Session {
    */
   clearSessionId = () => {
     this.sessionId = null;
-    types$1.logger.debug("[Session] Session ID cleared");
+    types.logger.debug("[Session] Session ID cleared");
   };
 }
 
@@ -117,7 +98,7 @@ function claudeCheckSession(sessionId, path) {
   const sessionFile = node_path.join(projectDir, `${sessionId}.jsonl`);
   const sessionExists = node_fs.existsSync(sessionFile);
   if (!sessionExists) {
-    types$1.logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    types.logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
     return false;
   }
   const sessionData = node_fs.readFileSync(sessionFile, "utf-8").split("\n");
@@ -170,7 +151,7 @@ async function claudeLocal(opts) {
   const detectedIdsFileSystem = /* @__PURE__ */ new Set();
   watcher.on("change", (event, filename) => {
     if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
-      types$1.logger.debug("change", event, filename);
+      types.logger.debug("change", event, filename);
       const sessionId = filename.replace(".jsonl", "");
       if (detectedIdsFileSystem.has(sessionId)) {
         return;
@@ -194,7 +175,7 @@ async function claudeLocal(opts) {
   const updateThinking = (newThinking) => {
     if (thinking !== newThinking) {
       thinking = newThinking;
-      types$1.logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
+      types.logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
       if (opts.onThinkingChange) {
         opts.onThinkingChange(thinking);
       }
@@ -272,10 +253,10 @@ async function claudeLocal(opts) {
                 }
                 break;
               default:
-                types$1.logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
+                types.logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
             }
           } catch (e) {
-            types$1.logger.debug(`[ClaudeLocal] Non-JSON line from fd3: ${line}`);
+            types.logger.debug(`[ClaudeLocal] Non-JSON line from fd3: ${line}`);
           }
         });
         rl.on("error", (err) => {
@@ -379,7 +360,7 @@ class InvalidateSync {
     this._pendings = [];
   };
   _doSync = async () => {
-    await types$1.backoff(async () => {
+    await types.backoff(async () => {
       if (this._stopped) {
         return;
       }
@@ -404,21 +385,21 @@ function startFileWatcher(file, onFileChange) {
   void (async () => {
     while (true) {
       try {
-        types$1.logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
-        const watcher = promises.watch(file, { persistent: true, signal: abortController.signal });
+        types.logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
+        const watcher = fs.watch(file, { persistent: true, signal: abortController.signal });
         for await (const event of watcher) {
           if (abortController.signal.aborted) {
             return;
           }
-          types$1.logger.debug(`[FILE_WATCHER] File changed: ${file}`);
+          types.logger.debug(`[FILE_WATCHER] File changed: ${file}`);
           onFileChange(file);
         }
       } catch (e) {
         if (abortController.signal.aborted) {
           return;
         }
-        types$1.logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, restarting watcher in a second`);
-        await types$1.delay(1e3);
+        types.logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, restarting watcher in a second`);
+        await types.delay(1e3);
       }
     }
   })();
@@ -488,21 +469,21 @@ async function createSessionScanner(opts) {
     },
     onNewSession: (sessionId) => {
       if (currentSessionId === sessionId) {
-        types$1.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
         return;
       }
       if (finishedSessions.has(sessionId)) {
-        types$1.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
         return;
       }
       if (pendingSessions.has(sessionId)) {
-        types$1.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
         return;
       }
       if (currentSessionId) {
         pendingSessions.add(currentSessionId);
       }
-      types$1.logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
+      types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
       currentSessionId = sessionId;
       sync.invalidate();
     }
@@ -523,12 +504,12 @@ function messageKey(message) {
 }
 async function readSessionLog(projectDir, sessionId) {
   const expectedSessionFile = node_path.join(projectDir, `${sessionId}.jsonl`);
-  types$1.logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
+  types.logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
   let file;
   try {
-    file = await promises$1.readFile(expectedSessionFile, "utf-8");
+    file = await promises.readFile(expectedSessionFile, "utf-8");
   } catch (error) {
-    types$1.logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
+    types.logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
     return [];
   }
   let lines = file.split("\n");
@@ -539,14 +520,14 @@ async function readSessionLog(projectDir, sessionId) {
         continue;
       }
       let message = JSON.parse(l);
-      let parsed = types$1.RawJSONLinesSchema.safeParse(message);
+      let parsed = types.RawJSONLinesSchema.safeParse(message);
       if (!parsed.success) {
-        types$1.logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
+        types.logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
         continue;
       }
       messages.push(parsed.data);
     } catch (e) {
-      types$1.logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
+      types.logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
       continue;
     }
   }
@@ -574,7 +555,7 @@ async function claudeLocalLauncher(session) {
       await exutFuture.promise;
     }
     async function doAbort() {
-      types$1.logger.debug("[local]: doAbort");
+      types.logger.debug("[local]: doAbort");
       if (!exitReason) {
         exitReason = "switch";
       }
@@ -582,7 +563,7 @@ async function claudeLocalLauncher(session) {
       await abort();
     }
     async function doSwitch() {
-      types$1.logger.debug("[local]: doSwitch");
+      types.logger.debug("[local]: doSwitch");
       if (!exitReason) {
         exitReason = "switch";
       }
@@ -604,7 +585,7 @@ async function claudeLocalLauncher(session) {
       if (exitReason) {
         return exitReason;
       }
-      types$1.logger.debug("[local]: launch");
+      types.logger.debug("[local]: launch");
       try {
         await claudeLocal({
           path: session.path,
@@ -622,7 +603,7 @@ async function claudeLocalLauncher(session) {
           break;
         }
       } catch (e) {
-        types$1.logger.debug("[local]: launch error", e);
+        types.logger.debug("[local]: launch error", e);
         if (!exitReason) {
           session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
           continue;
@@ -630,7 +611,7 @@ async function claudeLocalLauncher(session) {
           break;
         }
       }
-      types$1.logger.debug("[local]: launch done");
+      types.logger.debug("[local]: launch done");
     }
   } finally {
     exutFuture.resolve(void 0);
@@ -910,7 +891,7 @@ function getDefaultClaudeCodePath() {
 }
 function logDebug(message) {
   if (process.env.DEBUG) {
-    types$1.logger.debug(message);
+    types.logger.debug(message);
     console.log(message);
   }
 }
@@ -989,7 +970,7 @@ class Query {
             }
             this.inputStream.enqueue(message);
           } catch (e) {
-            types$1.logger.debug(line);
+            types.logger.debug(line);
           }
         }
       }
@@ -1406,10 +1387,10 @@ async function awaitFileExist(file, timeout = 1e4) {
   const startTime = Date.now();
   while (Date.now() - startTime < timeout) {
     try {
-      await promises.access(file);
+      await fs.access(file);
       return true;
     } catch (e) {
-      await types$1.delay(1e3);
+      await types.delay(1e3);
     }
   }
   return false;
@@ -1441,7 +1422,7 @@ async function claudeRemote(opts) {
   }
   let isCompactCommand = false;
   if (specialCommand.type === "compact") {
-    types$1.logger.debug("[claudeRemote] /compact command detected - will process as normal but with compaction behavior");
+    types.logger.debug("[claudeRemote] /compact command detected - will process as normal but with compaction behavior");
     isCompactCommand = true;
     if (opts.onCompletionEvent) {
       opts.onCompletionEvent("Compaction started");
@@ -1470,7 +1451,7 @@ async function claudeRemote(opts) {
   const updateThinking = (newThinking) => {
     if (thinking !== newThinking) {
       thinking = newThinking;
-      types$1.logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
+      types.logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
       if (opts.onThinkingChange) {
         opts.onThinkingChange(thinking);
       }
@@ -1490,26 +1471,26 @@ async function claudeRemote(opts) {
   });
   updateThinking(true);
   try {
-    types$1.logger.debug(`[claudeRemote] Starting to iterate over response`);
+    types.logger.debug(`[claudeRemote] Starting to iterate over response`);
     for await (const message of response) {
-      types$1.logger.debugLargeJson(`[claudeRemote] Message ${message.type}`, message);
+      types.logger.debugLargeJson(`[claudeRemote] Message ${message.type}`, message);
       opts.onMessage(message);
       if (message.type === "system" && message.subtype === "init") {
         updateThinking(true);
         const systemInit = message;
         if (systemInit.session_id) {
-          types$1.logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
+          types.logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
           const projectDir = getProjectPath(opts.path);
           const found = await awaitFileExist(node_path.join(projectDir, `${systemInit.session_id}.jsonl`));
-          types$1.logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
+          types.logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
           opts.onSessionFound(systemInit.session_id);
         }
       }
       if (message.type === "result") {
         updateThinking(false);
-        types$1.logger.debug("[claudeRemote] Result received, exiting claudeRemote");
+        types.logger.debug("[claudeRemote] Result received, exiting claudeRemote");
         if (isCompactCommand) {
-          types$1.logger.debug("[claudeRemote] Compaction completed");
+          types.logger.debug("[claudeRemote] Compaction completed");
           if (opts.onCompletionEvent) {
             opts.onCompletionEvent("Compaction completed");
           }
@@ -1529,7 +1510,7 @@ async function claudeRemote(opts) {
         if (msg.message.role === "user" && Array.isArray(msg.message.content)) {
           for (let c of msg.message.content) {
             if (c.type === "tool_result" && c.tool_use_id && opts.isAborted(c.tool_use_id)) {
-              types$1.logger.debug("[claudeRemote] Tool aborted, exiting claudeRemote");
+              types.logger.debug("[claudeRemote] Tool aborted, exiting claudeRemote");
               return;
             }
           }
@@ -1538,7 +1519,7 @@ async function claudeRemote(opts) {
     }
   } catch (e) {
     if (e instanceof AbortError) {
-      types$1.logger.debug(`[claudeRemote] Aborted`);
+      types.logger.debug(`[claudeRemote] Aborted`);
     } else {
       throw e;
     }
@@ -1658,9 +1639,9 @@ class PermissionHandler {
       this.permissionMode = response.mode;
     }
     if (pending.toolName === "exit_plan_mode" || pending.toolName === "ExitPlanMode") {
-      types$1.logger.debug("Plan mode result received", response);
+      types.logger.debug("Plan mode result received", response);
       if (response.approved) {
-        types$1.logger.debug("Plan approved - injecting PLAN_FAKE_RESTART");
+        types.logger.debug("Plan approved - injecting PLAN_FAKE_RESTART");
         if (response.mode && ["default", "acceptEdits", "bypassPermissions"].includes(response.mode)) {
           this.session.queue.unshift(PLAN_FAKE_RESTART, { permissionMode: response.mode });
         } else {
@@ -1703,7 +1684,7 @@ class PermissionHandler {
     }
     let toolCallId = this.resolveToolCallId(toolName, input);
     if (!toolCallId) {
-      await types$1.delay(1e3);
+      await types.delay(1e3);
       toolCallId = this.resolveToolCallId(toolName, input);
       if (!toolCallId) {
         throw new Error(`Could not resolve tool call ID for ${toolName}`);
@@ -1757,7 +1738,7 @@ class PermissionHandler {
           }
         }
       }));
-      types$1.logger.debug(`Permission request sent for tool call ${id}: ${toolName}`);
+      types.logger.debug(`Permission request sent for tool call ${id}: ${toolName}`);
     });
   }
   /**
@@ -1879,11 +1860,11 @@ class PermissionHandler {
    */
   setupClientHandler() {
     this.session.client.setHandler("permission", async (message) => {
-      types$1.logger.debug(`Permission response: ${JSON.stringify(message)}`);
+      types.logger.debug(`Permission response: ${JSON.stringify(message)}`);
       const id = message.id;
       const pending = this.pendingRequests.get(id);
       if (!pending) {
-        types$1.logger.debug("Permission request not found or already resolved");
+        types.logger.debug("Permission request not found or already resolved");
         return;
       }
       this.responses.set(id, { ...message, receivedAt: Date.now() });
@@ -1921,7 +1902,7 @@ class PermissionHandler {
 }
 
 function formatClaudeMessageForInk(message, messageBuffer, onAssistantResult) {
-  types$1.logger.debugLargeJson("[CLAUDE INK] Message from remote mode:", message);
+  types.logger.debugLargeJson("[CLAUDE INK] Message from remote mode:", message);
   switch (message.type) {
     case "system": {
       const sysMsg = message;
@@ -2016,7 +1997,7 @@ function formatClaudeMessageForInk(message, messageBuffer, onAssistantResult) {
       } else if (resultMsg.subtype === "error_during_execution") {
         messageBuffer.addMessage("\u274C Error during execution", "result");
         messageBuffer.addMessage(`Completed ${resultMsg.num_turns} turns before error`, "status");
-        types$1.logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
+        types.logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
       }
       break;
     }
@@ -2263,7 +2244,7 @@ class OutgoingMessageQueue {
   }
   queue = [];
   nextId = 1;
-  lock = new types$1.AsyncLock();
+  lock = new types.AsyncLock();
   processTimer;
   delayTimers = /* @__PURE__ */ new Map();
   /**
@@ -2395,9 +2376,9 @@ class OutgoingMessageQueue {
 }
 
 async function claudeRemoteLauncher(session) {
-  types$1.logger.debug("[claudeRemoteLauncher] Starting remote launcher");
+  types.logger.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
-  types$1.logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
+  types.logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
   let messageBuffer = new MessageBuffer();
   let inkInstance = null;
   if (hasTTY) {
@@ -2406,14 +2387,14 @@ async function claudeRemoteLauncher(session) {
       messageBuffer,
       logPath: process.env.DEBUG ? session.logPath : void 0,
       onExit: async () => {
-        types$1.logger.debug("[remote]: Exiting client via Ctrl-C");
+        types.logger.debug("[remote]: Exiting client via Ctrl-C");
         if (!exitReason) {
           exitReason = "exit";
         }
         await abort();
       },
       onSwitchToLocal: () => {
-        types$1.logger.debug("[remote]: Switching to local mode via double space");
+        types.logger.debug("[remote]: Switching to local mode via double space");
         doSwitch();
       }
     }), {
@@ -2438,11 +2419,11 @@ async function claudeRemoteLauncher(session) {
     await abortFuture?.promise;
   }
   async function doAbort() {
-    types$1.logger.debug("[remote]: doAbort");
+    types.logger.debug("[remote]: doAbort");
     await abort();
   }
   async function doSwitch() {
-    types$1.logger.debug("[remote]: doSwitch");
+    types.logger.debug("[remote]: doSwitch");
     if (!exitReason) {
       exitReason = "switch";
     }
@@ -2472,7 +2453,7 @@ async function claudeRemoteLauncher(session) {
       if (umessage.message.content && Array.isArray(umessage.message.content)) {
         for (let c of umessage.message.content) {
           if (c.type === "tool_use" && (c.name === "exit_plan_mode" || c.name === "ExitPlanMode")) {
-            types$1.logger.debug("[remote]: detected plan mode tool call " + c.id);
+            types.logger.debug("[remote]: detected plan mode tool call " + c.id);
             planModeToolCalls.add(c.id);
           }
         }
@@ -2483,7 +2464,7 @@ async function claudeRemoteLauncher(session) {
       if (umessage.message.content && Array.isArray(umessage.message.content)) {
         for (let c of umessage.message.content) {
           if (c.type === "tool_use") {
-            types$1.logger.debug("[remote]: detected tool use " + c.id + " parent: " + umessage.parent_tool_use_id);
+            types.logger.debug("[remote]: detected tool use " + c.id + " parent: " + umessage.parent_tool_use_id);
             ongoingToolCalls.set(c.id, { parentToolCallId: umessage.parent_tool_use_id ?? null });
           }
         }
@@ -2511,8 +2492,8 @@ async function claudeRemoteLauncher(session) {
             content: umessage.message.content.map((c) => {
               if (c.type === "tool_result" && c.tool_use_id && planModeToolCalls.has(c.tool_use_id)) {
                 if (c.content === PLAN_FAKE_REJECT) {
-                  types$1.logger.debug("[remote]: hack plan mode exit");
-                  types$1.logger.debugLargeJson("[remote]: hack plan mode exit", c);
+                  types.logger.debug("[remote]: hack plan mode exit");
+                  types.logger.debugLargeJson("[remote]: hack plan mode exit", c);
                   return {
                     ...c,
                     is_error: false,
@@ -2597,7 +2578,7 @@ async function claudeRemoteLauncher(session) {
   try {
     let pending = null;
     while (!exitReason) {
-      types$1.logger.debug("[remote]: launch");
+      types.logger.debug("[remote]: launch");
       messageBuffer.addMessage("\u2550".repeat(40), "status");
       messageBuffer.addMessage("Starting new Claude session...", "status");
       const controller = new AbortController();
@@ -2627,7 +2608,7 @@ async function claudeRemoteLauncher(session) {
             let msg = await session.queue.waitForMessagesAndGetAsString(controller.signal);
             if (msg) {
               if (modeHash && msg.hash !== modeHash || msg.isolate) {
-                types$1.logger.debug("[remote]: mode has changed, pending message");
+                types.logger.debug("[remote]: mode has changed, pending message");
                 pending = msg;
                 return null;
               }
@@ -2650,16 +2631,21 @@ async function claudeRemoteLauncher(session) {
           claudeArgs: session.claudeArgs,
           onMessage,
           onCompletionEvent: (message) => {
-            types$1.logger.debug(`[remote]: Completion event: ${message}`);
+            types.logger.debug(`[remote]: Completion event: ${message}`);
             session.client.sendSessionEvent({ type: "message", message });
           },
           onSessionReset: () => {
-            types$1.logger.debug("[remote]: Session reset");
+            types.logger.debug("[remote]: Session reset");
             session.clearSessionId();
           },
           onReady: () => {
             if (!pending && session.queue.size() === 0) {
               session.client.sendSessionEvent({ type: "ready" });
+              session.api.push().sendToAllDevices(
+                "It's ready!",
+                `Claude is waiting for your command`,
+                { sessionId: session.client.sessionId }
+              );
             }
           },
           signal: abortController.signal
@@ -2668,29 +2654,29 @@ async function claudeRemoteLauncher(session) {
           session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
         }
       } catch (e) {
-        types$1.logger.debug("[remote]: launch error", e);
+        types.logger.debug("[remote]: launch error", e);
         if (!exitReason) {
           session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
           continue;
         }
       } finally {
-        types$1.logger.debug("[remote]: launch finally");
+        types.logger.debug("[remote]: launch finally");
         for (let [toolCallId, { parentToolCallId }] of ongoingToolCalls) {
           const converted = sdkToLogConverter.generateInterruptedToolResult(toolCallId, parentToolCallId);
           if (converted) {
-            types$1.logger.debug("[remote]: terminating tool call " + toolCallId + " parent: " + parentToolCallId);
+            types.logger.debug("[remote]: terminating tool call " + toolCallId + " parent: " + parentToolCallId);
             session.client.sendClaudeSessionMessage(converted);
           }
         }
         ongoingToolCalls.clear();
-        types$1.logger.debug("[remote]: flushing message queue");
+        types.logger.debug("[remote]: flushing message queue");
         await messageQueue.flush();
         messageQueue.destroy();
-        types$1.logger.debug("[remote]: message queue flushed");
+        types.logger.debug("[remote]: message queue flushed");
         abortController = null;
         abortFuture?.resolve(void 0);
         abortFuture = null;
-        types$1.logger.debug("[remote]: launch done");
+        types.logger.debug("[remote]: launch done");
         permissionHandler.reset();
         modeHash = null;
         mode = null;
@@ -2714,7 +2700,7 @@ async function claudeRemoteLauncher(session) {
 }
 
 async function loop(opts) {
-  const logPath = await types$1.logger.logFilePathPromise;
+  const logPath = types.logger.logFilePath;
   let session = new Session({
     api: opts.api,
     client: opts.session,
@@ -2733,7 +2719,7 @@ async function loop(opts) {
   }
   let mode = opts.startingMode ?? "local";
   while (true) {
-    types$1.logger.debug(`[loop] Iteration with mode: ${mode}`);
+    types.logger.debug(`[loop] Iteration with mode: ${mode}`);
     if (mode === "local") {
       let reason = await claudeLocalLauncher(session);
       if (reason === "exit") {
@@ -2759,133 +2745,6 @@ async function loop(opts) {
   }
 }
 
-var name = "happy-coder";
-var version = "0.9.0-5";
-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$1 = "./dist/index.mjs";
-var types = "./dist/index.d.cts";
-var exports$1 = {
-	".": {
-		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$1,
-	types: types,
-	exports: exports$1,
-	files: files,
-	scripts: scripts,
-	dependencies: dependencies,
-	devDependencies: devDependencies,
-	resolutions: resolutions,
-	publishConfig: publishConfig,
-	packageManager: packageManager
-};
-
 function run(args, options) {
   const RUNNER_PATH = path.resolve(path.join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
   return new Promise((resolve2, reject) => {
@@ -2917,7 +2776,7 @@ function run(args, options) {
 const execAsync = util.promisify(child_process.exec);
 function registerHandlers(session) {
   session.setHandler("bash", async (data) => {
-    types$1.logger.debug("Shell command request:", data.command);
+    types.logger.debug("Shell command request:", data.command);
     try {
       const options = {
         cwd: data.cwd,
@@ -2952,22 +2811,22 @@ function registerHandlers(session) {
     }
   });
   session.setHandler("readFile", async (data) => {
-    types$1.logger.debug("Read file request:", data.path);
+    types.logger.debug("Read file request:", data.path);
     try {
-      const buffer = await promises.readFile(data.path);
+      const buffer = await fs.readFile(data.path);
       const content = buffer.toString("base64");
       return { success: true, content };
     } catch (error) {
-      types$1.logger.debug("Failed to read file:", error);
+      types.logger.debug("Failed to read file:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
     }
   });
   session.setHandler("writeFile", async (data) => {
-    types$1.logger.debug("Write file request:", data.path);
+    types.logger.debug("Write file request:", data.path);
     try {
       if (data.expectedHash !== null && data.expectedHash !== void 0) {
         try {
-          const existingBuffer = await promises.readFile(data.path);
+          const existingBuffer = await fs.readFile(data.path);
           const existingHash = crypto.createHash("sha256").update(existingBuffer).digest("hex");
           if (existingHash !== data.expectedHash) {
             return {
@@ -2987,7 +2846,7 @@ function registerHandlers(session) {
         }
       } else {
         try {
-          await promises.stat(data.path);
+          await fs.stat(data.path);
           return {
             success: false,
             error: "File already exists but was expected to be new"
@@ -3000,18 +2859,18 @@ function registerHandlers(session) {
         }
       }
       const buffer = Buffer.from(data.content, "base64");
-      await promises.writeFile(data.path, buffer);
+      await fs.writeFile(data.path, buffer);
       const hash = crypto.createHash("sha256").update(buffer).digest("hex");
       return { success: true, hash };
     } catch (error) {
-      types$1.logger.debug("Failed to write file:", error);
+      types.logger.debug("Failed to write file:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
     }
   });
   session.setHandler("listDirectory", async (data) => {
-    types$1.logger.debug("List directory request:", data.path);
+    types.logger.debug("List directory request:", data.path);
     try {
-      const entries = await promises.readdir(data.path, { withFileTypes: true });
+      const entries = await fs.readdir(data.path, { withFileTypes: true });
       const directoryEntries = await Promise.all(
         entries.map(async (entry) => {
           const fullPath = path.join(data.path, entry.name);
@@ -3024,11 +2883,11 @@ function registerHandlers(session) {
             type = "file";
           }
           try {
-            const stats = await promises.stat(fullPath);
+            const stats = await fs.stat(fullPath);
             size = stats.size;
             modified = stats.mtime.getTime();
           } catch (error) {
-            types$1.logger.debug(`Failed to stat ${fullPath}:`, error);
+            types.logger.debug(`Failed to stat ${fullPath}:`, error);
           }
           return {
             name: entry.name,
@@ -3045,15 +2904,15 @@ function registerHandlers(session) {
       });
       return { success: true, entries: directoryEntries };
     } catch (error) {
-      types$1.logger.debug("Failed to list directory:", error);
+      types.logger.debug("Failed to list directory:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
     }
   });
   session.setHandler("getDirectoryTree", async (data) => {
-    types$1.logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    types.logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
     async function buildTree(path$1, name, currentDepth) {
       try {
-        const stats = await promises.stat(path$1);
+        const stats = await fs.stat(path$1);
         const node = {
           name,
           path: path$1,
@@ -3062,12 +2921,12 @@ function registerHandlers(session) {
           modified: stats.mtime.getTime()
         };
         if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await promises.readdir(path$1, { withFileTypes: true });
+          const entries = await fs.readdir(path$1, { withFileTypes: true });
           const children = [];
           await Promise.all(
             entries.map(async (entry) => {
               if (entry.isSymbolicLink()) {
-                types$1.logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
+                types.logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
                 return;
               }
               const childPath = path.join(path$1, entry.name);
@@ -3086,7 +2945,7 @@ function registerHandlers(session) {
         }
         return node;
       } catch (error) {
-        types$1.logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
+        types.logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
         return null;
       }
     }
@@ -3101,12 +2960,12 @@ function registerHandlers(session) {
       }
       return { success: true, tree };
     } catch (error) {
-      types$1.logger.debug("Failed to get directory tree:", error);
+      types.logger.debug("Failed to get directory tree:", error);
       return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
     }
   });
   session.setHandler("ripgrep", async (data) => {
-    types$1.logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
+    types.logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
     try {
       const result = await run(data.args, { cwd: data.cwd });
       return {
@@ -3116,7 +2975,7 @@ function registerHandlers(session) {
         stderr: result.stderr.toString()
       };
     } catch (error) {
-      types$1.logger.debug("Failed to run ripgrep:", error);
+      types.logger.debug("Failed to run ripgrep:", error);
       return {
         success: false,
         error: error instanceof Error ? error.message : "Failed to run ripgrep"
@@ -3124,19 +2983,19 @@ function registerHandlers(session) {
     }
   });
   session.setHandler("killSession", async () => {
-    types$1.logger.debug("Kill session request received");
+    types.logger.debug("Kill session request received");
     try {
       const response = {
         success: true,
         message: "Session termination acknowledged, exiting in 100ms"
       };
       setTimeout(() => {
-        types$1.logger.debug("[KILL SESSION] Exiting process as requested");
+        types.logger.debug("[KILL SESSION] Exiting process as requested");
         process.exit(0);
       }, 100);
       return response;
     } catch (error) {
-      types$1.logger.debug("Failed to kill session:", error);
+      types.logger.debug("Failed to kill session:", error);
       return {
         success: false,
         message: error instanceof Error ? error.message : "Failed to kill session"
@@ -3145,129 +3004,6 @@ function registerHandlers(session) {
   });
 }
 
-const defaultSettings = {
-  onboardingCompleted: false
-};
-async function readSettings() {
-  if (!node_fs.existsSync(types$1.configuration.settingsFile)) {
-    return { ...defaultSettings };
-  }
-  try {
-    const content = await promises$1.readFile(types$1.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 = types$1.configuration.settingsFile + ".lock";
-  const tmpFile = types$1.configuration.settingsFile + ".tmp";
-  let fileHandle;
-  let attempts = 0;
-  while (attempts < MAX_LOCK_ATTEMPTS) {
-    try {
-      fileHandle = await promises$1.open(lockFile, node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.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 promises$1.stat(lockFile);
-          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
-            await promises$1.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 (!node_fs.existsSync(types$1.configuration.happyHomeDir)) {
-      await promises$1.mkdir(types$1.configuration.happyHomeDir, { recursive: true });
-    }
-    await promises$1.writeFile(tmpFile, JSON.stringify(updated, null, 2));
-    await promises$1.rename(tmpFile, types$1.configuration.settingsFile);
-    return updated;
-  } finally {
-    await fileHandle.close();
-    await promises$1.unlink(lockFile).catch(() => {
-    });
-  }
-}
-const credentialsSchema = z__namespace.object({
-  secret: z__namespace.string().base64(),
-  token: z__namespace.string()
-});
-async function readCredentials() {
-  if (!node_fs.existsSync(types$1.configuration.privateKeyFile)) {
-    return null;
-  }
-  try {
-    const keyBase64 = await promises$1.readFile(types$1.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 (!node_fs.existsSync(types$1.configuration.happyHomeDir)) {
-    await promises$1.mkdir(types$1.configuration.happyHomeDir, { recursive: true });
-  }
-  await promises$1.writeFile(types$1.configuration.privateKeyFile, JSON.stringify({
-    secret: types$1.encodeBase64(credentials.secret),
-    token: credentials.token
-  }, null, 2));
-}
-async function clearCredentials() {
-  if (node_fs.existsSync(types$1.configuration.privateKeyFile)) {
-    await promises$1.unlink(types$1.configuration.privateKeyFile);
-  }
-}
-async function clearMachineId() {
-  await updateSettings((settings) => ({
-    ...settings,
-    machineId: void 0
-  }));
-}
-async function readDaemonState() {
-  try {
-    if (!node_fs.existsSync(types$1.configuration.daemonStateFile)) {
-      return null;
-    }
-    const content = await promises$1.readFile(types$1.configuration.daemonStateFile, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    return null;
-  }
-}
-async function writeDaemonState(state) {
-  if (!node_fs.existsSync(types$1.configuration.happyHomeDir)) {
-    await promises$1.mkdir(types$1.configuration.happyHomeDir, { recursive: true });
-  }
-  await promises$1.writeFile(types$1.configuration.daemonStateFile, JSON.stringify(state, null, 2));
-}
-async function clearDaemonState() {
-  if (node_fs.existsSync(types$1.configuration.daemonStateFile)) {
-    await promises$1.unlink(types$1.configuration.daemonStateFile);
-  }
-}
-
 class MessageQueue2 {
   queue = [];
   // Made public for testing
@@ -3278,7 +3014,7 @@ class MessageQueue2 {
   constructor(modeHasher, onMessageHandler = null) {
     this.modeHasher = modeHasher;
     this.onMessageHandler = onMessageHandler;
-    types$1.logger.debug(`[MessageQueue2] Initialized`);
+    types.logger.debug(`[MessageQueue2] Initialized`);
   }
   /**
    * Set a handler that will be called when a message arrives
@@ -3294,7 +3030,7 @@ class MessageQueue2 {
       throw new Error("Cannot push to closed queue");
     }
     const modeHash = this.modeHasher(mode);
-    types$1.logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
+    types.logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
     this.queue.push({
       message,
       mode,
@@ -3305,12 +3041,12 @@ class MessageQueue2 {
       this.onMessageHandler(message, mode);
     }
     if (this.waiter) {
-      types$1.logger.debug(`[MessageQueue2] Notifying waiter`);
+      types.logger.debug(`[MessageQueue2] Notifying waiter`);
       const waiter = this.waiter;
       this.waiter = null;
       waiter(true);
     }
-    types$1.logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
+    types.logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
   }
   /**
    * Push a message immediately without batching delay.
@@ -3321,7 +3057,7 @@ class MessageQueue2 {
       throw new Error("Cannot push to closed queue");
     }
     const modeHash = this.modeHasher(mode);
-    types$1.logger.debug(`[MessageQueue2] pushImmediate() called with mode hash: ${modeHash}`);
+    types.logger.debug(`[MessageQueue2] pushImmediate() called with mode hash: ${modeHash}`);
     this.queue.push({
       message,
       mode,
@@ -3332,12 +3068,12 @@ class MessageQueue2 {
       this.onMessageHandler(message, mode);
     }
     if (this.waiter) {
-      types$1.logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
+      types.logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
       const waiter = this.waiter;
       this.waiter = null;
       waiter(true);
     }
-    types$1.logger.debug(`[MessageQueue2] pushImmediate() completed. Queue size: ${this.queue.length}`);
+    types.logger.debug(`[MessageQueue2] pushImmediate() completed. Queue size: ${this.queue.length}`);
   }
   /**
    * Push a message that must be processed in complete isolation.
@@ -3349,7 +3085,7 @@ class MessageQueue2 {
       throw new Error("Cannot push to closed queue");
     }
     const modeHash = this.modeHasher(mode);
-    types$1.logger.debug(`[MessageQueue2] pushIsolateAndClear() called with mode hash: ${modeHash} - clearing ${this.queue.length} pending messages`);
+    types.logger.debug(`[MessageQueue2] pushIsolateAndClear() called with mode hash: ${modeHash} - clearing ${this.queue.length} pending messages`);
     this.queue = [];
     this.queue.push({
       message,
@@ -3361,12 +3097,12 @@ class MessageQueue2 {
       this.onMessageHandler(message, mode);
     }
     if (this.waiter) {
-      types$1.logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
+      types.logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
       const waiter = this.waiter;
       this.waiter = null;
       waiter(true);
     }
-    types$1.logger.debug(`[MessageQueue2] pushIsolateAndClear() completed. Queue size: ${this.queue.length}`);
+    types.logger.debug(`[MessageQueue2] pushIsolateAndClear() completed. Queue size: ${this.queue.length}`);
   }
   /**
    * Push a message to the beginning of the queue with a mode.
@@ -3376,7 +3112,7 @@ class MessageQueue2 {
       throw new Error("Cannot unshift to closed queue");
     }
     const modeHash = this.modeHasher(mode);
-    types$1.logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
+    types.logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
     this.queue.unshift({
       message,
       mode,
@@ -3387,18 +3123,18 @@ class MessageQueue2 {
       this.onMessageHandler(message, mode);
     }
     if (this.waiter) {
-      types$1.logger.debug(`[MessageQueue2] Notifying waiter`);
+      types.logger.debug(`[MessageQueue2] Notifying waiter`);
       const waiter = this.waiter;
       this.waiter = null;
       waiter(true);
     }
-    types$1.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
+    types.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
   }
   /**
    * Reset the queue - clears all messages and resets to empty state
    */
   reset() {
-    types$1.logger.debug(`[MessageQueue2] reset() called. Clearing ${this.queue.length} messages`);
+    types.logger.debug(`[MessageQueue2] reset() called. Clearing ${this.queue.length} messages`);
     this.queue = [];
     this.closed = false;
     this.waiter = null;
@@ -3407,7 +3143,7 @@ class MessageQueue2 {
    * Close the queue - no more messages can be pushed
    */
   close() {
-    types$1.logger.debug(`[MessageQueue2] close() called`);
+    types.logger.debug(`[MessageQueue2] close() called`);
     this.closed = true;
     if (this.waiter) {
       const waiter = this.waiter;
@@ -3459,13 +3195,13 @@ class MessageQueue2 {
     if (firstItem.isolate) {
       const item = this.queue.shift();
       sameModeMessages.push(item.message);
-      types$1.logger.debug(`[MessageQueue2] Collected isolated message with mode hash: ${targetModeHash}`);
+      types.logger.debug(`[MessageQueue2] Collected isolated message with mode hash: ${targetModeHash}`);
     } else {
       while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash && !this.queue[0].isolate) {
         const item = this.queue.shift();
         sameModeMessages.push(item.message);
       }
-      types$1.logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
+      types.logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
     }
     const combinedMessage = sameModeMessages.join("\n");
     return {
@@ -3483,7 +3219,7 @@ class MessageQueue2 {
       let abortHandler = null;
       if (abortSignal) {
         abortHandler = () => {
-          types$1.logger.debug("[MessageQueue2] Wait aborted");
+          types.logger.debug("[MessageQueue2] Wait aborted");
           if (this.waiter === waiterFunc) {
             this.waiter = null;
           }
@@ -3512,7 +3248,7 @@ class MessageQueue2 {
         return;
       }
       this.waiter = waiterFunc;
-      types$1.logger.debug("[MessageQueue2] Waiting for messages...");
+      types.logger.debug("[MessageQueue2] Waiting for messages...");
     });
   }
 }
@@ -3606,11 +3342,11 @@ function hashObject(obj, options, encoding = "hex") {
 let caffeinateProcess = null;
 function startCaffeinate() {
   if (process.platform !== "darwin") {
-    types$1.logger.debug("[caffeinate] Not on macOS, skipping caffeinate");
+    types.logger.debug("[caffeinate] Not on macOS, skipping caffeinate");
     return false;
   }
   if (caffeinateProcess && !caffeinateProcess.killed) {
-    types$1.logger.debug("[caffeinate] Caffeinate already running");
+    types.logger.debug("[caffeinate] Caffeinate already running");
     return true;
   }
   try {
@@ -3619,41 +3355,41 @@ function startCaffeinate() {
       detached: false
     });
     caffeinateProcess.on("error", (error) => {
-      types$1.logger.debug("[caffeinate] Error starting caffeinate:", error);
+      types.logger.debug("[caffeinate] Error starting caffeinate:", error);
       caffeinateProcess = null;
     });
     caffeinateProcess.on("exit", (code, signal) => {
-      types$1.logger.debug(`[caffeinate] Process exited with code ${code}, signal ${signal}`);
+      types.logger.debug(`[caffeinate] Process exited with code ${code}, signal ${signal}`);
       caffeinateProcess = null;
     });
-    types$1.logger.debug(`[caffeinate] Started with PID ${caffeinateProcess.pid}`);
+    types.logger.debug(`[caffeinate] Started with PID ${caffeinateProcess.pid}`);
     setupCleanupHandlers();
     return true;
   } catch (error) {
-    types$1.logger.debug("[caffeinate] Failed to start caffeinate:", error);
+    types.logger.debug("[caffeinate] Failed to start caffeinate:", error);
     return false;
   }
 }
 let isStopping = false;
-function stopCaffeinate() {
+async function stopCaffeinate() {
   if (isStopping) {
+    types.logger.debug("[caffeinate] Already stopping, skipping");
     return;
   }
   if (caffeinateProcess && !caffeinateProcess.killed) {
     isStopping = true;
-    types$1.logger.debug(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
+    types.logger.debug(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
     try {
       caffeinateProcess.kill("SIGTERM");
-      setTimeout(() => {
-        if (caffeinateProcess && !caffeinateProcess.killed) {
-          types$1.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) {
+        types.logger.debug("[caffeinate] Force killing caffeinate process");
+        caffeinateProcess.kill("SIGKILL");
+      }
+      caffeinateProcess = null;
+      isStopping = false;
     } catch (error) {
-      types$1.logger.debug("[caffeinate] Error stopping caffeinate:", error);
+      types.logger.debug("[caffeinate] Error stopping caffeinate:", error);
       isStopping = false;
     }
   }
@@ -3673,21 +3409,19 @@ function setupCleanupHandlers() {
   process.on("SIGUSR1", cleanup);
   process.on("SIGUSR2", cleanup);
   process.on("uncaughtException", (error) => {
-    types$1.logger.debug("[caffeinate] Uncaught exception, cleaning up:", error);
+    types.logger.debug("[caffeinate] Uncaught exception, cleaning up:", error);
     cleanup();
-    process.exit(1);
   });
   process.on("unhandledRejection", (reason, promise) => {
-    types$1.logger.debug("[caffeinate] Unhandled rejection, cleaning up:", reason);
+    types.logger.debug("[caffeinate] Unhandled rejection, cleaning up:", reason);
     cleanup();
-    process.exit(1);
   });
 }
 
 async function extractSDKMetadata() {
   const abortController = new AbortController();
   try {
-    types$1.logger.debug("[metadataExtractor] Starting SDK metadata extraction");
+    types.logger.debug("[metadataExtractor] Starting SDK metadata extraction");
     const sdkQuery = query({
       prompt: "hello",
       options: {
@@ -3703,19 +3437,19 @@ async function extractSDKMetadata() {
           tools: systemMessage.tools,
           slashCommands: systemMessage.slash_commands
         };
-        types$1.logger.debug("[metadataExtractor] Captured SDK metadata:", metadata);
+        types.logger.debug("[metadataExtractor] Captured SDK metadata:", metadata);
         abortController.abort();
         return metadata;
       }
     }
-    types$1.logger.debug("[metadataExtractor] No init message received from SDK");
+    types.logger.debug("[metadataExtractor] No init message received from SDK");
     return {};
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
-      types$1.logger.debug("[metadataExtractor] SDK query aborted after capturing metadata");
+      types.logger.debug("[metadataExtractor] SDK query aborted after capturing metadata");
       return {};
     }
-    types$1.logger.debug("[metadataExtractor] Error extracting SDK metadata:", error);
+    types.logger.debug("[metadataExtractor] Error extracting SDK metadata:", error);
     return {};
   }
 }
@@ -3725,93 +3459,208 @@ function extractSDKMetadataAsync(onComplete) {
       onComplete(metadata);
     }
   }).catch((error) => {
-    types$1.logger.debug("[metadataExtractor] Async extraction failed:", error);
+    types.logger.debug("[metadataExtractor] Async extraction failed:", error);
   });
 }
 
-async function isDaemonRunning() {
+async function daemonPost(path, body) {
+  const state = await types.readDaemonState();
+  if (!state?.httpPort) {
+    const errorMessage = "No daemon running, no state file found";
+    types.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) {
-      types$1.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
-      await cleanupDaemonState();
-      return false;
-    }
-    return true;
+    process.kill(state.pid, 0);
   } catch (error) {
-    types$1.logger.debug("[DAEMON RUN] Error checking daemon status", error);
-    return false;
+    const errorMessage = "Daemon is not running, file is stale";
+    types.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}`;
+      types.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+      return {
+        error: errorMessage
+      };
+    }
+    return await response.json();
   } catch (error) {
-    types$1.logger.debug("[DAEMON RUN] Error reading daemon metadata", error);
-    return null;
+    const errorMessage = `Request failed: ${path}, ${error instanceof Error ? error.message : "Unknown error"}`;
+    types.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 types.readDaemonState();
+  if (!state) {
+    return false;
+  }
   try {
-    process.kill(pid, 0);
+    process.kill(state.pid, 0);
     return true;
   } catch {
+    types.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+}
+async function isDaemonRunningSameVersion() {
+  types.logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
+  if (!runningDaemon) {
+    types.logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    return false;
+  }
+  const state = await types.readDaemonState();
+  if (!state) {
+    types.logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  try {
+    types.logger.debug(`[DAEMON CONTROL] Current CLI version: ${types.configuration.currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+    return types.configuration.currentCliVersion === state.startedWithCliVersion;
+  } catch (error) {
+    types.logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
     return false;
   }
 }
 async function cleanupDaemonState() {
   try {
-    await clearDaemonState();
-    types$1.logger.debug("[DAEMON RUN] Daemon state file removed");
+    await types.clearDaemonState();
+    types.logger.debug("[DAEMON RUN] Daemon state file removed");
+  } catch (error) {
+    types.logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+  }
+}
+async function stopDaemon() {
+  try {
+    const state = await types.readDaemonState();
+    if (!state) {
+      types.logger.debug("No daemon state found");
+      return;
+    }
+    types.logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 2e3);
+      types.logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      types.logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      types.logger.debug("Force killed daemon");
+    } catch (error) {
+      types.logger.debug("Daemon already dead");
+    }
   } catch (error) {
-    types$1.logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+    types.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 = node_child_process.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 = node_child_process.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 = node_child_process.execSync('ps aux | grep -E "(tsx.*src/index.ts|yarn.*tsx)" | grep -v grep', { encoding: "utf8" });
+      const devOutput = node_child_process.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 = node_child_process.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 {
     }
@@ -3822,18 +3671,39 @@ function findAllHappyProcesses() {
 }
 function findRunawayHappyProcesses() {
   try {
-    const output = node_child_process.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 = node_child_process.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 = node_child_process.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) {
@@ -3843,10 +3713,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);
@@ -3854,66 +3724,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();
-    types$1.logger.debug("Stopped sleep prevention");
-    const state = await getDaemonState();
-    if (!state) {
-      types$1.logger.debug("No daemon state found");
-      return;
-    }
-    types$1.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);
-      types$1.logger.debug("Daemon stopped gracefully via HTTP");
-      return;
-    } catch (error) {
-      types$1.logger.debug("HTTP stop failed, will force kill", error);
-    }
-    try {
-      process.kill(state.pid, "SIGKILL");
-      types$1.logger.debug("Force killed daemon");
-    } catch (error) {
-      types$1.logger.debug("Daemon already dead");
-    }
-  } catch (error) {
-    types$1.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 {
@@ -3926,9 +3749,17 @@ function getEnvironmentInfo() {
     DEBUG: process.env.DEBUG,
     workingDirectory: process.cwd(),
     processArgv: process.argv,
-    happyDir: types$1.configuration?.happyHomeDir,
-    serverUrl: types$1.configuration?.serverUrl,
-    logsDir: types$1.configuration?.logsDir
+    happyDir: types.configuration?.happyHomeDir,
+    serverUrl: types.configuration?.serverUrl,
+    logsDir: types.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) {
@@ -3940,62 +3771,67 @@ function getLogFiles(logDir) {
       const path = node_path.join(logDir, file);
       const stats = node_fs.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 = node_path.join(projectRoot, "bin", "happy.mjs");
-  const cliEntrypoint = node_path.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: ${node_fs.existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
-  console.log(`CLI Exists: ${node_fs.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(types$1.configuration.happyHomeDir)}`);
-  console.log(`Server URL: ${chalk.blue(types$1.configuration.serverUrl)}`);
-  console.log(`Logs Dir: ${chalk.blue(types$1.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(types.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 = node_path.join(projectRoot, "bin", "happy.mjs");
+    const cliEntrypoint = node_path.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: ${node_fs.existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log(`CLI Exists: ${node_fs.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(types.configuration.happyHomeDir)}`);
+    console.log(`Server URL: ${chalk.blue(types.configuration.serverUrl)}`);
+    console.log(`Logs Dir: ${chalk.blue(types.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 types.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"));
+    }
+    console.log(chalk.bold("\n\u{1F510} Authentication"));
+    try {
+      const credentials = await types.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"));
     }
-  } 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 types.readDaemonState();
     if (isRunning && state) {
       console.log(chalk.green("\u2713 Daemon is running"));
       console.log(`  PID: ${state.pid}`);
@@ -4011,7 +3847,7 @@ async function runDoctorCommand() {
     }
     if (state) {
       console.log(chalk.bold("\n\u{1F4C4} Daemon State:"));
-      console.log(chalk.blue(`Location: ${types$1.configuration.daemonStateFile}`));
+      console.log(chalk.blue(`Location: ${types.configuration.daemonStateFile}`));
       console.log(chalk.gray(JSON.stringify(state, null, 2)));
     }
     const allProcesses = findAllHappyProcesses();
@@ -4026,9 +3862,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",
@@ -4042,190 +3880,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(types$1.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) {
-    types$1.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(fastifyTypeProviderZod.validatorCompiler);
-    app.setSerializerCompiler(fastifyTypeProviderZod.serializerCompiler);
-    const typed = app.withTypeProvider();
-    typed.post("/session-started", {
-      schema: {
-        body: z.z.object({
-          sessionId: z.z.string(),
-          metadata: z.z.any()
-          // Metadata type from API
-        })
-      }
-    }, async (request, reply) => {
-      const { sessionId, metadata } = request.body;
-      types$1.logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
-      onHappySessionWebhook(sessionId, metadata);
-      return { status: "ok" };
-    });
-    typed.post("/list", async (request, reply) => {
-      const children = getChildren();
-      types$1.logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
-      return { children };
-    });
-    typed.post("/stop-session", {
-      schema: {
-        body: z.z.object({
-          sessionId: z.z.string()
-        })
-      }
-    }, async (request, reply) => {
-      const { sessionId } = request.body;
-      types$1.logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
-      const success = stopSession(sessionId);
-      return { success };
-    });
-    typed.post("/spawn-session", {
-      schema: {
-        body: z.z.object({
-          directory: z.z.string(),
-          sessionId: z.z.string().optional()
-        })
+  if (filter === "all") {
+    console.log(chalk.bold("\n\u{1F4DD} Log Files"));
+    const allLogs = getLogFiles(types.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;
-      types$1.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" };
-      }
-    });
-    typed.post("/stop", async (request, reply) => {
-      types$1.logger.debug("[CONTROL SERVER] Stop daemon request received");
-      setTimeout(() => {
-        types$1.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) {
-        types$1.logger.debug("[CONTROL SERVER] Failed to start:", err);
-        throw err;
+        console.log(chalk.yellow("\nNo daemon log files found"));
       }
-      const port = parseInt(address.split(":").pop());
-      types$1.logger.debug(`[CONTROL SERVER] Started on port ${port}`);
-      resolve({
-        port,
-        stop: async () => {
-          types$1.logger.debug("[CONTROL SERVER] Stopping server");
-          await app.close();
-          types$1.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) {
@@ -4241,22 +3943,22 @@ function displayQRCode(url) {
 }
 
 function generateWebAuthUrl(publicKey) {
-  const publicKeyBase64 = types$1.encodeBase64(publicKey, "base64url");
+  const publicKeyBase64 = types.encodeBase64(publicKey, "base64url");
   return `https://app.happy.engineering/terminal/connect#key=${publicKeyBase64}`;
 }
 
 async function openBrowser(url) {
   try {
     if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
-      types$1.logger.debug("[browser] Headless environment detected, skipping browser open");
+      types.logger.debug("[browser] Headless environment detected, skipping browser open");
       return false;
     }
-    types$1.logger.debug(`[browser] Attempting to open URL: ${url}`);
+    types.logger.debug(`[browser] Attempting to open URL: ${url}`);
     await open(url);
-    types$1.logger.debug("[browser] Browser opened successfully");
+    types.logger.debug("[browser] Browser opened successfully");
     return true;
   } catch (error) {
-    types$1.logger.debug("[browser] Failed to open browser:", error);
+    types.logger.debug("[browser] Failed to open browser:", error);
     return false;
   }
 }
@@ -4306,10 +4008,10 @@ async function doAuth() {
   const secret = new Uint8Array(node_crypto.randomBytes(32));
   const keypair = tweetnacl.box.keyPair.fromSecretKey(secret);
   try {
-    console.log(`[AUTH DEBUG] Sending auth request to: ${types$1.configuration.serverUrl}/v1/auth/request`);
-    console.log(`[AUTH DEBUG] Public key: ${types$1.encodeBase64(keypair.publicKey).substring(0, 20)}...`);
-    await axios.post(`${types$1.configuration.serverUrl}/v1/auth/request`, {
-      publicKey: types$1.encodeBase64(keypair.publicKey)
+    console.log(`[AUTH DEBUG] Sending auth request to: ${types.configuration.serverUrl}/v1/auth/request`);
+    console.log(`[AUTH DEBUG] Public key: ${types.encodeBase64(keypair.publicKey).substring(0, 20)}...`);
+    await axios.post(`${types.configuration.serverUrl}/v1/auth/request`, {
+      publicKey: types.encodeBase64(keypair.publicKey)
     });
     console.log(`[AUTH DEBUG] Auth request sent successfully`);
   } catch (error) {
@@ -4350,7 +4052,7 @@ async function doMobileAuth(keypair) {
   console.clear();
   console.log("\nMobile Authentication\n");
   console.log("Scan this QR code with your Happy mobile app:\n");
-  const authUrl = "happy://terminal?" + types$1.encodeBase64Url(keypair.publicKey);
+  const authUrl = "happy://terminal?" + types.encodeBase64Url(keypair.publicKey);
   displayQRCode(authUrl);
   console.log("\nOr manually enter this URL:");
   console.log(authUrl);
@@ -4387,19 +4089,19 @@ async function waitForAuthentication(keypair) {
   try {
     while (!cancelled) {
       try {
-        const response = await axios.post(`${types$1.configuration.serverUrl}/v1/auth/request`, {
-          publicKey: types$1.encodeBase64(keypair.publicKey)
+        const response = await axios.post(`${types.configuration.serverUrl}/v1/auth/request`, {
+          publicKey: types.encodeBase64(keypair.publicKey)
         });
         if (response.data.state === "authorized") {
           let token = response.data.token;
-          let r = types$1.decodeBase64(response.data.response);
+          let r = types.decodeBase64(response.data.response);
           let decrypted = decryptWithEphemeralKey(r, keypair.secretKey);
           if (decrypted) {
             const credentials = {
               secret: decrypted,
               token
             };
-            await writeCredentials(credentials);
+            await types.writeCredentials(credentials);
             console.log("\n\n\u2713 Authentication successful\n");
             return credentials;
           } else {
@@ -4413,7 +4115,7 @@ async function waitForAuthentication(keypair) {
       }
       process.stdout.write("\rWaiting for authentication" + ".".repeat(dots % 3 + 1) + "   ");
       dots++;
-      await types$1.delay(1e3);
+      await types.delay(1e3);
     }
   } finally {
     process.off("SIGINT", handleInterrupt);
@@ -4431,22 +4133,22 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
   return decrypted;
 }
 async function authAndSetupMachineIfNeeded() {
-  types$1.logger.debug("[AUTH] Starting auth and machine setup...");
-  let credentials = await readCredentials();
+  types.logger.debug("[AUTH] Starting auth and machine setup...");
+  let credentials = await types.readCredentials();
   if (!credentials) {
-    types$1.logger.debug("[AUTH] No credentials found, starting authentication flow...");
+    types.logger.debug("[AUTH] No credentials found, starting authentication flow...");
     const authResult = await doAuth();
     if (!authResult) {
       throw new Error("Authentication failed or was cancelled");
     }
     credentials = authResult;
   } else {
-    types$1.logger.debug("[AUTH] Using existing credentials");
+    types.logger.debug("[AUTH] Using existing credentials");
   }
-  const settings = await updateSettings(async (s) => {
+  const settings = await types.updateSettings(async (s) => {
     if (!s.machineId) {
       const newMachineId = node_crypto.randomUUID();
-      types$1.logger.debug(`[AUTH] No machine ID found, generating new one: ${newMachineId}; We will not create machine on startup since we don't have api client intialized`);
+      types.logger.debug(`[AUTH] No machine ID found, generating new one: ${newMachineId}; We will not create machine on startup since we don't have api client intialized`);
       return {
         ...s,
         machineId: node_crypto.randomUUID()
@@ -4454,7 +4156,7 @@ async function authAndSetupMachineIfNeeded() {
     }
     return s;
   });
-  types$1.logger.debug(`[AUTH] Machine ID: ${settings.machineId}`);
+  types.logger.debug(`[AUTH] Machine ID: ${settings.machineId}`);
   return { credentials, machineId: settings.machineId };
 }
 
@@ -4468,65 +4170,231 @@ function spawnHappyCLI(args, options = {}) {
     directory = process.cwd();
   }
   const fullCommand = `happy ${args.join(" ")}`;
-  types$1.logger.debug(`[DAEMON RUN] Spawning: ${fullCommand} in ${directory}`);
+  types.logger.debug(`[SPAWN HAPPY CLI] Spawning: ${fullCommand} in ${directory}`);
   const nodeArgs = [
     "--no-warnings",
     "--no-deprecation",
     entrypoint,
     ...args
   ];
+  if (!node_fs.existsSync(entrypoint)) {
+    const errorMessage = `Entrypoint ${entrypoint} does not exist`;
+    types.logger.debug(`[SPAWN HAPPY CLI] ${errorMessage}`);
+    throw new Error(errorMessage);
+  }
   return child_process.spawn("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(fastifyTypeProviderZod.validatorCompiler);
+    app.setSerializerCompiler(fastifyTypeProviderZod.serializerCompiler);
+    const typed = app.withTypeProvider();
+    typed.post("/session-started", {
+      schema: {
+        body: z.z.object({
+          sessionId: z.z.string(),
+          metadata: z.z.any()
+          // Metadata type from API
+        })
+      }
+    }, async (request, reply) => {
+      const { sessionId, metadata } = request.body;
+      types.logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
+      onHappySessionWebhook(sessionId, metadata);
+      return { status: "ok" };
+    });
+    typed.post("/list", async (request, reply) => {
+      const children = getChildren();
+      types.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.z.object({
+          sessionId: z.z.string()
+        })
+      }
+    }, async (request, reply) => {
+      const { sessionId } = request.body;
+      types.logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
+      const success = stopSession(sessionId);
+      return { success };
+    });
+    typed.post("/spawn-session", {
+      schema: {
+        body: z.z.object({
+          directory: z.z.string(),
+          sessionId: z.z.string().optional()
+        })
+      }
+    }, async (request, reply) => {
+      const { directory, sessionId } = request.body;
+      types.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) => {
+      types.logger.debug("[CONTROL SERVER] Stop daemon request received");
+      setTimeout(() => {
+        types.logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
+        requestShutdown();
+      }, 50);
+      return { status: "stopping" };
+    });
+    typed.post("/dev-simulate-error", {
+      schema: {
+        body: z.z.object({
+          error: z.z.string()
+        })
+      }
+    }, async (request, reply) => {
+      const { error } = request.body;
+      types.logger.debug(`[CONTROL SERVER] Dev: Simulating error: ${error}`);
+      setTimeout(() => {
+        types.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) {
+        types.logger.debug("[CONTROL SERVER] Failed to start:", err);
+        throw err;
+      }
+      const port = parseInt(address.split(":").pop());
+      types.logger.debug(`[CONTROL SERVER] Started on port ${port}`);
+      resolve({
+        port,
+        stop: async () => {
+          types.logger.debug("[CONTROL SERVER] Stopping server");
+          await app.close();
+          types.logger.debug("[CONTROL SERVER] Server stopped");
+        }
+      });
+    });
+  });
+}
+
 const initialMachineMetadata = {
   host: os$1.hostname(),
   platform: os$1.platform(),
-  happyCliVersion: packageJson.version,
+  happyCliVersion: types.packageJson.version,
   homeDir: os$1.homedir(),
-  happyHomeDir: types$1.configuration.happyHomeDir
+  happyHomeDir: types.configuration.happyHomeDir
 };
 async function startDaemon() {
-  types$1.logger.debug("[DAEMON RUN] Starting daemon process...");
-  types$1.logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
-  const runningDaemon = await getDaemonState();
-  if (runningDaemon) {
-    try {
-      process.kill(runningDaemon.pid, 0);
-      types$1.logger.debug("[DAEMON RUN] Daemon already running");
-      console.log(`Daemon already running (PID: ${runningDaemon.pid})`);
-      process.exit(0);
-    } catch {
-      types$1.logger.debug("[DAEMON RUN] Stale state found, cleaning up");
-      await cleanupDaemonState();
-    }
+  let requestShutdown;
+  let resolvesWhenShutdownRequested = new Promise((resolve2) => {
+    requestShutdown = (source, errorMessage) => {
+      types.logger.debug(`[DAEMON RUN] Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
+      setTimeout(async () => {
+        types.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", () => {
+    types.logger.debug("[DAEMON RUN] Received SIGINT");
+    requestShutdown("os-signal");
+  });
+  process.on("SIGTERM", () => {
+    types.logger.debug("[DAEMON RUN] Received SIGTERM");
+    requestShutdown("os-signal");
+  });
+  process.on("uncaughtException", (error) => {
+    types.logger.debug("[DAEMON RUN] FATAL: Uncaught exception", error);
+    types.logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  process.on("unhandledRejection", (reason, promise) => {
+    types.logger.debug("[DAEMON RUN] FATAL: Unhandled promise rejection", reason);
+    types.logger.debug(`[DAEMON RUN] Rejected promise:`, promise);
+    const error = reason instanceof Error ? reason : new Error(`Unhandled promise rejection: ${reason}`);
+    types.logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  process.on("exit", (code) => {
+    types.logger.debug(`[DAEMON RUN] Process exiting with code: ${code}`);
+  });
+  process.on("beforeExit", (code) => {
+    types.logger.debug(`[DAEMON RUN] Process about to exit with code: ${code}`);
+  });
+  types.logger.debug("[DAEMON RUN] Starting daemon process...");
+  types.logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
+  const runningDaemonVersionMatches = await isDaemonRunningSameVersion();
+  if (!runningDaemonVersionMatches) {
+    types.logger.debug("[DAEMON RUN] Daemon version mismatch detected, restarting daemon with current CLI version");
+    await stopDaemon();
+  } else {
+    types.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) {
-    types$1.logger.debug("[DAEMON RUN] Sleep prevention enabled");
+  const daemonLockHandle = await types.acquireDaemonLock(5, 200);
+  if (!daemonLockHandle) {
+    types.logger.debug("[DAEMON RUN] Daemon lock file already held, another daemon is running");
+    process.exit(0);
   }
   try {
+    const caffeinateStarted = startCaffeinate();
+    if (caffeinateStarted) {
+      types.logger.debug("[DAEMON RUN] Sleep prevention enabled");
+    }
     const { credentials, machineId } = await authAndSetupMachineIfNeeded();
-    types$1.logger.debug("[DAEMON RUN] Auth and machine setup complete");
+    types.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) => {
+      types.logger.debugLargeJson(`[DAEMON RUN] Session reported`, sessionMetadata);
       const pid = sessionMetadata.hostPid;
       if (!pid) {
-        types$1.logger.debug(`[DAEMON RUN] Session webhook missing hostPid for session ${sessionId}`);
+        types.logger.debug(`[DAEMON RUN] Session webhook missing hostPid for sessionId: ${sessionId}`);
         return;
       }
-      types$1.logger.debug(`[DAEMON RUN] Session webhook: ${sessionId}, PID: ${pid}, started by: ${sessionMetadata.startedBy || "unknown"}`);
+      types.logger.debug(`[DAEMON RUN] Session webhook: ${sessionId}, PID: ${pid}, started by: ${sessionMetadata.startedBy || "unknown"}`);
+      types.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;
         existingSession.happySessionMetadataFromLocalWebhook = sessionMetadata;
-        types$1.logger.debug(`[DAEMON RUN] Updated daemon-spawned session ${sessionId} with metadata`);
+        types.logger.debug(`[DAEMON RUN] Updated daemon-spawned session ${sessionId} with metadata`);
         const awaiter = pidToAwaiter.get(pid);
         if (awaiter) {
           pidToAwaiter.delete(pid);
           awaiter(existingSession);
-          types$1.logger.debug(`[DAEMON RUN] Resolved session awaiter for PID ${pid}`);
+          types.logger.debug(`[DAEMON RUN] Resolved session awaiter for PID ${pid}`);
         }
       } else if (!existingSession) {
         const trackedSession = {
@@ -4536,12 +4404,41 @@ async function startDaemon() {
           pid
         };
         pidToTrackedSession.set(pid, trackedSession);
-        types$1.logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
+        types.logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
       }
     };
     const spawnSession = async (directory, sessionId) => {
+      let directoryCreated = false;
+      if (directory.startsWith("~")) {
+        directory = path.resolve(os$1.homedir(), directory.replace("~", ""));
+      }
+      try {
+        await fs.access(directory);
+        types.logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
+      } catch (error) {
+        types.logger.debug(`[DAEMON RUN] Directory doesn't exist, creating: ${directory}`);
+        try {
+          await fs.mkdir(directory, { recursive: true });
+          types.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.`;
+          }
+          types.logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
+          return null;
+        }
+      }
       try {
-        const happyBinPath = path.join(projectPath(), "bin", "happy.mjs");
         const args = [
           "--happy-starting-mode",
           "remote",
@@ -4556,88 +4453,88 @@ async function startDaemon() {
           // Capture stdout/stderr for debugging
           // env is inherited automatically from parent process
         });
-        happyProcess.stdout?.on("data", (data) => {
-          types$1.logger.debug(`[DAEMON RUN] Child stdout: ${data.toString()}`);
-        });
-        happyProcess.stderr?.on("data", (data) => {
-          types$1.logger.debug(`[DAEMON RUN] Child stderr: ${data.toString()}`);
-        });
+        if (process.env.DEBUG) {
+          happyProcess.stdout?.on("data", (data) => {
+            types.logger.debug(`[DAEMON RUN] Child stdout: ${data.toString()}`);
+          });
+          happyProcess.stderr?.on("data", (data) => {
+            types.logger.debug(`[DAEMON RUN] Child stderr: ${data.toString()}`);
+          });
+        }
         if (!happyProcess.pid) {
-          types$1.logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
+          types.logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
           return null;
         }
-        types$1.logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
+        types.logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
         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) => {
-          types$1.logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
+          types.logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
           if (happyProcess.pid) {
             onChildExited(happyProcess.pid);
           }
         });
         happyProcess.on("error", (error) => {
-          types$1.logger.debug(`[DAEMON RUN] Child process error:`, error);
+          types.logger.debug(`[DAEMON RUN] Child process error:`, error);
           if (happyProcess.pid) {
             onChildExited(happyProcess.pid);
           }
         });
-        types$1.logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
-        return new Promise((resolve, reject) => {
+        types.logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
+        return new Promise((resolve2, reject) => {
           const timeout = setTimeout(() => {
             pidToAwaiter.delete(happyProcess.pid);
-            types$1.logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
-            resolve(trackedSession);
+            types.logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
+            resolve2(trackedSession);
           }, 1e4);
           pidToAwaiter.set(happyProcess.pid, (completedSession) => {
             clearTimeout(timeout);
-            types$1.logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
-            resolve(completedSession);
+            types.logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
+            resolve2(completedSession);
           });
         });
       } catch (error) {
-        types$1.logger.debug("[DAEMON RUN] Failed to spawn session:", error);
+        types.logger.debug("[DAEMON RUN] Failed to spawn session:", error);
         return null;
       }
     };
     const stopSession = (sessionId) => {
-      types$1.logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
+      types.logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
       for (const [pid, session] of pidToTrackedSession.entries()) {
         if (session.happySessionId === sessionId || sessionId.startsWith("PID-") && pid === parseInt(sessionId.replace("PID-", ""))) {
           if (session.startedBy === "daemon" && session.childProcess) {
             try {
               session.childProcess.kill("SIGTERM");
-              types$1.logger.debug(`[DAEMON RUN] Sent SIGTERM to daemon-spawned session ${sessionId}`);
+              types.logger.debug(`[DAEMON RUN] Sent SIGTERM to daemon-spawned session ${sessionId}`);
             } catch (error) {
-              types$1.logger.debug(`[DAEMON RUN] Failed to kill session ${sessionId}:`, error);
+              types.logger.debug(`[DAEMON RUN] Failed to kill session ${sessionId}:`, error);
             }
           } else {
             try {
               process.kill(pid, "SIGTERM");
-              types$1.logger.debug(`[DAEMON RUN] Sent SIGTERM to external session PID ${pid}`);
+              types.logger.debug(`[DAEMON RUN] Sent SIGTERM to external session PID ${pid}`);
             } catch (error) {
-              types$1.logger.debug(`[DAEMON RUN] Failed to kill external session PID ${pid}:`, error);
+              types.logger.debug(`[DAEMON RUN] Failed to kill external session PID ${pid}:`, error);
             }
           }
           pidToTrackedSession.delete(pid);
-          types$1.logger.debug(`[DAEMON RUN] Removed session ${sessionId} from tracking`);
+          types.logger.debug(`[DAEMON RUN] Removed session ${sessionId} from tracking`);
           return true;
         }
       }
-      types$1.logger.debug(`[DAEMON RUN] Session ${sessionId} not found`);
+      types.logger.debug(`[DAEMON RUN] Session ${sessionId} not found`);
       return false;
     };
     const onChildExited = (pid) => {
-      types$1.logger.debug(`[DAEMON RUN] Removing exited process PID ${pid} from tracking`);
+      types.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,
@@ -4648,24 +4545,25 @@ async function startDaemon() {
     const fileState = {
       pid: process.pid,
       httpPort: controlPort,
-      startTime: (/* @__PURE__ */ new Date()).toISOString(),
-      startedWithCliVersion: packageJson.version
+      startTime: (/* @__PURE__ */ new Date()).toLocaleString(),
+      startedWithCliVersion: types.packageJson.version,
+      daemonLogPath: types.logger.logFilePath
     };
-    await writeDaemonState(fileState);
-    types$1.logger.debug("[DAEMON RUN] Daemon state written");
+    types.writeDaemonState(fileState);
+    types.logger.debug("[DAEMON RUN] Daemon state written");
     const initialDaemonState = {
       status: "offline",
       pid: process.pid,
       httpPort: controlPort,
       startedAt: Date.now()
     };
-    const api = new types$1.ApiClient(credentials.token, credentials.secret);
+    const api = new types.ApiClient(credentials.token, credentials.secret);
     const machine = await api.createMachineOrGetExistingAsIs({
       machineId,
       metadata: initialMachineMetadata,
       daemonState: initialDaemonState
     });
-    types$1.logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
+    types.logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
     const apiMachine = api.machineSyncClient(machine);
     apiMachine.setRPCHandlers({
       spawnSession,
@@ -4673,63 +4571,96 @@ async function startDaemon() {
       requestShutdown: () => requestShutdown("happy-app")
     });
     apiMachine.connect();
-    const cleanupAndShutdown = async (source) => {
-      types$1.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;
+      }
+      heartbeatRunning = true;
+      if (process.env.DEBUG) {
+        types.logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+      }
+      for (const [pid, _] of pidToTrackedSession.entries()) {
+        try {
+          process.kill(pid, 0);
+        } catch (error) {
+          types.logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
+          pidToTrackedSession.delete(pid);
+        }
       }
-      if (apiMachine) {
-        apiMachine.shutdown();
+      const projectVersion = JSON.parse(fs$1.readFileSync(path.join(projectPath(), "package.json"), "utf-8")).version;
+      if (projectVersion !== types.configuration.currentCliVersion) {
+        types.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) {
+          types.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);
+        }
+        types.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);
       }
-      types$1.logger.debug("[DAEMON RUN] Machine session shutdown");
+      const daemonState = await types.readDaemonState();
+      if (daemonState && daemonState.pid !== process.pid) {
+        types.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: types.packageJson.version,
+          lastHeartbeat: (/* @__PURE__ */ new Date()).toLocaleString(),
+          daemonLogPath: fileState.daemonLogPath
+        };
+        types.writeDaemonState(updatedState);
+        if (process.env.DEBUG) {
+          types.logger.debug(`[DAEMON RUN] Health check completed at ${updatedState.lastHeartbeat}`);
+        }
+      } catch (error) {
+        types.logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+      }
+      heartbeatRunning = false;
+    }, heartbeatIntervalMs);
+    const cleanupAndShutdown = async (source, errorMessage) => {
+      types.logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
+      if (restartOnStaleVersionAndHeartbeat) {
+        clearInterval(restartOnStaleVersionAndHeartbeat);
+        types.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();
-      types$1.logger.debug("[DAEMON RUN] Control server stopped");
       await cleanupDaemonState();
-      types$1.logger.debug("[DAEMON RUN] State cleaned up");
-      stopCaffeinate();
-      types$1.logger.debug("[DAEMON RUN] Caffeinate stopped");
+      await stopCaffeinate();
+      await types.releaseDaemonLock(daemonLockHandle);
+      types.logger.debug("[DAEMON RUN] Cleanup completed, exiting process");
       process.exit(0);
     };
-    process.on("SIGINT", () => {
-      types$1.logger.debug("[DAEMON RUN] Received SIGINT");
-      cleanupAndShutdown("os-signal");
-    });
-    process.on("SIGTERM", () => {
-      types$1.logger.debug("[DAEMON RUN] Received SIGTERM");
-      cleanupAndShutdown("os-signal");
-    });
-    process.on("uncaughtException", (error) => {
-      types$1.logger.debug("[DAEMON RUN] Uncaught exception - cleaning up before crash", error);
-      cleanupAndShutdown("unknown");
-    });
-    process.on("unhandledRejection", (reason) => {
-      types$1.logger.debug("[DAEMON RUN] Unhandled rejection - cleaning up before crash", reason);
-      cleanupAndShutdown("unknown");
-    });
-    process.on("exit", () => {
-      types$1.logger.debug("[DAEMON RUN] Process exit, not killing any children");
-    });
-    types$1.logger.debug("[DAEMON RUN] Daemon started successfully");
-    const shutdownSource = await resolvesWhenShutdownRequested;
-    types$1.logger.debug(`[DAEMON RUN] Shutdown requested (source: ${shutdownSource})`);
-    await cleanupAndShutdown(shutdownSource);
+    types.logger.debug("[DAEMON RUN] Daemon started successfully, waiting for shutdown request");
+    const shutdownRequest = await resolvesWhenShutdownRequested;
+    await cleanupAndShutdown(shutdownRequest.source, shutdownRequest.errorMessage);
   } catch (error) {
-    types$1.logger.debug("[DAEMON RUN] Failed to start daemon", error);
-    await cleanupDaemonState();
-    stopCaffeinate();
+    types.logger.debug("[DAEMON RUN][FATAL] Failed somewhere unexpectedly - exiting with code 1", error);
     process.exit(1);
   }
 }
 
 async function startHappyServer(client) {
   const handler = async (title) => {
-    types$1.logger.debug("[happyMCP] Changing title to:", title);
+    types.logger.debug("[happyMCP] Changing title to:", title);
     try {
       client.sendClaudeSessionMessage({
         type: "summary",
@@ -4754,7 +4685,7 @@ async function startHappyServer(client) {
     }
   }, async (args) => {
     const response = await handler(args.title);
-    types$1.logger.debug("[happyMCP] Response:", response);
+    types.logger.debug("[happyMCP] Response:", response);
     if (response.success) {
       return {
         content: [
@@ -4787,7 +4718,7 @@ async function startHappyServer(client) {
     try {
       await transport.handleRequest(req, res);
     } catch (error) {
-      types$1.logger.debug("Error handling request:", error);
+      types.logger.debug("Error handling request:", error);
       if (!res.headersSent) {
         res.writeHead(500).end();
       }
@@ -4812,74 +4743,76 @@ async function startHappyServer(client) {
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = node_crypto.randomUUID();
-  types$1.logger.debugLargeJson("[START] Happy process started", getEnvironmentInfo());
-  types$1.logger.debug(`[START] Options: startedBy=${options.startedBy}, startingMode=${options.startingMode}`);
+  types.logger.debugLargeJson("[START] Happy process started", getEnvironmentInfo());
+  types.logger.debug(`[START] Options: startedBy=${options.startedBy}, startingMode=${options.startingMode}`);
   if (options.startedBy === "daemon" && options.startingMode === "local") {
-    types$1.logger.debug("Daemon spawn requested with local mode - forcing remote mode");
+    types.logger.debug("Daemon spawn requested with local mode - forcing remote mode");
     options.startingMode = "remote";
   }
-  const api = new types$1.ApiClient(credentials.token, credentials.secret);
+  const api = new types.ApiClient(credentials.token, credentials.secret);
   let state = {};
-  const settings = await readSettings();
+  const settings = await types.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);
   }
-  types$1.logger.debug(`Using machineId: ${machineId}`);
+  types.logger.debug(`Using machineId: ${machineId}`);
+  await api.createMachineOrGetExistingAsIs({
+    machineId,
+    metadata: initialMachineMetadata
+  });
   let metadata = {
     path: workingDirectory,
     host: os.hostname(),
-    version: packageJson.version,
+    version: types.packageJson.version,
     os: os.platform(),
     machineId,
     homeDir: os.homedir(),
-    happyHomeDir: types$1.configuration.happyHomeDir,
+    happyHomeDir: types.configuration.happyHomeDir,
     startedFromDaemon: options.startedBy === "daemon",
     hostPid: process.pid,
     startedBy: options.startedBy || "terminal"
   };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
-  types$1.logger.debug(`Session created: ${response.id}`);
-  await api.createMachineOrGetExistingAsIs({
-    machineId,
-    metadata: initialMachineMetadata
-  });
+  types.logger.debug(`Session created: ${response.id}`);
   try {
-    const daemonState = await getDaemonState();
-    if (daemonState?.httpPort) {
-      await notifyDaemonSessionStarted(response.id, metadata);
-      types$1.logger.debug(`[START] Reported session ${response.id} to daemon`);
+    types.logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await notifyDaemonSessionStarted(response.id, metadata);
+    if (result.error) {
+      types.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+    } else {
+      types.logger.debug(`[START] Reported session ${response.id} to daemon`);
     }
   } catch (error) {
-    types$1.logger.debug("[START] Failed to report to daemon (may not be running):", error);
+    types.logger.debug("[START] Failed to report to daemon (may not be running):", error);
   }
   extractSDKMetadataAsync(async (sdkMetadata) => {
-    types$1.logger.debug("[start] SDK metadata extracted, updating session:", sdkMetadata);
+    types.logger.debug("[start] SDK metadata extracted, updating session:", sdkMetadata);
     try {
       api.sessionSyncClient(response).updateMetadata((currentMetadata) => ({
         ...currentMetadata,
         tools: sdkMetadata.tools,
         slashCommands: sdkMetadata.slashCommands
       }));
-      types$1.logger.debug("[start] Session metadata updated with SDK capabilities");
+      types.logger.debug("[start] Session metadata updated with SDK capabilities");
     } catch (error) {
-      types$1.logger.debug("[start] Failed to update session metadata:", error);
+      types.logger.debug("[start] Failed to update session metadata:", error);
     }
   });
   const session = api.sessionSyncClient(response);
   const happyServer = await startHappyServer(session);
-  types$1.logger.debug(`[START] Happy MCP server started at ${happyServer.url}`);
-  const logPath = await types$1.logger.logFilePathPromise;
-  types$1.logger.infoDeveloper(`Session: ${response.id}`);
-  types$1.logger.infoDeveloper(`Logs: ${logPath}`);
+  types.logger.debug(`[START] Happy MCP server started at ${happyServer.url}`);
+  const logPath = types.logger.logFilePath;
+  types.logger.infoDeveloper(`Session: ${response.id}`);
+  types.logger.infoDeveloper(`Logs: ${logPath}`);
   session.updateAgentState((currentState) => ({
     ...currentState,
     controlledByUser: options.startingMode !== "remote"
   }));
   const caffeinateStarted = startCaffeinate();
   if (caffeinateStarted) {
-    types$1.logger.infoDeveloper("Sleep prevention enabled (macOS)");
+    types.logger.infoDeveloper("Sleep prevention enabled (macOS)");
   }
   const messageQueue = new MessageQueue2((mode) => hashObject({
     isPlan: mode.permissionMode === "plan",
@@ -4905,64 +4838,64 @@ async function start(credentials, options = {}) {
       if (validModes.includes(message.meta.permissionMode)) {
         messagePermissionMode = message.meta.permissionMode;
         currentPermissionMode = messagePermissionMode;
-        types$1.logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
+        types.logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
       } else {
-        types$1.logger.debug(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
+        types.logger.debug(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
       }
     } else {
-      types$1.logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
+      types.logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
     }
     let messageModel = currentModel;
     if (message.meta?.hasOwnProperty("model")) {
       messageModel = message.meta.model || void 0;
       currentModel = messageModel;
-      types$1.logger.debug(`[loop] Model updated from user message: ${messageModel || "reset to default"}`);
+      types.logger.debug(`[loop] Model updated from user message: ${messageModel || "reset to default"}`);
     } else {
-      types$1.logger.debug(`[loop] User message received with no model override, using current: ${currentModel || "default"}`);
+      types.logger.debug(`[loop] User message received with no model override, using current: ${currentModel || "default"}`);
     }
     let messageCustomSystemPrompt = currentCustomSystemPrompt;
     if (message.meta?.hasOwnProperty("customSystemPrompt")) {
       messageCustomSystemPrompt = message.meta.customSystemPrompt || void 0;
       currentCustomSystemPrompt = messageCustomSystemPrompt;
-      types$1.logger.debug(`[loop] Custom system prompt updated from user message: ${messageCustomSystemPrompt ? "set" : "reset to none"}`);
+      types.logger.debug(`[loop] Custom system prompt updated from user message: ${messageCustomSystemPrompt ? "set" : "reset to none"}`);
     } else {
-      types$1.logger.debug(`[loop] User message received with no custom system prompt override, using current: ${currentCustomSystemPrompt ? "set" : "none"}`);
+      types.logger.debug(`[loop] User message received with no custom system prompt override, using current: ${currentCustomSystemPrompt ? "set" : "none"}`);
     }
     let messageFallbackModel = currentFallbackModel;
     if (message.meta?.hasOwnProperty("fallbackModel")) {
       messageFallbackModel = message.meta.fallbackModel || void 0;
       currentFallbackModel = messageFallbackModel;
-      types$1.logger.debug(`[loop] Fallback model updated from user message: ${messageFallbackModel || "reset to none"}`);
+      types.logger.debug(`[loop] Fallback model updated from user message: ${messageFallbackModel || "reset to none"}`);
     } else {
-      types$1.logger.debug(`[loop] User message received with no fallback model override, using current: ${currentFallbackModel || "none"}`);
+      types.logger.debug(`[loop] User message received with no fallback model override, using current: ${currentFallbackModel || "none"}`);
     }
     let messageAppendSystemPrompt = currentAppendSystemPrompt;
     if (message.meta?.hasOwnProperty("appendSystemPrompt")) {
       messageAppendSystemPrompt = message.meta.appendSystemPrompt || void 0;
       currentAppendSystemPrompt = messageAppendSystemPrompt;
-      types$1.logger.debug(`[loop] Append system prompt updated from user message: ${messageAppendSystemPrompt ? "set" : "reset to none"}`);
+      types.logger.debug(`[loop] Append system prompt updated from user message: ${messageAppendSystemPrompt ? "set" : "reset to none"}`);
     } else {
-      types$1.logger.debug(`[loop] User message received with no append system prompt override, using current: ${currentAppendSystemPrompt ? "set" : "none"}`);
+      types.logger.debug(`[loop] User message received with no append system prompt override, using current: ${currentAppendSystemPrompt ? "set" : "none"}`);
     }
     let messageAllowedTools = currentAllowedTools;
     if (message.meta?.hasOwnProperty("allowedTools")) {
       messageAllowedTools = message.meta.allowedTools || void 0;
       currentAllowedTools = messageAllowedTools;
-      types$1.logger.debug(`[loop] Allowed tools updated from user message: ${messageAllowedTools ? messageAllowedTools.join(", ") : "reset to none"}`);
+      types.logger.debug(`[loop] Allowed tools updated from user message: ${messageAllowedTools ? messageAllowedTools.join(", ") : "reset to none"}`);
     } else {
-      types$1.logger.debug(`[loop] User message received with no allowed tools override, using current: ${currentAllowedTools ? currentAllowedTools.join(", ") : "none"}`);
+      types.logger.debug(`[loop] User message received with no allowed tools override, using current: ${currentAllowedTools ? currentAllowedTools.join(", ") : "none"}`);
     }
     let messageDisallowedTools = currentDisallowedTools;
     if (message.meta?.hasOwnProperty("disallowedTools")) {
       messageDisallowedTools = message.meta.disallowedTools || void 0;
       currentDisallowedTools = messageDisallowedTools;
-      types$1.logger.debug(`[loop] Disallowed tools updated from user message: ${messageDisallowedTools ? messageDisallowedTools.join(", ") : "reset to none"}`);
+      types.logger.debug(`[loop] Disallowed tools updated from user message: ${messageDisallowedTools ? messageDisallowedTools.join(", ") : "reset to none"}`);
     } else {
-      types$1.logger.debug(`[loop] User message received with no disallowed tools override, using current: ${currentDisallowedTools ? currentDisallowedTools.join(", ") : "none"}`);
+      types.logger.debug(`[loop] User message received with no disallowed tools override, using current: ${currentDisallowedTools ? currentDisallowedTools.join(", ") : "none"}`);
     }
     const specialCommand = parseSpecialCommand(message.content.text);
     if (specialCommand.type === "compact") {
-      types$1.logger.debug("[start] Detected /compact command");
+      types.logger.debug("[start] Detected /compact command");
       const enhancedMode2 = {
         permissionMode: messagePermissionMode || "default",
         model: messageModel,
@@ -4973,11 +4906,11 @@ async function start(credentials, options = {}) {
         disallowedTools: messageDisallowedTools
       };
       messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
-      types$1.logger.debugLargeJson("[start] /compact command pushed to queue:", message);
+      types.logger.debugLargeJson("[start] /compact command pushed to queue:", message);
       return;
     }
     if (specialCommand.type === "clear") {
-      types$1.logger.debug("[start] Detected /clear command");
+      types.logger.debug("[start] Detected /clear command");
       const enhancedMode2 = {
         permissionMode: messagePermissionMode || "default",
         model: messageModel,
@@ -4988,7 +4921,7 @@ async function start(credentials, options = {}) {
         disallowedTools: messageDisallowedTools
       };
       messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
-      types$1.logger.debugLargeJson("[start] /compact command pushed to queue:", message);
+      types.logger.debugLargeJson("[start] /compact command pushed to queue:", message);
       return;
     }
     const enhancedMode = {
@@ -5001,10 +4934,10 @@ async function start(credentials, options = {}) {
       disallowedTools: messageDisallowedTools
     };
     messageQueue.push(message.content.text, enhancedMode);
-    types$1.logger.debugLargeJson("User message pushed to queue:", message);
+    types.logger.debugLargeJson("User message pushed to queue:", message);
   });
   const cleanup = async () => {
-    types$1.logger.debug("[START] Received termination signal, cleaning up...");
+    types.logger.debug("[START] Received termination signal, cleaning up...");
     try {
       if (session) {
         session.sendSessionDeath();
@@ -5013,21 +4946,21 @@ async function start(credentials, options = {}) {
       }
       stopCaffeinate();
       happyServer.stop();
-      types$1.logger.debug("[START] Cleanup complete, exiting");
+      types.logger.debug("[START] Cleanup complete, exiting");
       process.exit(0);
     } catch (error) {
-      types$1.logger.debug("[START] Error during cleanup:", error);
+      types.logger.debug("[START] Error during cleanup:", error);
       process.exit(1);
     }
   };
   process.on("SIGTERM", cleanup);
   process.on("SIGINT", cleanup);
   process.on("uncaughtException", (error) => {
-    types$1.logger.debug("[START] Uncaught exception:", error);
+    types.logger.debug("[START] Uncaught exception:", error);
     cleanup();
   });
   process.on("unhandledRejection", (reason) => {
-    types$1.logger.debug("[START] Unhandled rejection:", reason);
+    types.logger.debug("[START] Unhandled rejection:", reason);
     cleanup();
   });
   await loop({
@@ -5058,14 +4991,14 @@ async function start(credentials, options = {}) {
     claudeArgs: options.claudeArgs
   });
   session.sendSessionDeath();
-  types$1.logger.debug("Waiting for socket to flush...");
+  types.logger.debug("Waiting for socket to flush...");
   await session.flush();
-  types$1.logger.debug("Closing session...");
+  types.logger.debug("Closing session...");
   await session.close();
   stopCaffeinate();
-  types$1.logger.debug("Stopped sleep prevention");
+  types.logger.debug("Stopped sleep prevention");
   happyServer.stop();
-  types$1.logger.debug("Stopped Happy MCP server");
+  types.logger.debug("Stopped Happy MCP server");
   process.exit(0);
 }
 
@@ -5073,8 +5006,8 @@ const PLIST_LABEL$1 = "com.happy-cli.daemon";
 const PLIST_FILE$1 = `/Library/LaunchDaemons/${PLIST_LABEL$1}.plist`;
 async function install$1() {
   try {
-    if (fs.existsSync(PLIST_FILE$1)) {
-      types$1.logger.info("Daemon plist already exists. Uninstalling first...");
+    if (fs$1.existsSync(PLIST_FILE$1)) {
+      types.logger.info("Daemon plist already exists. Uninstalling first...");
       child_process.execSync(`launchctl unload ${PLIST_FILE$1}`, { stdio: "inherit" });
     }
     const happyPath = process.argv[0];
@@ -5117,14 +5050,14 @@ async function install$1() {
             </dict>
             </plist>
         `);
-    fs.writeFileSync(PLIST_FILE$1, plistContent);
-    fs.chmodSync(PLIST_FILE$1, 420);
-    types$1.logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
+    fs$1.writeFileSync(PLIST_FILE$1, plistContent);
+    fs$1.chmodSync(PLIST_FILE$1, 420);
+    types.logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
     child_process.execSync(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
-    types$1.logger.info("Daemon installed and started successfully");
-    types$1.logger.info("Check logs at ~/.happy/daemon.log");
+    types.logger.info("Daemon installed and started successfully");
+    types.logger.info("Check logs at ~/.happy/daemon.log");
   } catch (error) {
-    types$1.logger.debug("Failed to install daemon:", error);
+    types.logger.debug("Failed to install daemon:", error);
     throw error;
   }
 }
@@ -5136,7 +5069,7 @@ async function install() {
   if (process.getuid && process.getuid() !== 0) {
     throw new Error("Daemon installation requires sudo privileges. Please run with sudo.");
   }
-  types$1.logger.info("Installing Happy CLI daemon for macOS...");
+  types.logger.info("Installing Happy CLI daemon for macOS...");
   await install$1();
 }
 
@@ -5144,21 +5077,21 @@ const PLIST_LABEL = "com.happy-cli.daemon";
 const PLIST_FILE = `/Library/LaunchDaemons/${PLIST_LABEL}.plist`;
 async function uninstall$1() {
   try {
-    if (!fs.existsSync(PLIST_FILE)) {
-      types$1.logger.info("Daemon plist not found. Nothing to uninstall.");
+    if (!fs$1.existsSync(PLIST_FILE)) {
+      types.logger.info("Daemon plist not found. Nothing to uninstall.");
       return;
     }
     try {
       child_process.execSync(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
-      types$1.logger.info("Daemon stopped successfully");
+      types.logger.info("Daemon stopped successfully");
     } catch (error) {
-      types$1.logger.info("Failed to unload daemon (it might not be running)");
+      types.logger.info("Failed to unload daemon (it might not be running)");
     }
-    fs.unlinkSync(PLIST_FILE);
-    types$1.logger.info(`Removed daemon plist from ${PLIST_FILE}`);
-    types$1.logger.info("Daemon uninstalled successfully");
+    fs$1.unlinkSync(PLIST_FILE);
+    types.logger.info(`Removed daemon plist from ${PLIST_FILE}`);
+    types.logger.info("Daemon uninstalled successfully");
   } catch (error) {
-    types$1.logger.debug("Failed to uninstall daemon:", error);
+    types.logger.debug("Failed to uninstall daemon:", error);
     throw error;
   }
 }
@@ -5170,7 +5103,7 @@ async function uninstall() {
   if (process.getuid && process.getuid() !== 0) {
     throw new Error("Daemon uninstallation requires sudo privileges. Please run with sudo.");
   }
-  types$1.logger.info("Uninstalling Happy CLI daemon for macOS...");
+  types.logger.info("Uninstalling Happy CLI daemon for macOS...");
   await uninstall$1();
 }
 
@@ -5263,21 +5196,21 @@ async function handleAuthLogin(args) {
     console.log(chalk.gray("  \u2022 Stop daemon if running"));
     console.log(chalk.gray("  \u2022 Re-authenticate and register machine\n"));
     try {
-      types$1.logger.debug("Stopping daemon for force auth...");
+      types.logger.debug("Stopping daemon for force auth...");
       await stopDaemon();
       console.log(chalk.gray("\u2713 Stopped daemon"));
     } catch (error) {
-      types$1.logger.debug("Daemon was not running or failed to stop:", error);
+      types.logger.debug("Daemon was not running or failed to stop:", error);
     }
-    await clearCredentials();
+    await types.clearCredentials();
     console.log(chalk.gray("\u2713 Cleared credentials"));
-    await clearMachineId();
+    await types.clearMachineId();
     console.log(chalk.gray("\u2713 Cleared machine ID"));
     console.log("");
   }
   if (!forceAuth) {
-    const existingCreds = await readCredentials();
-    const settings = await readSettings();
+    const existingCreds = await types.readCredentials();
+    const settings = await types.readSettings();
     if (existingCreds && settings?.machineId) {
       console.log(chalk.green("\u2713 Already authenticated"));
       console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
@@ -5300,8 +5233,8 @@ async function handleAuthLogin(args) {
   }
 }
 async function handleAuthLogout() {
-  const happyDir = types$1.configuration.happyHomeDir;
-  const credentials = await readCredentials();
+  const happyDir = types.configuration.happyHomeDir;
+  const credentials = await types.readCredentials();
   if (!credentials) {
     console.log(chalk.yellow("Not currently authenticated"));
     return;
@@ -5336,8 +5269,8 @@ async function handleAuthLogout() {
   }
 }
 async function handleAuthShowBackup() {
-  const credentials = await readCredentials();
-  const settings = await readSettings();
+  const credentials = await types.readCredentials();
+  const settings = await types.readSettings();
   if (!credentials) {
     console.log(chalk.yellow("Not authenticated"));
     console.log(chalk.gray('Run "happy auth login" to authenticate first'));
@@ -5361,8 +5294,8 @@ async function handleAuthShowBackup() {
   console.log(chalk.yellow("\u26A0\uFE0F  Keep this key secure - it provides full access to your account"));
 }
 async function handleAuthStatus() {
-  const credentials = await readCredentials();
-  const settings = await readSettings();
+  const credentials = await types.readCredentials();
+  const settings = await types.readSettings();
   console.log(chalk.bold("\nAuthentication Status\n"));
   if (!credentials) {
     console.log(chalk.red("\u2717 Not authenticated"));
@@ -5381,10 +5314,9 @@ async function handleAuthStatus() {
     console.log(chalk.gray('  Run "happy auth login --force" to fix this'));
   }
   console.log(chalk.gray(`
-  Data directory: ${types$1.configuration.happyHomeDir}`));
+  Data directory: ${types.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 {
@@ -5425,9 +5357,19 @@ const DaemonPrompt = ({ onSelect }) => {
 
 (async () => {
   const args = process.argv.slice(2);
-  types$1.logger.debug("Starting happy CLI with args: ", process.argv);
+  if (!args.includes("--version")) {
+    types.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") {
@@ -5470,16 +5412,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");
@@ -5507,7 +5443,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;
         }
@@ -5527,28 +5463,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 types.getLatestDaemonLog();
+      if (!latest) {
+        console.log("No daemon logs found");
+      } else {
+        console.log(latest.path);
       }
       process.exit(0);
     } else if (daemonSubcommand === "install") {
@@ -5572,14 +5494,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;
@@ -5587,8 +5510,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];
@@ -5598,11 +5519,7 @@ 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") {
+      } else if (arg === "--auth" || arg === "--login") ; else if (arg === "--force-auth") ; else if (arg === "--happy-starting-mode") {
         options.startingMode = z.z.enum(["local", "remote"]).parse(args[++i]);
       } else if (arg === "--yolo") {
         unknownArgs.push("--dangerously-skip-permissions");
@@ -5623,29 +5540,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`):")}
@@ -5660,34 +5571,13 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
       process.exit(0);
     }
     if (showVersion) {
-      console.log(packageJson.version);
+      console.log(types.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;
-    }
-    let settings = await readSettings();
+    const {
+      credentials
+    } = await authAndSetupMachineIfNeeded();
+    let settings = await types.readSettings();
     if (settings && settings.daemonAutoStartWhenRunningHappy === void 0) {
       const shouldAutoStart = await new Promise((resolve) => {
         let hasResolved = false;
@@ -5703,7 +5593,7 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
           patchConsole: false
         });
       });
-      settings = await updateSettings((settings2) => ({
+      settings = await types.updateSettings((settings2) => ({
         ...settings2,
         daemonAutoStartWhenRunningHappy: shouldAutoStart
       }));
@@ -5715,15 +5605,18 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
       }
     }
     if (settings && settings.daemonAutoStartWhenRunningHappy) {
-      types$1.logger.debug("Starting Happy background service...");
-      if (!await isDaemonRunning()) {
+      types.logger.debug("Ensuring Happy background service is running & matches our version...");
+      if (!await isDaemonRunningSameVersion()) {
+        types.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 {
+        types.logger.debug("Happy background service is running & matches our version");
       }
     }
     try {
@@ -5778,14 +5671,14 @@ ${chalk.bold("Examples:")}
     console.log(chalk.gray('Run "happy notify --help" for usage information.'));
     process.exit(1);
   }
-  let credentials = await readCredentials();
+  let credentials = await types.readCredentials();
   if (!credentials) {
     console.error(chalk.red('Error: Not authenticated. Please run "happy --auth" first.'));
     process.exit(1);
   }
   console.log(chalk.blue("\u{1F4F1} Sending push notification..."));
   try {
-    const api = new types$1.ApiClient(credentials.token, credentials.secret);
+    const api = new types.ApiClient(credentials.token, credentials.secret);
     const notificationTitle = title || "Happy";
     api.push().sendToAllDevices(
       notificationTitle,