happy-coder 0.2.2 → 0.2.3-beta.1

package/dist/index.mjs

@@ -1,134 +1,832 @@
 import chalk from 'chalk';
-import { l as logger, d as delay, e as backoff, R as RawJSONLinesSchema, c as configuration, f as encodeBase64, A as ApiClient, g as encodeBase64Url, h as decodeBase64, b as initializeConfiguration, i as initLoggerWithGlobalConfiguration } from './types-DNu8okOb.mjs';
+import { l as logger, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as encodeBase64, A as ApiClient, g as encodeBase64Url, h as decodeBase64, b as initializeConfiguration, i as initLoggerWithGlobalConfiguration } from './types-BX4xv8Ty.mjs';
 import { randomUUID, randomBytes } from 'node:crypto';
-import { spawn } from 'node:child_process';
+import { spawn, execSync } from 'node:child_process';
+import { resolve, join, dirname } from 'node:path';
 import { createInterface } from 'node:readline';
-import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
-import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
 import os, { homedir } from 'node:os';
-import { access, watch as watch$1, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
 import { readFile, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
+import { watch as watch$1, access, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
+import { useStdout, useInput, Box, Text, render } from 'ink';
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import axios from 'axios';
+import { EventEmitter } from 'node:events';
+import { io } from 'socket.io-client';
+import tweetnacl from 'tweetnacl';
+import 'expo-server-sdk';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import * as z from 'zod';
 import { z as z$1 } from 'zod';
-import { spawn as spawn$1, exec, execSync } from 'child_process';
+import { spawn as spawn$1, exec, execSync as execSync$1 } from 'child_process';
 import { promisify } from 'util';
 import crypto, { createHash } from 'crypto';
 import { dirname as dirname$1, join as join$1 } from 'path';
 import { fileURLToPath as fileURLToPath$1 } from 'url';
-import tweetnacl from 'tweetnacl';
-import axios from 'axios';
 import qrcode from 'qrcode-terminal';
-import { EventEmitter } from 'node:events';
-import { io } from 'socket.io-client';
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, writeFileSync, unlinkSync, mkdirSync as mkdirSync$1, chmodSync } from 'fs';
 import { hostname, homedir as homedir$1 } from 'os';
-import { closeSync, existsSync as existsSync$1, readFileSync as readFileSync$1, unlinkSync, mkdirSync as mkdirSync$1, openSync, writeSync, writeFileSync, chmodSync } from 'fs';
-import 'expo-server-sdk';
 
-class Stream {
-  constructor(returned) {
-    this.returned = returned;
-  }
-  queue = [];
-  readResolve;
-  readReject;
-  isDone = false;
-  hasError;
-  started = false;
-  /**
-   * Implements async iterable protocol
-   */
-  [Symbol.asyncIterator]() {
-    if (this.started) {
-      throw new Error("Stream can only be iterated once");
-    }
-    this.started = true;
-    return this;
+class Session {
+  path;
+  logPath;
+  api;
+  client;
+  queue;
+  claudeEnvVars;
+  claudeArgs;
+  mcpServers;
+  _onModeChange;
+  sessionId;
+  mode = "local";
+  thinking = false;
+  constructor(opts) {
+    this.path = opts.path;
+    this.api = opts.api;
+    this.client = opts.client;
+    this.logPath = opts.logPath;
+    this.sessionId = opts.sessionId;
+    this.queue = opts.messageQueue;
+    this.claudeEnvVars = opts.claudeEnvVars;
+    this.claudeArgs = opts.claudeArgs;
+    this.mcpServers = opts.mcpServers;
+    this._onModeChange = opts.onModeChange;
+    this.client.keepAlive(this.thinking, this.mode);
+    setInterval(() => {
+      this.client.keepAlive(this.thinking, this.mode);
+    }, 2e3);
+  }
+  onThinkingChange = (thinking) => {
+    this.thinking = thinking;
+    this.client.keepAlive(thinking, this.mode);
+  };
+  onModeChange = (mode) => {
+    this.mode = mode;
+    this.client.keepAlive(this.thinking, mode);
+    this._onModeChange(mode);
+  };
+  onSessionFound = (sessionId) => {
+    this.sessionId = sessionId;
+  };
+}
+
+function getProjectPath(workingDirectory) {
+  const projectId = resolve(workingDirectory).replace(/[\\\/\.:]/g, "-");
+  return join(homedir(), ".claude", "projects", projectId);
+}
+
+function claudeCheckSession(sessionId, path) {
+  const projectDir = getProjectPath(path);
+  const sessionFile = join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = existsSync(sessionFile);
+  if (!sessionExists) {
+    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    return false;
   }
-  /**
-   * Gets the next value from the stream
-   */
-  async next() {
-    if (this.queue.length > 0) {
-      return Promise.resolve({
-        done: false,
-        value: this.queue.shift()
-      });
+  const sessionData = readFileSync(sessionFile, "utf-8").split("\n");
+  const hasGoodMessage = !!sessionData.find((v) => {
+    try {
+      return typeof JSON.parse(v).uuid === "string";
+    } catch (e) {
+      return false;
     }
-    if (this.isDone) {
-      return Promise.resolve({ done: true, value: void 0 });
+  });
+  return hasGoodMessage;
+}
+
+const __dirname$2 = dirname(fileURLToPath(import.meta.url));
+async function claudeLocal(opts) {
+  const projectDir = getProjectPath(opts.path);
+  mkdirSync(projectDir, { recursive: true });
+  const watcher = watch(projectDir);
+  let resolvedSessionId = null;
+  const detectedIdsRandomUUID = /* @__PURE__ */ new Set();
+  const detectedIdsFileSystem = /* @__PURE__ */ new Set();
+  watcher.on("change", (event, filename) => {
+    if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
+      logger.debug("change", event, filename);
+      const sessionId = filename.replace(".jsonl", "");
+      if (detectedIdsFileSystem.has(sessionId)) {
+        return;
+      }
+      detectedIdsFileSystem.add(sessionId);
+      if (resolvedSessionId) {
+        return;
+      }
+      if (detectedIdsRandomUUID.has(sessionId)) {
+        resolvedSessionId = sessionId;
+        opts.onSessionFound(sessionId);
+      }
     }
-    if (this.hasError) {
-      return Promise.reject(this.hasError);
+  });
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
+  }
+  let thinking = false;
+  let stopThinkingTimeout = null;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
     }
-    return new Promise((resolve, reject) => {
-      this.readResolve = resolve;
-      this.readReject = reject;
+  };
+  try {
+    process.stdin.pause();
+    await new Promise((r, reject) => {
+      const args = [];
+      if (startFrom) {
+        args.push("--resume", startFrom);
+      }
+      if (opts.claudeArgs) {
+        args.push(...opts.claudeArgs);
+      }
+      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || resolve(join(__dirname$2, "..", "scripts", "claudeInteractiveLaunch.cjs"));
+      const env = {
+        ...process.env,
+        ...opts.claudeEnvVars
+      };
+      const child = spawn("node", [claudeCliPath, ...args], {
+        stdio: ["inherit", "inherit", "inherit", "pipe"],
+        signal: opts.abort,
+        cwd: opts.path,
+        env
+      });
+      if (child.stdio[3]) {
+        const rl = createInterface({
+          input: child.stdio[3],
+          crlfDelay: Infinity
+        });
+        const activeFetches = /* @__PURE__ */ new Map();
+        rl.on("line", (line) => {
+          try {
+            const message = JSON.parse(line);
+            switch (message.type) {
+              case "uuid":
+                detectedIdsRandomUUID.add(message.value);
+                if (!resolvedSessionId && detectedIdsFileSystem.has(message.value)) {
+                  resolvedSessionId = message.value;
+                  opts.onSessionFound(message.value);
+                }
+                break;
+              case "fetch-start":
+                activeFetches.set(message.id, {
+                  hostname: message.hostname,
+                  path: message.path,
+                  startTime: message.timestamp
+                });
+                if (stopThinkingTimeout) {
+                  clearTimeout(stopThinkingTimeout);
+                  stopThinkingTimeout = null;
+                }
+                updateThinking(true);
+                break;
+              case "fetch-end":
+                activeFetches.delete(message.id);
+                if (activeFetches.size === 0 && thinking && !stopThinkingTimeout) {
+                  stopThinkingTimeout = setTimeout(() => {
+                    if (activeFetches.size === 0) {
+                      updateThinking(false);
+                    }
+                    stopThinkingTimeout = null;
+                  }, 500);
+                }
+                break;
+              default:
+                logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
+            }
+          } catch (e) {
+            logger.debug(`[ClaudeLocal] Non-JSON line from fd3: ${line}`);
+          }
+        });
+        rl.on("error", (err) => {
+          console.error("Error reading from fd 3:", err);
+        });
+        child.on("exit", () => {
+          if (stopThinkingTimeout) {
+            clearTimeout(stopThinkingTimeout);
+          }
+          updateThinking(false);
+        });
+      }
+      child.on("error", (error) => {
+      });
+      child.on("exit", (code, signal) => {
+        if (signal === "SIGTERM" && opts.abort.aborted) {
+          r();
+        } else if (signal) {
+          reject(new Error(`Process terminated with signal: ${signal}`));
+        } else {
+          r();
+        }
+      });
     });
-  }
-  /**
-   * Adds a value to the stream
-   */
-  enqueue(value) {
-    if (this.readResolve) {
-      const resolve = this.readResolve;
-      this.readResolve = void 0;
-      this.readReject = void 0;
-      resolve({ done: false, value });
-    } else {
-      this.queue.push(value);
+  } finally {
+    watcher.close();
+    process.stdin.resume();
+    if (stopThinkingTimeout) {
+      clearTimeout(stopThinkingTimeout);
+      stopThinkingTimeout = null;
     }
+    updateThinking(false);
   }
-  /**
-   * Marks the stream as complete
-   */
-  done() {
-    this.isDone = true;
-    if (this.readResolve) {
-      const resolve = this.readResolve;
-      this.readResolve = void 0;
-      this.readReject = void 0;
-      resolve({ done: true, value: void 0 });
-    }
+  return resolvedSessionId;
+}
+
+class Future {
+  _resolve;
+  _reject;
+  _promise;
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
   }
-  /**
-   * Propagates an error through the stream
-   */
-  error(error) {
-    this.hasError = error;
-    if (this.readReject) {
-      const reject = this.readReject;
-      this.readResolve = void 0;
-      this.readReject = void 0;
-      reject(error);
-    }
+  resolve(value) {
+    this._resolve(value);
   }
-  /**
-   * Implements async iterator cleanup
-   */
-  async return() {
-    this.isDone = true;
-    if (this.returned) {
-      this.returned();
-    }
-    return Promise.resolve({ done: true, value: void 0 });
+  reject(reason) {
+    this._reject(reason);
   }
-}
-
-class AbortError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AbortError";
+  get promise() {
+    return this._promise;
   }
 }
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname$2 = join(__filename, "..");
-function getDefaultClaudeCodePath() {
-  return join(__dirname$2, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+class InvalidateSync {
+  _invalidated = false;
+  _invalidatedDouble = false;
+  _stopped = false;
+  _command;
+  _pendings = [];
+  constructor(command) {
+    this._command = command;
+  }
+  invalidate() {
+    if (this._stopped) {
+      return;
+    }
+    if (!this._invalidated) {
+      this._invalidated = true;
+      this._invalidatedDouble = false;
+      this._doSync();
+    } else {
+      if (!this._invalidatedDouble) {
+        this._invalidatedDouble = true;
+      }
+    }
+  }
+  async invalidateAndAwait() {
+    if (this._stopped) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this._pendings.push(resolve);
+      this.invalidate();
+    });
+  }
+  stop() {
+    if (this._stopped) {
+      return;
+    }
+    this._notifyPendings();
+    this._stopped = true;
+  }
+  _notifyPendings = () => {
+    for (let pending of this._pendings) {
+      pending();
+    }
+    this._pendings = [];
+  };
+  _doSync = async () => {
+    await backoff(async () => {
+      if (this._stopped) {
+        return;
+      }
+      await this._command();
+    });
+    if (this._stopped) {
+      this._notifyPendings();
+      return;
+    }
+    if (this._invalidatedDouble) {
+      this._invalidatedDouble = false;
+      this._doSync();
+    } else {
+      this._invalidated = false;
+      this._notifyPendings();
+    }
+  };
+}
+
+function startFileWatcher(file, onFileChange) {
+  const abortController = new AbortController();
+  void (async () => {
+    while (true) {
+      try {
+        logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
+        const watcher = watch$1(file, { persistent: true, signal: abortController.signal });
+        for await (const event of watcher) {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          logger.debug(`[FILE_WATCHER] File changed: ${file}`);
+          onFileChange(file);
+        }
+      } catch (e) {
+        if (abortController.signal.aborted) {
+          return;
+        }
+        logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, restarting watcher in a second`);
+        await delay(1e3);
+      }
+    }
+  })();
+  return () => {
+    abortController.abort();
+  };
+}
+
+async function createSessionScanner(opts) {
+  const projectDir = getProjectPath(opts.workingDirectory);
+  let finishedSessions = /* @__PURE__ */ new Set();
+  let pendingSessions = /* @__PURE__ */ new Set();
+  let currentSessionId = null;
+  let watchers = /* @__PURE__ */ new Map();
+  let processedMessageKeys = /* @__PURE__ */ new Set();
+  if (opts.sessionId) {
+    let messages = await readSessionLog(projectDir, opts.sessionId);
+    for (let m of messages) {
+      processedMessageKeys.add(messageKey(m));
+    }
+  }
+  const sync = new InvalidateSync(async () => {
+    let sessions = [];
+    for (let p of pendingSessions) {
+      sessions.push(p);
+    }
+    if (currentSessionId) {
+      sessions.push(currentSessionId);
+    }
+    for (let session of sessions) {
+      for (let file of await readSessionLog(projectDir, session)) {
+        let key = messageKey(file);
+        if (processedMessageKeys.has(key)) {
+          continue;
+        }
+        processedMessageKeys.add(key);
+        opts.onMessage(file);
+      }
+    }
+    for (let p of sessions) {
+      if (pendingSessions.has(p)) {
+        pendingSessions.delete(p);
+        finishedSessions.add(p);
+      }
+    }
+    for (let p of sessions) {
+      if (!watchers.has(p)) {
+        watchers.set(p, startFileWatcher(join(projectDir, `${p}.jsonl`), () => {
+          sync.invalidate();
+        }));
+      }
+    }
+  });
+  await sync.invalidateAndAwait();
+  const intervalId = setInterval(() => {
+    sync.invalidate();
+  }, 3e3);
+  return {
+    cleanup: async () => {
+      clearInterval(intervalId);
+      for (let w of watchers.values()) {
+        w();
+      }
+      watchers.clear();
+      await sync.invalidateAndAwait();
+      sync.stop();
+    },
+    onNewSession: (sessionId) => {
+      if (currentSessionId === sessionId) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        return;
+      }
+      if (finishedSessions.has(sessionId)) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        return;
+      }
+      if (pendingSessions.has(sessionId)) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        return;
+      }
+      if (currentSessionId) {
+        pendingSessions.add(currentSessionId);
+      }
+      logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
+      currentSessionId = sessionId;
+      sync.invalidate();
+    }
+  };
+}
+function messageKey(message) {
+  if (message.type === "user") {
+    return message.uuid;
+  } else if (message.type === "assistant") {
+    return message.uuid;
+  } else if (message.type === "summary") {
+    return "summary: " + message.leafUuid + ": " + message.summary;
+  } else if (message.type === "system") {
+    return message.uuid;
+  } else {
+    throw Error();
+  }
+}
+async function readSessionLog(projectDir, sessionId) {
+  const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
+  let file;
+  try {
+    file = await readFile(expectedSessionFile, "utf-8");
+  } catch (error) {
+    logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
+    return [];
+  }
+  let lines = file.split("\n");
+  let messages = [];
+  for (let l of lines) {
+    try {
+      if (l.trim() === "") {
+        continue;
+      }
+      let message = JSON.parse(l);
+      let parsed = RawJSONLinesSchema.safeParse(message);
+      if (!parsed.success) {
+        logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
+        continue;
+      }
+      messages.push(parsed.data);
+    } catch (e) {
+      logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
+      continue;
+    }
+  }
+  return messages;
+}
+
+async function claudeLocalLauncher(session) {
+  const scanner = await createSessionScanner({
+    sessionId: session.sessionId,
+    workingDirectory: session.path,
+    onMessage: (message) => {
+      session.client.sendClaudeSessionMessage(message);
+    }
+  });
+  let exitReason = null;
+  const processAbortController = new AbortController();
+  let exutFuture = new Future();
+  try {
+    async function abort() {
+      if (!processAbortController.signal.aborted) {
+        processAbortController.abort();
+      }
+      await exutFuture.promise;
+    }
+    async function doAbort() {
+      logger.debug("[local]: doAbort");
+      if (!exitReason) {
+        exitReason = "switch";
+      }
+      session.queue.reset();
+      await abort();
+    }
+    async function doSwitch() {
+      logger.debug("[local]: doSwitch");
+      if (!exitReason) {
+        exitReason = "switch";
+      }
+      await abort();
+    }
+    session.client.setHandler("abort", doAbort);
+    session.client.setHandler("switch", doSwitch);
+    session.queue.setOnMessage(doSwitch);
+    if (session.queue.size() > 0) {
+      return "switch";
+    }
+    const handleSessionStart = (sessionId) => {
+      session.onSessionFound(sessionId);
+      scanner.onNewSession(sessionId);
+    };
+    while (true) {
+      if (exitReason) {
+        return exitReason;
+      }
+      logger.debug("[local]: launch");
+      try {
+        await claudeLocal({
+          path: session.path,
+          sessionId: session.sessionId,
+          onSessionFound: handleSessionStart,
+          onThinkingChange: session.onThinkingChange,
+          abort: processAbortController.signal,
+          claudeEnvVars: session.claudeEnvVars,
+          claudeArgs: session.claudeArgs
+        });
+        if (!exitReason) {
+          exitReason = "exit";
+          break;
+        }
+      } catch (e) {
+        logger.debug("[local]: launch error", e);
+        if (!exitReason) {
+          session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          continue;
+        } else {
+          break;
+        }
+      }
+      logger.debug("[local]: launch done");
+    }
+  } finally {
+    exutFuture.resolve(void 0);
+    session.client.setHandler("abort", async () => {
+    });
+    session.client.setHandler("switch", async () => {
+    });
+    session.queue.setOnMessage(null);
+    await scanner.cleanup();
+  }
+  return exitReason || "exit";
+}
+
+class MessageBuffer {
+  messages = [];
+  listeners = [];
+  nextId = 1;
+  addMessage(content, type = "assistant") {
+    const message = {
+      id: `msg-${this.nextId++}`,
+      timestamp: /* @__PURE__ */ new Date(),
+      content,
+      type
+    };
+    this.messages.push(message);
+    this.notifyListeners();
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  clear() {
+    this.messages = [];
+    this.nextId = 1;
+    this.notifyListeners();
+  }
+  onUpdate(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  notifyListeners() {
+    const messages = this.getMessages();
+    this.listeners.forEach((listener) => listener(messages));
+  }
+}
+
+const RemoteModeDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal }) => {
+  const [messages, setMessages] = useState([]);
+  const [confirmationMode, setConfirmationMode] = useState(null);
+  const [actionInProgress, setActionInProgress] = useState(null);
+  const confirmationTimeoutRef = useRef(null);
+  const { stdout } = useStdout();
+  const terminalWidth = stdout.columns || 80;
+  const terminalHeight = stdout.rows || 24;
+  useEffect(() => {
+    setMessages(messageBuffer.getMessages());
+    const unsubscribe = messageBuffer.onUpdate((newMessages) => {
+      setMessages(newMessages);
+    });
+    return () => {
+      unsubscribe();
+      if (confirmationTimeoutRef.current) {
+        clearTimeout(confirmationTimeoutRef.current);
+      }
+    };
+  }, [messageBuffer]);
+  const resetConfirmation = useCallback(() => {
+    setConfirmationMode(null);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+      confirmationTimeoutRef.current = null;
+    }
+  }, []);
+  const setConfirmationWithTimeout = useCallback((mode) => {
+    setConfirmationMode(mode);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+    }
+    confirmationTimeoutRef.current = setTimeout(() => {
+      resetConfirmation();
+    }, 15e3);
+  }, [resetConfirmation]);
+  useInput(useCallback(async (input, key) => {
+    if (actionInProgress) return;
+    if (key.ctrl && input === "c") {
+      if (confirmationMode === "exit") {
+        resetConfirmation();
+        setActionInProgress("exiting");
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        onExit?.();
+      } else {
+        setConfirmationWithTimeout("exit");
+      }
+      return;
+    }
+    if (input === " ") {
+      if (confirmationMode === "switch") {
+        resetConfirmation();
+        setActionInProgress("switching");
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        onSwitchToLocal?.();
+      } else {
+        setConfirmationWithTimeout("switch");
+      }
+      return;
+    }
+    if (confirmationMode) {
+      resetConfirmation();
+    }
+  }, [confirmationMode, actionInProgress, onExit, onSwitchToLocal, setConfirmationWithTimeout, resetConfirmation]));
+  const getMessageColor = (type) => {
+    switch (type) {
+      case "user":
+        return "magenta";
+      case "assistant":
+        return "cyan";
+      case "system":
+        return "blue";
+      case "tool":
+        return "yellow";
+      case "result":
+        return "green";
+      case "status":
+        return "gray";
+      default:
+        return "white";
+    }
+  };
+  const formatMessage = (msg) => {
+    const lines = msg.content.split("\n");
+    const maxLineLength = terminalWidth - 10;
+    return lines.map((line) => {
+      if (line.length <= maxLineLength) return line;
+      const chunks = [];
+      for (let i = 0; i < line.length; i += maxLineLength) {
+        chunks.push(line.slice(i, i + maxLineLength));
+      }
+      return chunks.join("\n");
+    }).join("\n");
+  };
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      flexDirection: "column",
+      width: terminalWidth,
+      height: terminalHeight - 4,
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      overflow: "hidden"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "\u{1F4E1} Remote Mode - Claude Messages"), /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Waiting for messages...") : (
+      // Show only the last messages that fit in the available space
+      messages.slice(-Math.max(1, terminalHeight - 10)).map((msg) => /* @__PURE__ */ React.createElement(Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
+    ))
+  ), /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      width: terminalWidth,
+      borderStyle: "round",
+      borderColor: actionInProgress ? "gray" : confirmationMode === "exit" ? "red" : confirmationMode === "switch" ? "yellow" : "green",
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Exiting...") : actionInProgress === "switching" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Switching to local mode...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit completely") : confirmationMode === "switch" ? /* @__PURE__ */ React.createElement(Text, { color: "yellow", bold: true }, "\u23F8\uFE0F  Press space again to switch to local mode") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "\u{1F4F1} Press space to switch to local mode \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+  ));
+};
+
+class Stream {
+  constructor(returned) {
+    this.returned = returned;
+  }
+  queue = [];
+  readResolve;
+  readReject;
+  isDone = false;
+  hasError;
+  started = false;
+  /**
+   * Implements async iterable protocol
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("Stream can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  /**
+   * Gets the next value from the stream
+   */
+  async next() {
+    if (this.queue.length > 0) {
+      return Promise.resolve({
+        done: false,
+        value: this.queue.shift()
+      });
+    }
+    if (this.isDone) {
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    if (this.hasError) {
+      return Promise.reject(this.hasError);
+    }
+    return new Promise((resolve, reject) => {
+      this.readResolve = resolve;
+      this.readReject = reject;
+    });
+  }
+  /**
+   * Adds a value to the stream
+   */
+  enqueue(value) {
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  /**
+   * Marks the stream as complete
+   */
+  done() {
+    this.isDone = true;
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: true, value: void 0 });
+    }
+  }
+  /**
+   * Propagates an error through the stream
+   */
+  error(error) {
+    this.hasError = error;
+    if (this.readReject) {
+      const reject = this.readReject;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      reject(error);
+    }
+  }
+  /**
+   * Implements async iterator cleanup
+   */
+  async return() {
+    this.isDone = true;
+    if (this.returned) {
+      this.returned();
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+}
+
+class AbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname$1 = join(__filename, "..");
+function getDefaultClaudeCodePath() {
+  return join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
 }
 function logDebug(message) {
   if (process.env.DEBUG) {
@@ -136,9 +834,9 @@ function logDebug(message) {
     console.log(message);
   }
 }
-async function streamToStdin(stream, stdin, abortController) {
+async function streamToStdin(stream, stdin, abort) {
   for await (const message of stream) {
-    if (abortController.signal.aborted) break;
+    if (abort?.aborted) break;
     stdin.write(JSON.stringify(message) + "\n");
   }
   stdin.end();
@@ -254,7 +952,6 @@ class Query {
 function query(config) {
   const {
     prompt,
-    abortController = config.abortController || new AbortController(),
     options: {
       allowedTools = [],
       appendSystemPrompt,
@@ -311,7 +1008,7 @@ function query(config) {
   const child = spawn(executable, [...executableArgs, pathToClaudeCodeExecutable, ...args], {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
-    signal: abortController.signal,
+    signal: config.options?.abort,
     env: {
       ...process.env
     }
@@ -320,7 +1017,7 @@ function query(config) {
   if (typeof prompt === "string") {
     child.stdin.end();
   } else {
-    streamToStdin(prompt, child.stdin, abortController);
+    streamToStdin(prompt, child.stdin, config.options?.abort);
     childStdin = child.stdin;
   }
   if (process.env.DEBUG) {
@@ -333,11 +1030,11 @@ function query(config) {
       child.kill("SIGTERM");
     }
   };
-  abortController.signal.addEventListener("abort", cleanup);
+  config.options?.abort?.addEventListener("abort", cleanup);
   process.on("exit", cleanup);
   const processExitPromise = new Promise((resolve) => {
     child.on("close", (code) => {
-      if (abortController.signal.aborted) {
+      if (config.options?.abort?.aborted) {
         query2.setError(new AbortError("Claude Code process aborted by user"));
       }
       if (code !== 0) {
@@ -349,163 +1046,20 @@ function query(config) {
   });
   const query2 = new Query(childStdin, child.stdout, processExitPromise);
   child.on("error", (error) => {
-    if (abortController.signal.aborted) {
+    if (config.options?.abort?.aborted) {
       query2.setError(new AbortError("Claude Code process aborted by user"));
     } else {
       query2.setError(new Error(`Failed to spawn Claude Code process: ${error.message}`));
     }
-  });
-  processExitPromise.finally(() => {
-    cleanup();
-    abortController.signal.removeEventListener("abort", cleanup);
-    if (process.env.CLAUDE_SDK_MCP_SERVERS) {
-      delete process.env.CLAUDE_SDK_MCP_SERVERS;
-    }
-  });
-  return query2;
-}
-
-function formatClaudeMessage(message, onAssistantResult) {
-  logger.debugLargeJson("[CLAUDE] Message from non interactive & remote mode:", message);
-  switch (message.type) {
-    case "system": {
-      const sysMsg = message;
-      if (sysMsg.subtype === "init") {
-        console.log(chalk.gray("\u2500".repeat(60)));
-        console.log(chalk.blue.bold("\u{1F680} Session initialized:"), chalk.cyan(sysMsg.session_id));
-        console.log(chalk.gray(`  Model: ${sysMsg.model}`));
-        console.log(chalk.gray(`  CWD: ${sysMsg.cwd}`));
-        if (sysMsg.tools && sysMsg.tools.length > 0) {
-          console.log(chalk.gray(`  Tools: ${sysMsg.tools.join(", ")}`));
-        }
-        console.log(chalk.gray("\u2500".repeat(60)));
-      }
-      break;
-    }
-    case "user": {
-      const userMsg = message;
-      if (userMsg.message && typeof userMsg.message === "object" && "content" in userMsg.message) {
-        const content = userMsg.message.content;
-        if (typeof content === "string") {
-          console.log(chalk.magenta.bold("\n\u{1F464} User:"), content);
-        } else if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "text") {
-              console.log(chalk.magenta.bold("\n\u{1F464} User:"), block.text);
-            } else if (block.type === "tool_result") {
-              console.log(chalk.green.bold("\n\u2705 Tool Result:"), chalk.gray(`(Tool ID: ${block.tool_use_id})`));
-              if (block.content) {
-                const outputStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content, null, 2);
-                const maxLength = 200;
-                if (outputStr.length > maxLength) {
-                  console.log(outputStr.substring(0, maxLength) + chalk.gray("\n... (truncated)"));
-                } else {
-                  console.log(outputStr);
-                }
-              }
-            }
-          }
-        } else {
-          console.log(chalk.magenta.bold("\n\u{1F464} User:"), JSON.stringify(content, null, 2));
-        }
-      }
-      break;
-    }
-    case "assistant": {
-      const assistantMsg = message;
-      if (assistantMsg.message && assistantMsg.message.content) {
-        console.log(chalk.cyan.bold("\n\u{1F916} Assistant:"));
-        for (const block of assistantMsg.message.content) {
-          if (block.type === "text") {
-            console.log(block.text);
-          } else if (block.type === "tool_use") {
-            console.log(chalk.yellow.bold(`
-\u{1F527} Tool: ${block.name}`));
-            if (block.input) {
-              const inputStr = JSON.stringify(block.input, null, 2);
-              const maxLength = 500;
-              if (inputStr.length > maxLength) {
-                console.log(chalk.gray("Input:"), inputStr.substring(0, maxLength) + chalk.gray("\n... (truncated)"));
-              } else {
-                console.log(chalk.gray("Input:"), inputStr);
-              }
-            }
-          }
-        }
-      }
-      break;
-    }
-    case "result": {
-      const resultMsg = message;
-      if (resultMsg.subtype === "success") {
-        if ("result" in resultMsg && resultMsg.result) {
-          console.log(chalk.green.bold("\n\u2728 Summary:"));
-          console.log(resultMsg.result);
-        }
-        if (resultMsg.usage) {
-          console.log(chalk.gray("\n\u{1F4CA} Session Stats:"));
-          console.log(chalk.gray(`  \u2022 Turns: ${resultMsg.num_turns}`));
-          console.log(chalk.gray(`  \u2022 Input tokens: ${resultMsg.usage.input_tokens}`));
-          console.log(chalk.gray(`  \u2022 Output tokens: ${resultMsg.usage.output_tokens}`));
-          if (resultMsg.usage.cache_read_input_tokens) {
-            console.log(chalk.gray(`  \u2022 Cache read tokens: ${resultMsg.usage.cache_read_input_tokens}`));
-          }
-          if (resultMsg.usage.cache_creation_input_tokens) {
-            console.log(chalk.gray(`  \u2022 Cache creation tokens: ${resultMsg.usage.cache_creation_input_tokens}`));
-          }
-          console.log(chalk.gray(`  \u2022 Cost: $${resultMsg.total_cost_usd.toFixed(4)}`));
-          console.log(chalk.gray(`  \u2022 Duration: ${resultMsg.duration_ms}ms`));
-          console.log(chalk.gray("\n\u{1F440} Back already?"));
-          console.log(chalk.green("\u{1F449} Press any key to continue your session in `claude`"));
-          if (onAssistantResult) {
-            Promise.resolve(onAssistantResult(resultMsg)).catch((err) => {
-              logger.debug("Error in onAssistantResult callback:", err);
-            });
-          }
-        }
-      } else if (resultMsg.subtype === "error_max_turns") {
-        console.log(chalk.red.bold("\n\u274C Error: Maximum turns reached"));
-        console.log(chalk.gray(`Completed ${resultMsg.num_turns} turns`));
-      } else if (resultMsg.subtype === "error_during_execution") {
-        console.log(chalk.red.bold("\n\u274C Error during execution"));
-        console.log(chalk.gray(`Completed ${resultMsg.num_turns} turns before error`));
-        logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
-      }
-      break;
-    }
-    default: {
-      if (process.env.DEBUG) {
-        console.log(chalk.gray(`[Unknown message type: ${message.type}]`));
-      }
-    }
-  }
-}
-function printDivider() {
-  console.log(chalk.gray("\u2550".repeat(60)));
-}
-
-function getProjectPath(workingDirectory) {
-  const projectId = resolve(workingDirectory).replace(/[\\\/\.:]/g, "-");
-  return join(homedir(), ".claude", "projects", projectId);
-}
-
-function claudeCheckSession(sessionId, path) {
-  const projectDir = getProjectPath(path);
-  const sessionFile = join(projectDir, `${sessionId}.jsonl`);
-  const sessionExists = existsSync(sessionFile);
-  if (!sessionExists) {
-    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
-    return false;
-  }
-  const sessionData = readFileSync(sessionFile, "utf-8").split("\n");
-  const hasGoodMessage = !!sessionData.find((v) => {
-    try {
-      return typeof JSON.parse(v).uuid === "string";
-    } catch (e) {
-      return false;
+  });
+  processExitPromise.finally(() => {
+    cleanup();
+    config.options?.abort?.removeEventListener("abort", cleanup);
+    if (process.env.CLAUDE_SDK_MCP_SERVERS) {
+      delete process.env.CLAUDE_SDK_MCP_SERVERS;
     }
   });
-  return hasGoodMessage;
+  return query2;
 }
 
 async function awaitFileExist(file, timeout = 1e4) {
@@ -521,1057 +1075,1252 @@ async function awaitFileExist(file, timeout = 1e4) {
   return false;
 }
 
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  if (typeof a !== "object" || typeof b !== "object") return false;
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) return false;
-  for (const key of keysA) {
-    if (!keysB.includes(key)) return false;
-    if (!deepEqual(a[key], b[key])) return false;
-  }
-  return true;
-}
-async function claudeRemote(opts) {
-  let startFrom = opts.sessionId;
-  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
-    startFrom = null;
-  }
-  if (opts.claudeEnvVars) {
-    Object.entries(opts.claudeEnvVars).forEach(([key, value]) => {
-      process.env[key] = value;
-    });
-  }
-  const abortController = new AbortController();
-  const sdkOptions = {
-    cwd: opts.path,
-    resume: startFrom ?? void 0,
-    mcpServers: opts.mcpServers,
-    permissionPromptToolName: opts.permissionPromptToolName,
-    permissionMode: opts.permissionMode,
-    executable: "node",
-    abortController
-  };
-  if (opts.claudeArgs && opts.claudeArgs.length > 0) {
-    sdkOptions.executableArgs = [...sdkOptions.executableArgs || [], ...opts.claudeArgs];
-  }
-  let aborted = false;
-  let response;
-  opts.abort.addEventListener("abort", () => {
-    if (!aborted) {
-      aborted = true;
-      if (response) {
-        (async () => {
-          try {
-            await response.interrupt();
-          } catch (e) {
-          }
-          abortController.abort();
-        })();
-      } else {
-        abortController.abort();
-      }
-    }
-  });
-  logger.debug(`[claudeRemote] Starting query with permission mode: ${opts.permissionMode}`);
-  response = query({
-    prompt: opts.message,
-    options: sdkOptions
-  });
-  if (opts.interruptController) {
-    opts.interruptController.register(async () => {
-      logger.debug("[claudeRemote] Interrupting Claude via SDK");
-      await response.interrupt();
-    });
-  }
-  printDivider();
-  let thinking = false;
-  const updateThinking = (newThinking) => {
-    if (thinking !== newThinking) {
-      thinking = newThinking;
-      logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
-      if (opts.onThinkingChange) {
-        opts.onThinkingChange(thinking);
-      }
-    }
-  };
-  const toolCalls = [];
-  const resolveToolCallId = (name, args) => {
-    for (let i = toolCalls.length - 1; i >= 0; i--) {
-      const call = toolCalls[i];
-      if (call.name === name && deepEqual(call.input, args)) {
-        if (call.used) {
-          logger.debug("[claudeRemote] Warning: Permission request matched an already-used tool call");
-          return null;
-        }
-        call.used = true;
-        logger.debug(`[claudeRemote] Resolved tool call ID: ${call.id} for ${name}`);
-        return call.id;
-      }
-    }
-    logger.debug(`[claudeRemote] No matching tool call found for permission request: ${name}`);
-    return null;
-  };
-  if (opts.onToolCallResolver) {
-    opts.onToolCallResolver(resolveToolCallId);
+class PushableAsyncIterable {
+  queue = [];
+  waiters = [];
+  isDone = false;
+  error = null;
+  started = false;
+  constructor() {
   }
-  try {
-    logger.debug(`[claudeRemote] Starting to iterate over response`);
-    for await (const message of response) {
-      logger.debugLargeJson(`[claudeRemote] Message ${message.type}`, message);
-      formatClaudeMessage(message, opts.onAssistantResult);
-      if (message.type === "assistant") {
-        const assistantMsg = message;
-        if (assistantMsg.message && assistantMsg.message.content) {
-          for (const block of assistantMsg.message.content) {
-            if (block.type === "tool_use") {
-              toolCalls.push({
-                id: block.id,
-                name: block.name,
-                input: block.input,
-                used: false
-              });
-              logger.debug(`[claudeRemote] Tracked tool call: ${block.id} - ${block.name}`);
-            }
-          }
-        }
-      }
-      if (message.type === "user") {
-        const userMsg = message;
-        if (userMsg.message && userMsg.message.content && Array.isArray(userMsg.message.content)) {
-          for (const block of userMsg.message.content) {
-            if (block.type === "tool_result" && block.tool_use_id) {
-              const toolCall = toolCalls.find((tc) => tc.id === block.tool_use_id);
-              if (toolCall && !toolCall.used) {
-                toolCall.used = true;
-                logger.debug(`[claudeRemote] Tool completed execution, marked as used: ${block.tool_use_id}`);
-              }
-            }
-          }
-        }
-      }
-      if (message.type === "system" && message.subtype === "init") {
-        updateThinking(true);
-        const systemInit = message;
-        if (systemInit.session_id) {
-          logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
-          const projectDir = getProjectPath(opts.path);
-          const found = await awaitFileExist(join(projectDir, `${systemInit.session_id}.jsonl`));
-          logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
-          opts.onSessionFound(systemInit.session_id);
-        }
-      }
-      if (message.type === "result") {
-        updateThinking(false);
-        logger.debug("[claudeRemote] Result received, exiting claudeRemote");
-        break;
-      }
+  /**
+   * Push a value to the iterable
+   */
+  push(value) {
+    if (this.isDone) {
+      throw new Error("Cannot push to completed iterable");
     }
-    logger.debug(`[claudeRemote] Finished iterating over response`);
-  } catch (e) {
-    if (abortController.signal.aborted) {
-      logger.debug(`[claudeRemote] Aborted`);
+    if (this.error) {
+      throw this.error;
     }
-    if (e instanceof AbortError) {
-      logger.debug(`[claudeRemote] Aborted`);
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ done: false, value });
     } else {
-      throw e;
-    }
-  } finally {
-    updateThinking(false);
-    toolCalls.length = 0;
-    if (opts.onToolCallResolver) {
-      opts.onToolCallResolver(null);
-    }
-    if (opts.interruptController) {
-      opts.interruptController.unregister();
-    }
-  }
-  printDivider();
-  logger.debug(`[claudeRemote] Function completed`);
-}
-
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-async function claudeLocal(opts) {
-  const projectDir = getProjectPath(opts.path);
-  mkdirSync(projectDir, { recursive: true });
-  const watcher = watch(projectDir);
-  let resolvedSessionId = null;
-  const detectedIdsRandomUUID = /* @__PURE__ */ new Set();
-  const detectedIdsFileSystem = /* @__PURE__ */ new Set();
-  watcher.on("change", (event, filename) => {
-    if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
-      logger.debug("change", event, filename);
-      const sessionId = filename.replace(".jsonl", "");
-      if (detectedIdsFileSystem.has(sessionId)) {
-        return;
-      }
-      detectedIdsFileSystem.add(sessionId);
-      if (resolvedSessionId) {
-        return;
-      }
-      if (detectedIdsRandomUUID.has(sessionId)) {
-        resolvedSessionId = sessionId;
-        opts.onSessionFound(sessionId);
-      }
+      this.queue.push(value);
     }
-  });
-  let startFrom = opts.sessionId;
-  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
-    startFrom = null;
-  }
-  try {
-    process.stdin.pause();
-    await new Promise((r, reject) => {
-      const args = [];
-      if (startFrom) {
-        args.push("--resume", startFrom);
-      }
-      if (opts.claudeArgs) {
-        args.push(...opts.claudeArgs);
-      }
-      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || resolve(join(__dirname$1, "..", "scripts", "claudeInteractiveLaunch.cjs"));
-      const env = {
-        ...process.env,
-        ...opts.claudeEnvVars
-      };
-      const child = spawn("node", [claudeCliPath, ...args], {
-        stdio: ["inherit", "inherit", "inherit", "pipe"],
-        signal: opts.abort,
-        cwd: opts.path,
-        env
-      });
-      if (child.stdio[3]) {
-        const rl = createInterface({
-          input: child.stdio[3],
-          crlfDelay: Infinity
-        });
-        const activeFetches = /* @__PURE__ */ new Map();
-        let thinking = false;
-        let stopThinkingTimeout = null;
-        const updateThinking = (newThinking) => {
-          if (thinking !== newThinking) {
-            thinking = newThinking;
-            logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
-            if (opts.onThinkingChange) {
-              opts.onThinkingChange(thinking);
-            }
-          }
-        };
-        rl.on("line", (line) => {
-          try {
-            const message = JSON.parse(line);
-            switch (message.type) {
-              case "uuid":
-                detectedIdsRandomUUID.add(message.value);
-                if (!resolvedSessionId && detectedIdsFileSystem.has(message.value)) {
-                  resolvedSessionId = message.value;
-                  opts.onSessionFound(message.value);
-                }
-                break;
-              case "fetch-start":
-                logger.debug(`[ClaudeLocal] Fetch start: ${message.method} ${message.hostname}${message.path} (id: ${message.id})`);
-                activeFetches.set(message.id, {
-                  hostname: message.hostname,
-                  path: message.path,
-                  startTime: message.timestamp
-                });
-                if (stopThinkingTimeout) {
-                  clearTimeout(stopThinkingTimeout);
-                  stopThinkingTimeout = null;
-                }
-                updateThinking(true);
-                break;
-              case "fetch-end":
-                logger.debug(`[ClaudeLocal] Fetch end: id ${message.id}`);
-                activeFetches.delete(message.id);
-                if (activeFetches.size === 0 && thinking && !stopThinkingTimeout) {
-                  stopThinkingTimeout = setTimeout(() => {
-                    if (activeFetches.size === 0) {
-                      updateThinking(false);
-                    }
-                    stopThinkingTimeout = null;
-                  }, 500);
-                }
-                break;
-              default:
-                logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
-            }
-          } catch (e) {
-            logger.debug(`[ClaudeLocal] Non-JSON line from fd3: ${line}`);
-          }
-        });
-        rl.on("error", (err) => {
-          console.error("Error reading from fd 3:", err);
-        });
-        child.on("exit", () => {
-          if (stopThinkingTimeout) {
-            clearTimeout(stopThinkingTimeout);
-          }
-          updateThinking(false);
-        });
-      }
-      child.on("error", (error) => {
-      });
-      child.on("exit", (code, signal) => {
-        if (signal === "SIGTERM" && opts.abort.aborted) {
-          r();
-        } else if (signal) {
-          reject(new Error(`Process terminated with signal: ${signal}`));
-        } else {
-          r();
-        }
-      });
-    });
-  } finally {
-    watcher.close();
-    process.stdin.resume();
   }
-  return resolvedSessionId;
-}
-
-class MessageQueue2 {
-  constructor(modeHasher) {
-    this.modeHasher = modeHasher;
-    logger.debug(`[MessageQueue2] Initialized`);
+  /**
+   * Mark the iterable as complete
+   */
+  end() {
+    if (this.isDone) {
+      return;
+    }
+    this.isDone = true;
+    this.cleanup();
   }
-  queue = [];
-  waiter = null;
-  closed = false;
   /**
-   * Push a message to the queue with a mode.
+   * Set an error on the iterable
    */
-  push(message, mode) {
-    if (this.closed) {
-      throw new Error("Cannot push to closed queue");
+  setError(err) {
+    if (this.isDone) {
+      return;
     }
-    const modeHash = this.modeHasher(mode);
-    logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
-    this.queue.push({
-      message,
-      mode,
-      modeHash
-    });
-    if (this.waiter) {
-      logger.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
+    this.error = err;
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Cleanup waiting consumers
+   */
+  cleanup() {
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      if (this.error) {
+        waiter.reject(this.error);
+      } else {
+        waiter.resolve({ done: true, value: void 0 });
+      }
     }
-    logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
   }
   /**
-   * Push a message to the beginning of the queue with a mode.
+   * AsyncIterableIterator implementation
    */
-  unshift(message, mode) {
-    if (this.closed) {
-      throw new Error("Cannot unshift to closed queue");
+  async next() {
+    if (this.queue.length > 0) {
+      return { done: false, value: this.queue.shift() };
     }
-    const modeHash = this.modeHasher(mode);
-    logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
-    this.queue.unshift({
-      message,
-      mode,
-      modeHash
-    });
-    if (this.waiter) {
-      logger.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
+    if (this.isDone) {
+      if (this.error) {
+        throw this.error;
+      }
+      return { done: true, value: void 0 };
     }
-    logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
   }
   /**
-   * Close the queue - no more messages can be pushed
+   * AsyncIterableIterator return implementation
    */
-  close() {
-    logger.debug(`[MessageQueue2] close() called`);
-    this.closed = true;
-    if (this.waiter) {
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(false);
+  async return(_value) {
+    this.end();
+    return { done: true, value: void 0 };
+  }
+  /**
+   * AsyncIterableIterator throw implementation
+   */
+  async throw(e) {
+    this.setError(e instanceof Error ? e : new Error(String(e)));
+    throw this.error;
+  }
+  /**
+   * Make this iterable
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("PushableAsyncIterable can only be iterated once");
     }
+    this.started = true;
+    return this;
   }
   /**
-   * Check if the queue is closed
+   * Check if the iterable is done
    */
-  isClosed() {
-    return this.closed;
+  get done() {
+    return this.isDone;
+  }
+  /**
+   * Check if the iterable has an error
+   */
+  get hasError() {
+    return this.error !== null;
   }
   /**
    * Get the current queue size
    */
-  size() {
+  get queueSize() {
     return this.queue.length;
   }
   /**
-   * Wait for messages and return all messages with the same mode as a single string
-   * Returns { message: string, mode: T } or null if aborted/closed
+   * Get the number of waiting consumers
    */
-  async waitForMessagesAndGetAsString(abortSignal) {
-    if (this.queue.length > 0) {
-      return this.collectBatch();
+  get waiterCount() {
+    return this.waiters.length;
+  }
+}
+
+async function claudeRemote(opts) {
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
+  }
+  if (opts.claudeEnvVars) {
+    Object.entries(opts.claudeEnvVars).forEach(([key, value]) => {
+      process.env[key] = value;
+    });
+  }
+  let response;
+  const sdkOptions = {
+    cwd: opts.path,
+    resume: startFrom ?? void 0,
+    mcpServers: opts.mcpServers,
+    permissionPromptToolName: opts.permissionPromptToolName,
+    permissionMode: opts.permissionMode,
+    executable: "node",
+    abort: opts.signal
+  };
+  if (opts.claudeArgs && opts.claudeArgs.length > 0) {
+    sdkOptions.executableArgs = [...sdkOptions.executableArgs || [], ...opts.claudeArgs];
+  }
+  logger.debug(`[claudeRemote] Starting query with permission mode: ${opts.permissionMode}`);
+  let message = new PushableAsyncIterable();
+  message.push({
+    type: "user",
+    message: {
+      role: "user",
+      content: opts.message
     }
-    if (this.closed || abortSignal?.aborted) {
-      return null;
+  });
+  message.end();
+  response = query({
+    prompt: message,
+    options: sdkOptions
+  });
+  let thinking = false;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
     }
-    const hasMessages = await this.waitForMessages(abortSignal);
-    if (!hasMessages) {
-      return null;
+  };
+  updateThinking(true);
+  try {
+    logger.debug(`[claudeRemote] Starting to iterate over response`);
+    for await (const message2 of response) {
+      logger.debugLargeJson(`[claudeRemote] Message ${message2.type}`, message2);
+      opts.onMessage(message2);
+      if (message2.type === "system" && message2.subtype === "init") {
+        updateThinking(true);
+        const systemInit = message2;
+        if (systemInit.session_id) {
+          logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
+          const projectDir = getProjectPath(opts.path);
+          const found = await awaitFileExist(join(projectDir, `${systemInit.session_id}.jsonl`));
+          logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
+          opts.onSessionFound(systemInit.session_id);
+        }
+      }
+      if (message2.type === "result") {
+        updateThinking(false);
+        logger.debug("[claudeRemote] Result received, exiting claudeRemote");
+        return;
+      }
+      if (message2.type === "user") {
+        const msg = message2;
+        if (msg.message.role === "user" && Array.isArray(msg.message.content)) {
+          for (let c of msg.message.content) {
+            if (c.type === "tool_result" && (c.name === "exit_plan_mode" || c.name === "ExitPlanMode")) {
+              logger.debug("[claudeRemote] Plan result received, exiting claudeRemote");
+              return;
+            }
+            if (c.type === "tool_result" && c.tool_use_id && opts.responses.has(c.tool_use_id) && !opts.responses.get(c.tool_use_id).approved) {
+              logger.debug("[claudeRemote] Tool rejected, exiting claudeRemote");
+              return;
+            }
+          }
+        }
+      }
     }
-    return this.collectBatch();
-  }
-  /**
-   * Collect a batch of messages with the same mode
-   */
-  collectBatch() {
-    if (this.queue.length === 0) {
-      return null;
+    logger.debug(`[claudeRemote] Finished iterating over response`);
+  } catch (e) {
+    if (e instanceof AbortError) {
+      logger.debug(`[claudeRemote] Aborted`);
+    } else {
+      throw e;
     }
-    const firstItem = this.queue[0];
-    const sameModeMessages = [];
-    let mode = firstItem.mode;
-    const targetModeHash = firstItem.modeHash;
-    while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash) {
-      const item = this.queue.shift();
-      sameModeMessages.push(item.message);
+  } finally {
+    updateThinking(false);
+  }
+  logger.debug(`[claudeRemote] Function completed`);
+}
+
+const PLAN_FAKE_REJECT = `User approved plan, but you need to be restarted. STOP IMMEDIATELY TO SWITCH FROM PLAN MODE. DO NOT REPLY TO THIS MESSAGE.`;
+const PLAN_FAKE_RESTART = `PlEaZe Continue with plan.`;
+
+async function startPermissionServerV2(handler) {
+  const mcp = new McpServer({
+    name: "Permission Server",
+    version: "1.0.0",
+    description: "A server that allows you to request permissions from the user"
+  });
+  mcp.registerTool("ask_permission", {
+    description: "Request permission to execute a tool",
+    title: "Request Permission",
+    inputSchema: {
+      tool_name: z$1.string().describe("The tool that needs permission"),
+      input: z$1.any().describe("The arguments for the tool")
     }
-    const combinedMessage = sameModeMessages.join("\n");
-    logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
+  }, async (args) => {
+    const response = await handler({ name: args.tool_name, arguments: args.input });
+    logger.debugLargeJson("[permissionServerV2] Response", response);
+    const result = response.approved ? { behavior: "allow", updatedInput: args.input || {} } : { behavior: "deny", message: response.reason || `The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.` };
     return {
-      message: combinedMessage,
-      mode
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result)
+        }
+      ],
+      isError: false
     };
+  });
+  const transport = new StreamableHTTPServerTransport({
+    // NOTE: Returning session id here will result in claude
+    // sdk spawn to fail with `Invalid Request: Server already initialized`
+    sessionIdGenerator: void 0
+  });
+  await mcp.connect(transport);
+  const server = createServer(async (req, res) => {
+    try {
+      await transport.handleRequest(req, res);
+    } catch (error) {
+      logger.debug("Error handling request:", error);
+      if (!res.headersSent) {
+        res.writeHead(500).end();
+      }
+    }
+  });
+  const baseUrl = await new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve(new URL(`http://127.0.0.1:${addr.port}`));
+    });
+  });
+  return {
+    url: baseUrl.toString(),
+    toolName: "ask_permission",
+    stop: () => {
+      mcp.close();
+      server.close();
+    }
+  };
+}
+
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
   }
-  /**
-   * Wait for messages to arrive
-   */
-  waitForMessages(abortSignal) {
-    return new Promise((resolve) => {
-      let abortHandler = null;
-      if (abortSignal) {
-        abortHandler = () => {
-          logger.debug("[MessageQueue2] Wait aborted");
-          if (this.waiter === waiterFunc) {
-            this.waiter = null;
+  return true;
+}
+
+async function startPermissionResolver(session) {
+  let toolCalls = [];
+  let responses = /* @__PURE__ */ new Map();
+  let requests = /* @__PURE__ */ new Map();
+  let pendingPermissionRequests = [];
+  const server = await startPermissionServerV2(async (request) => {
+    const id = resolveToolCallId(request.name, request.arguments);
+    if (!id) {
+      logger.debug(`Tool call ID not yet available for ${request.name}, queueing request`);
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          const idx = pendingPermissionRequests.findIndex((p) => p.request === request);
+          if (idx !== -1) {
+            pendingPermissionRequests.splice(idx, 1);
+            reject(new Error(`Timeout: Tool call ID never arrived for ${request.name}`));
+          }
+        }, 3e4);
+        pendingPermissionRequests.push({ request, resolve, reject, timeout });
+      });
+    }
+    return handlePermissionRequest(id, request);
+  });
+  function handlePermissionRequest(id, request) {
+    let promise = new Promise((resolve) => {
+      if (request.name === "exit_plan_mode" || request.name === "ExitPlanMode") {
+        const wrappedResolve = (response) => {
+          if (response.approved) {
+            logger.debug("Plan approved - injecting PLAN_FAKE_RESTART");
+            if (response.mode && ["default", "acceptEdits", "bypassPermissions"].includes(response.mode)) {
+              session.queue.unshift(PLAN_FAKE_RESTART, response.mode);
+            } else {
+              session.queue.unshift(PLAN_FAKE_RESTART, "default");
+            }
+            resolve({ approved: false, reason: PLAN_FAKE_REJECT });
+          } else {
+            resolve(response);
           }
-          resolve(false);
         };
-        abortSignal.addEventListener("abort", abortHandler);
+        requests.set(id, wrappedResolve);
+      } else {
+        requests.set(id, resolve);
       }
-      const waiterFunc = (hasMessages) => {
-        if (abortHandler && abortSignal) {
-          abortSignal.removeEventListener("abort", abortHandler);
-        }
-        resolve(hasMessages);
-      };
-      if (this.queue.length > 0) {
-        if (abortHandler && abortSignal) {
-          abortSignal.removeEventListener("abort", abortHandler);
-        }
-        resolve(true);
-        return;
+    });
+    let timeout = setTimeout(async () => {
+      logger.debug("Permission timeout - attempting to interrupt Claude");
+      requests.delete(id);
+      session.client.updateAgentState((currentState) => {
+        const request2 = currentState.requests?.[id];
+        if (!request2) return currentState;
+        let r = { ...currentState.requests };
+        delete r[id];
+        return {
+          ...currentState,
+          requests: r,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [id]: {
+              ...request2,
+              completedAt: Date.now(),
+              status: "canceled",
+              reason: "Timeout"
+            }
+          }
+        };
+      });
+    }, 1e3 * 60 * 4.5);
+    logger.debug("Permission request" + id + " " + JSON.stringify(request));
+    session.api.push().sendToAllDevices(
+      "Permission Request",
+      `Claude wants to use ${request.name}`,
+      {
+        sessionId: session.client.sessionId,
+        requestId: id,
+        tool: request.name,
+        type: "permission_request"
       }
-      if (this.closed || abortSignal?.aborted) {
-        if (abortHandler && abortSignal) {
-          abortSignal.removeEventListener("abort", abortHandler);
+    );
+    session.client.updateAgentState((currentState) => ({
+      ...currentState,
+      requests: {
+        ...currentState.requests,
+        [id]: {
+          tool: request.name,
+          arguments: request.arguments,
+          createdAt: Date.now()
         }
-        resolve(false);
-        return;
       }
-      this.waiter = waiterFunc;
-      logger.debug("[MessageQueue2] Waiting for messages...");
-    });
-  }
-}
-
-var MessageQueue2$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    MessageQueue2: MessageQueue2
-});
-
-class InvalidateSync {
-  _invalidated = false;
-  _invalidatedDouble = false;
-  _stopped = false;
-  _command;
-  _pendings = [];
-  constructor(command) {
-    this._command = command;
+    }));
+    promise.then(() => clearTimeout(timeout)).catch(() => clearTimeout(timeout));
+    return promise;
   }
-  invalidate() {
-    if (this._stopped) {
-      return;
-    }
-    if (!this._invalidated) {
-      this._invalidated = true;
-      this._invalidatedDouble = false;
-      this._doSync();
+  session.client.setHandler("permission", async (message) => {
+    logger.debug("Permission response" + JSON.stringify(message));
+    const id = message.id;
+    const resolve = requests.get(id);
+    if (resolve) {
+      responses.set(id, message);
+      resolve({ approved: message.approved, reason: message.reason, mode: message.mode });
+      requests.delete(id);
     } else {
-      if (!this._invalidatedDouble) {
-        this._invalidatedDouble = true;
-      }
-    }
-  }
-  async invalidateAndAwait() {
-    if (this._stopped) {
+      logger.debug("Permission request stale, likely timed out");
       return;
     }
-    await new Promise((resolve) => {
-      this._pendings.push(resolve);
-      this.invalidate();
+    session.client.updateAgentState((currentState) => {
+      const request = currentState.requests?.[id];
+      if (!request) return currentState;
+      let r = { ...currentState.requests };
+      delete r[id];
+      const isExitPlanModeSuccess = request.tool === "exit_plan_mode" && !message.approved && message.reason === PLAN_FAKE_REJECT;
+      return {
+        ...currentState,
+        requests: r,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [id]: {
+            ...request,
+            completedAt: Date.now(),
+            status: isExitPlanModeSuccess ? "approved" : message.approved ? "approved" : "denied",
+            reason: isExitPlanModeSuccess ? "Plan approved" : message.reason
+          }
+        }
+      };
     });
-  }
-  stop() {
-    if (this._stopped) {
-      return;
-    }
-    this._notifyPendings();
-    this._stopped = true;
-  }
-  _notifyPendings = () => {
-    for (let pending of this._pendings) {
-      pending();
+  });
+  const resolveToolCallId = (name, args) => {
+    for (let i = toolCalls.length - 1; i >= 0; i--) {
+      const call = toolCalls[i];
+      if (call.name === name && deepEqual(call.input, args)) {
+        if (call.used) {
+          return null;
+        }
+        call.used = true;
+        return call.id;
+      }
     }
-    this._pendings = [];
+    return null;
   };
-  _doSync = async () => {
-    await backoff(async () => {
-      if (this._stopped) {
-        return;
+  function reset() {
+    toolCalls = [];
+    requests.clear();
+    responses.clear();
+    for (const pending of pendingPermissionRequests) {
+      clearTimeout(pending.timeout);
+    }
+    pendingPermissionRequests = [];
+    session.client.updateAgentState((currentState) => {
+      const pendingRequests = currentState.requests || {};
+      const completedRequests = { ...currentState.completedRequests };
+      for (const [id, request] of Object.entries(pendingRequests)) {
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason: "Session switched to local mode"
+        };
       }
-      await this._command();
+      return {
+        ...currentState,
+        requests: {},
+        // Clear all pending requests
+        completedRequests
+      };
     });
-    if (this._stopped) {
-      this._notifyPendings();
-      return;
-    }
-    if (this._invalidatedDouble) {
-      this._invalidatedDouble = false;
-      this._doSync();
-    } else {
-      this._invalidated = false;
-      this._notifyPendings();
-    }
-  };
-}
-
-function startFileWatcher(file, onFileChange) {
-  const abortController = new AbortController();
-  void (async () => {
-    while (true) {
-      try {
-        logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
-        const watcher = watch$1(file, { persistent: true, signal: abortController.signal });
-        for await (const event of watcher) {
-          if (abortController.signal.aborted) {
-            return;
+  }
+  function onMessage(message) {
+    if (message.type === "assistant") {
+      const assistantMsg = message;
+      if (assistantMsg.message && assistantMsg.message.content) {
+        for (const block of assistantMsg.message.content) {
+          if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              name: block.name,
+              input: block.input,
+              used: false
+            });
+            for (let i = pendingPermissionRequests.length - 1; i >= 0; i--) {
+              const pending = pendingPermissionRequests[i];
+              if (pending.request.name === block.name && deepEqual(pending.request.arguments, block.input)) {
+                logger.debug(`Resolving pending permission request for ${block.name} with ID ${block.id}`);
+                clearTimeout(pending.timeout);
+                pendingPermissionRequests.splice(i, 1);
+                handlePermissionRequest(block.id, pending.request).then(
+                  pending.resolve,
+                  pending.reject
+                );
+                break;
+              }
+            }
           }
-          logger.debug(`[FILE_WATCHER] File changed: ${file}`);
-          onFileChange(file);
         }
-      } catch (e) {
-        if (abortController.signal.aborted) {
-          return;
+      }
+    }
+    if (message.type === "user") {
+      const userMsg = message;
+      if (userMsg.message && userMsg.message.content && Array.isArray(userMsg.message.content)) {
+        for (const block of userMsg.message.content) {
+          if (block.type === "tool_result" && block.tool_use_id) {
+            const toolCall = toolCalls.find((tc) => tc.id === block.tool_use_id);
+            if (toolCall && !toolCall.used) {
+              toolCall.used = true;
+            }
+          }
         }
-        logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, restarting watcher in a second`);
-        await delay(1e3);
       }
     }
-  })();
-  return () => {
-    abortController.abort();
+  }
+  return {
+    server,
+    reset,
+    onMessage,
+    responses
   };
 }
 
-const PLAN_FAKE_REJECT = `User approved plan, but you need to be restarted. STOP IMMEDIATELY TO SWITCH FROM PLAN MODE. DO NOT REPLY TO THIS MESSAGE.`;
-const PLAN_FAKE_RESTART = `PlEaZe Continue with plan.`;
-
-function hackToolResponse(message) {
-  logger.debug("hackToolResponse", JSON.stringify(message, null, 2));
-  if (message.type === "user" && message.message?.role === "user" && message.message?.content && Array.isArray(message.message.content)) {
-    let modified = false;
-    const hackedContent = message.message.content.map((item) => {
-      if (item.type === "tool_result" && item.is_error === true) {
-        if (item.content === PLAN_FAKE_REJECT) {
-          logger.debug(`[SESSION_SCANNER] Hacking exit_plan_mode tool_result: flipping is_error from true to false`);
-          modified = true;
-          return {
-            ...item,
-            is_error: false,
-            content: "Plan approved"
-          };
+function formatClaudeMessageForInk(message, messageBuffer, onAssistantResult) {
+  logger.debugLargeJson("[CLAUDE INK] Message from remote mode:", message);
+  switch (message.type) {
+    case "system": {
+      const sysMsg = message;
+      if (sysMsg.subtype === "init") {
+        messageBuffer.addMessage("\u2500".repeat(40), "status");
+        messageBuffer.addMessage(`\u{1F680} Session initialized: ${sysMsg.session_id}`, "system");
+        messageBuffer.addMessage(`  Model: ${sysMsg.model}`, "status");
+        messageBuffer.addMessage(`  CWD: ${sysMsg.cwd}`, "status");
+        if (sysMsg.tools && sysMsg.tools.length > 0) {
+          messageBuffer.addMessage(`  Tools: ${sysMsg.tools.join(", ")}`, "status");
         }
+        messageBuffer.addMessage("\u2500".repeat(40), "status");
       }
-      return item;
-    });
-    if (modified) {
-      return {
-        ...message,
-        message: {
-          ...message.message,
-          content: hackedContent
-        }
-      };
-    }
-  }
-  return message;
-}
-function createSessionScanner(opts) {
-  const projectDir = getProjectPath(opts.workingDirectory);
-  let finishedSessions = /* @__PURE__ */ new Set();
-  let pendingSessions = /* @__PURE__ */ new Set();
-  let currentSessionId = null;
-  let watchers = /* @__PURE__ */ new Map();
-  let processedMessageKeys = /* @__PURE__ */ new Set();
-  let unmatchedServerMessageContents = /* @__PURE__ */ new Set();
-  const sync = new InvalidateSync(async () => {
-    logger.debug(`[SESSION_SCANNER] Syncing...`);
-    let sessions = [];
-    for (let p of pendingSessions) {
-      sessions.push(p);
-    }
-    if (currentSessionId) {
-      sessions.push(currentSessionId);
+      break;
     }
-    let processSessionFile = async (sessionId) => {
-      const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
-      let file;
-      try {
-        file = await readFile(expectedSessionFile, "utf-8");
-      } catch (error) {
-        logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
-        return;
-      }
-      let lines = file.split("\n");
-      for (let l of lines) {
-        try {
-          if (l.trim() === "") {
-            continue;
-          }
-          let message = JSON.parse(l);
-          let parsed = RawJSONLinesSchema.safeParse(message);
-          if (!parsed.success) {
-            logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
-            continue;
-          }
-          let key = getMessageKey(parsed.data);
-          if (processedMessageKeys.has(key)) {
-            continue;
+    case "user": {
+      const userMsg = message;
+      if (userMsg.message && typeof userMsg.message === "object" && "content" in userMsg.message) {
+        const content = userMsg.message.content;
+        if (typeof content === "string") {
+          messageBuffer.addMessage(`\u{1F464} User: ${content}`, "user");
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "text") {
+              messageBuffer.addMessage(`\u{1F464} User: ${block.text}`, "user");
+            } else if (block.type === "tool_result") {
+              messageBuffer.addMessage(`\u2705 Tool Result (ID: ${block.tool_use_id})`, "result");
+              if (block.content) {
+                const outputStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content, null, 2);
+                const maxLength = 200;
+                if (outputStr.length > maxLength) {
+                  messageBuffer.addMessage(outputStr.substring(0, maxLength) + "... (truncated)", "result");
+                } else {
+                  messageBuffer.addMessage(outputStr, "result");
+                }
+              }
+            }
           }
-          processedMessageKeys.add(key);
-          logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
-          logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
-          if (parsed.data.type === "user" && typeof parsed.data.message.content === "string" && parsed.data.isSidechain !== true && parsed.data.isMeta !== true) {
-            if (unmatchedServerMessageContents.has(parsed.data.message.content)) {
-              logger.debug(`[SESSION_SCANNER] Matched server message echo: ${parsed.data.uuid}`);
-              unmatchedServerMessageContents.delete(parsed.data.message.content);
-              continue;
+        } else {
+          messageBuffer.addMessage(`\u{1F464} User: ${JSON.stringify(content, null, 2)}`, "user");
+        }
+      }
+      break;
+    }
+    case "assistant": {
+      const assistantMsg = message;
+      if (assistantMsg.message && assistantMsg.message.content) {
+        messageBuffer.addMessage("\u{1F916} Assistant:", "assistant");
+        for (const block of assistantMsg.message.content) {
+          if (block.type === "text") {
+            messageBuffer.addMessage(block.text || "", "assistant");
+          } else if (block.type === "tool_use") {
+            messageBuffer.addMessage(`\u{1F527} Tool: ${block.name}`, "tool");
+            if (block.input) {
+              const inputStr = JSON.stringify(block.input, null, 2);
+              const maxLength = 500;
+              if (inputStr.length > maxLength) {
+                messageBuffer.addMessage(`Input: ${inputStr.substring(0, maxLength)}... (truncated)`, "tool");
+              } else {
+                messageBuffer.addMessage(`Input: ${inputStr}`, "tool");
+              }
             }
           }
-          const hackedMessage = hackToolResponse(message);
-          opts.onMessage(hackedMessage);
-        } catch (e) {
-          logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
-          continue;
         }
       }
-    };
-    for (let session of sessions) {
-      await processSessionFile(session);
+      break;
     }
-    for (let p of sessions) {
-      if (pendingSessions.has(p)) {
-        pendingSessions.delete(p);
-        finishedSessions.add(p);
+    case "result": {
+      const resultMsg = message;
+      if (resultMsg.subtype === "success") {
+        if ("result" in resultMsg && resultMsg.result) {
+          messageBuffer.addMessage("\u2728 Summary:", "result");
+          messageBuffer.addMessage(resultMsg.result || "", "result");
+        }
+        if (resultMsg.usage) {
+          messageBuffer.addMessage("\u{1F4CA} Session Stats:", "status");
+          messageBuffer.addMessage(`  \u2022 Turns: ${resultMsg.num_turns}`, "status");
+          messageBuffer.addMessage(`  \u2022 Input tokens: ${resultMsg.usage.input_tokens}`, "status");
+          messageBuffer.addMessage(`  \u2022 Output tokens: ${resultMsg.usage.output_tokens}`, "status");
+          if (resultMsg.usage.cache_read_input_tokens) {
+            messageBuffer.addMessage(`  \u2022 Cache read tokens: ${resultMsg.usage.cache_read_input_tokens}`, "status");
+          }
+          if (resultMsg.usage.cache_creation_input_tokens) {
+            messageBuffer.addMessage(`  \u2022 Cache creation tokens: ${resultMsg.usage.cache_creation_input_tokens}`, "status");
+          }
+          messageBuffer.addMessage(`  \u2022 Cost: $${resultMsg.total_cost_usd.toFixed(4)}`, "status");
+          messageBuffer.addMessage(`  \u2022 Duration: ${resultMsg.duration_ms}ms`, "status");
+        }
+      } else if (resultMsg.subtype === "error_max_turns") {
+        messageBuffer.addMessage("\u274C Error: Maximum turns reached", "result");
+        messageBuffer.addMessage(`Completed ${resultMsg.num_turns} turns`, "status");
+      } else if (resultMsg.subtype === "error_during_execution") {
+        messageBuffer.addMessage("\u274C Error during execution", "result");
+        messageBuffer.addMessage(`Completed ${resultMsg.num_turns} turns before error`, "status");
+        logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
       }
+      break;
     }
-    for (let p of sessions) {
-      if (!watchers.has(p)) {
-        watchers.set(p, startFileWatcher(join(projectDir, `${p}.jsonl`), () => {
-          sync.invalidate();
-        }));
+    default: {
+      if (process.env.DEBUG) {
+        messageBuffer.addMessage(`[Unknown message type: ${message.type}]`, "status");
       }
     }
-  });
-  sync.invalidate();
-  const intervalId = setInterval(() => {
-    sync.invalidate();
-  }, 3e3);
-  return {
-    cleanup: () => {
-      clearInterval(intervalId);
-      for (let w of watchers.values()) {
-        w();
+  }
+}
+
+function getGitBranch(cwd) {
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return branch || void 0;
+  } catch {
+    return void 0;
+  }
+}
+class SDKToLogConverter {
+  lastUuid = null;
+  context;
+  responses;
+  sidechainLastUUID = /* @__PURE__ */ new Map();
+  constructor(context, responses) {
+    this.context = {
+      ...context,
+      gitBranch: context.gitBranch ?? getGitBranch(context.cwd),
+      version: context.version ?? process.env.npm_package_version ?? "0.0.0",
+      parentUuid: null
+    };
+    this.responses = responses;
+  }
+  /**
+   * Update session ID (for when session changes during resume)
+   */
+  updateSessionId(sessionId) {
+    this.context.sessionId = sessionId;
+  }
+  /**
+   * Reset parent chain (useful when starting new conversation)
+   */
+  resetParentChain() {
+    this.lastUuid = null;
+    this.context.parentUuid = null;
+  }
+  /**
+   * Convert SDK message to log format
+   */
+  convert(sdkMessage) {
+    const uuid = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let parentUuid = this.lastUuid;
+    let isSidechain = false;
+    if (sdkMessage.parent_tool_use_id) {
+      isSidechain = true;
+      parentUuid = this.sidechainLastUUID.get(sdkMessage.parent_tool_use_id) ?? null;
+      this.sidechainLastUUID.set(sdkMessage.parent_tool_use_id, uuid);
+    }
+    const baseFields = {
+      parentUuid,
+      isSidechain,
+      userType: "external",
+      cwd: this.context.cwd,
+      sessionId: this.context.sessionId,
+      version: this.context.version,
+      gitBranch: this.context.gitBranch,
+      uuid,
+      timestamp
+    };
+    let logMessage = null;
+    switch (sdkMessage.type) {
+      case "user": {
+        const userMsg = sdkMessage;
+        logMessage = {
+          ...baseFields,
+          type: "user",
+          message: userMsg.message
+        };
+        if (Array.isArray(userMsg.message.content)) {
+          for (const content of userMsg.message.content) {
+            if (content.type === "tool_result" && content.tool_use_id && this.responses?.has(content.tool_use_id)) {
+              const response = this.responses.get(content.tool_use_id);
+              if (response?.mode) {
+                logMessage.mode = response.mode;
+              }
+            }
+          }
+        } else if (typeof userMsg.message.content === "string") ;
+        break;
       }
-      watchers.clear();
-    },
-    onNewSession: (sessionId) => {
-      if (currentSessionId === sessionId) {
-        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
-        return;
+      case "assistant": {
+        const assistantMsg = sdkMessage;
+        logMessage = {
+          ...baseFields,
+          type: "assistant",
+          message: assistantMsg.message,
+          // Assistant messages often have additional fields
+          requestId: assistantMsg.requestId
+        };
+        break;
       }
-      if (finishedSessions.has(sessionId)) {
-        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
-        return;
+      case "system": {
+        const systemMsg = sdkMessage;
+        if (systemMsg.subtype === "init" && systemMsg.session_id) {
+          this.updateSessionId(systemMsg.session_id);
+        }
+        logMessage = {
+          ...baseFields,
+          type: "system",
+          subtype: systemMsg.subtype,
+          model: systemMsg.model,
+          tools: systemMsg.tools,
+          // Include all other fields
+          ...systemMsg
+        };
+        break;
       }
-      if (pendingSessions.has(sessionId)) {
-        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
-        return;
+      case "result": {
+        break;
       }
-      if (currentSessionId) {
-        pendingSessions.add(currentSessionId);
+      // Handle tool use results (often comes as user messages)
+      case "tool_result": {
+        const toolMsg = sdkMessage;
+        const baseLogMessage = {
+          ...baseFields,
+          type: "user",
+          message: {
+            role: "user",
+            content: [{
+              type: "tool_result",
+              tool_use_id: toolMsg.tool_use_id,
+              content: toolMsg.content
+            }]
+          },
+          toolUseResult: toolMsg.content
+        };
+        if (toolMsg.tool_use_id && this.responses?.has(toolMsg.tool_use_id)) {
+          const response = this.responses.get(toolMsg.tool_use_id);
+          if (response?.mode) {
+            baseLogMessage.mode = response.mode;
+          }
+        }
+        logMessage = baseLogMessage;
+        break;
       }
-      logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
-      currentSessionId = sessionId;
-      sync.invalidate();
-    },
-    onRemoteUserMessageForDeduplication: (messageContent) => {
-      logger.debug(`[SESSION_SCANNER] Adding unmatched server message content: ${messageContent.substring(0, 50)}...`);
-      unmatchedServerMessageContents.add(messageContent);
+      default:
+        logMessage = {
+          ...baseFields,
+          ...sdkMessage,
+          type: sdkMessage.type
+          // Override type last to ensure it's set
+        };
     }
-  };
-}
-function getMessageKey(message) {
-  if (message.type === "user") {
-    if (Array.isArray(message.message.content) && message.message.content.length > 0 && typeof message.message.content[0] === "object" && "text" in message.message.content[0]) {
-      return `user-message-content:${stableStringify(message.message.content[0].text)}`;
-    } else {
-      return `user-message-content:${stableStringify(message.message.content)}`;
+    if (logMessage && logMessage.type !== "summary") {
+      this.lastUuid = uuid;
     }
-  } else if (message.type === "assistant") {
-    const { usage, ...messageWithoutUsage } = message.message;
-    return stableStringify(messageWithoutUsage);
-  } else if (message.type === "summary") {
-    return `summary:${message.leafUuid}`;
-  } else if (message.type === "system") {
-    return `system:${message.uuid}`;
+    return logMessage;
   }
-  return `unknown:<error, this should be unreachable>`;
-}
-function stableStringify(obj) {
-  if (!obj) {
-    return "null";
+  /**
+   * Convert multiple SDK messages to log format
+   */
+  convertMany(sdkMessages) {
+    return sdkMessages.map((msg) => this.convert(msg)).filter((msg) => msg !== null);
   }
-  return JSON.stringify(sortKeys(obj), null, 2);
-}
-function sortKeys(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortKeys);
-  } else if (value && typeof value === "object" && value.constructor === Object) {
-    return Object.keys(value).sort().reduce((result, key) => {
-      result[key] = sortKeys(value[key]);
-      return result;
-    }, {});
-  } else {
-    return value;
+  /**
+   * Convert a simple string content to a sidechain user message
+   * Used for Task tool sub-agent prompts
+   */
+  convertSidechainUserMessage(toolUseId, content) {
+    const uuid = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    this.sidechainLastUUID.set(toolUseId, uuid);
+    return {
+      parentUuid: null,
+      isSidechain: true,
+      userType: "external",
+      cwd: this.context.cwd,
+      sessionId: this.context.sessionId,
+      version: this.context.version,
+      gitBranch: this.context.gitBranch,
+      type: "user",
+      message: {
+        role: "user",
+        content
+      },
+      uuid,
+      timestamp
+    };
+  }
+  /**
+   * Generate an interrupted tool result message
+   * Used when a tool call is interrupted by the user
+   * @param toolUseId - The ID of the tool that was interrupted
+   * @param parentToolUseId - Optional parent tool ID if this is a sidechain tool
+   */
+  generateInterruptedToolResult(toolUseId, parentToolUseId) {
+    const uuid = randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const errorMessage = "[Request interrupted by user for tool use]";
+    let isSidechain = false;
+    let parentUuid = this.lastUuid;
+    if (parentToolUseId) {
+      isSidechain = true;
+      parentUuid = this.sidechainLastUUID.get(parentToolUseId) ?? null;
+      this.sidechainLastUUID.set(parentToolUseId, uuid);
+    }
+    const logMessage = {
+      type: "user",
+      isSidechain,
+      uuid,
+      message: {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            content: errorMessage,
+            is_error: true,
+            tool_use_id: toolUseId
+          }
+        ]
+      },
+      parentUuid,
+      userType: "external",
+      cwd: this.context.cwd,
+      sessionId: this.context.sessionId,
+      version: this.context.version,
+      gitBranch: this.context.gitBranch,
+      timestamp,
+      toolUseResult: `Error: ${errorMessage}`
+    };
+    this.lastUuid = uuid;
+    return logMessage;
   }
 }
 
-async function loop(opts) {
-  let mode = opts.startingMode ?? "local";
-  let currentPermissionMode = opts.permissionMode ?? "default";
-  logger.debug(`[loop] Starting with permission mode: ${currentPermissionMode}`);
-  let currentMessageQueue = opts.messageQueue || new MessageQueue2(
-    (mode2) => mode2
-    // Simple string hasher since modes are already strings
-  );
-  let sessionId = null;
-  let onMessage = null;
-  const sessionScanner = opts.sessionScanner || createSessionScanner({
-    workingDirectory: opts.path,
-    onMessage: (message) => {
-      opts.session.sendClaudeSessionMessage(message);
+async function claudeRemoteLauncher(session) {
+  let messageBuffer = new MessageBuffer();
+  console.clear();
+  let inkInstance = render(React.createElement(RemoteModeDisplay, {
+    messageBuffer,
+    logPath: process.env.DEBUG ? session.logPath : void 0,
+    onExit: async () => {
+      logger.debug("[remote]: Exiting client via Ctrl-C");
+      if (!exitReason) {
+        exitReason = "exit";
+      }
+      await abort();
+    },
+    onSwitchToLocal: () => {
+      logger.debug("[remote]: Switching to local mode via double space");
+      doSwitch();
     }
+  }), {
+    exitOnCtrlC: false,
+    patchConsole: false
   });
-  opts.session.onUserMessage((message) => {
-    sessionScanner.onRemoteUserMessageForDeduplication(message.content.text);
-    let messagePermissionMode = currentPermissionMode;
-    if (message.meta?.permissionMode) {
-      const validModes = ["default", "acceptEdits", "bypassPermissions", "plan"];
-      if (validModes.includes(message.meta.permissionMode)) {
-        messagePermissionMode = message.meta.permissionMode;
-        currentPermissionMode = messagePermissionMode;
-        logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
-      } else {
-        logger.info(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
+  process.stdin.resume();
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.setEncoding("utf8");
+  const scanner = await createSessionScanner({
+    sessionId: session.sessionId,
+    workingDirectory: session.path,
+    onMessage: (message) => {
+      if (message.type === "summary") {
+        session.client.sendClaudeSessionMessage(message);
       }
-    } else {
-      logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
-    }
-    currentMessageQueue.push(message.content.text, messagePermissionMode);
-    logger.debugLargeJson("User message pushed to queue:", message);
-    if (onMessage) {
-      onMessage();
     }
   });
-  let onSessionFound = (newSessionId) => {
-    sessionId = newSessionId;
-    sessionScanner.onNewSession(newSessionId);
-  };
-  while (true) {
-    logger.debug(`[loop] Starting loop iteration, queue size: ${currentMessageQueue.size()}, mode: ${mode}`);
-    if (currentMessageQueue.size() > 0) {
-      if (mode !== "remote") {
-        mode = "remote";
-        if (opts.onModeChange) {
-          opts.onModeChange(mode);
+  let exitReason = null;
+  let abortController = null;
+  let abortFuture = null;
+  async function abort() {
+    if (abortController && !abortController.signal.aborted) {
+      abortController.abort();
+    }
+    await abortFuture?.promise;
+  }
+  async function doAbort() {
+    logger.debug("[remote]: doAbort");
+    await abort();
+  }
+  async function doSwitch() {
+    logger.debug("[remote]: doSwitch");
+    if (!exitReason) {
+      exitReason = "switch";
+    }
+    await abort();
+  }
+  session.client.setHandler("abort", doAbort);
+  session.client.setHandler("switch", doSwitch);
+  const permissions = await startPermissionResolver(session);
+  const sdkToLogConverter = new SDKToLogConverter({
+    sessionId: session.sessionId || "unknown",
+    cwd: session.path,
+    version: process.env.npm_package_version
+  }, permissions.responses);
+  let planModeToolCalls = /* @__PURE__ */ new Set();
+  let ongoingToolCalls = /* @__PURE__ */ new Map();
+  function onMessage(message) {
+    formatClaudeMessageForInk(message, messageBuffer);
+    permissions.onMessage(message);
+    if (message.type === "assistant") {
+      let umessage = message;
+      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")) {
+            logger.debug("[remote]: detected plan mode tool call " + c.id);
+            planModeToolCalls.add(c.id);
+          }
         }
       }
     }
-    if (mode === "local") {
-      let abortedOutside = false;
-      const interactiveAbortController = new AbortController();
-      opts.session.setHandler("switch", () => {
-        if (!interactiveAbortController.signal.aborted) {
-          abortedOutside = true;
-          if (mode !== "remote") {
-            mode = "remote";
-            if (opts.onModeChange) {
-              opts.onModeChange(mode);
-            }
+    if (message.type === "assistant") {
+      let umessage = message;
+      if (umessage.message.content && Array.isArray(umessage.message.content)) {
+        for (let c of umessage.message.content) {
+          if (c.type === "tool_use") {
+            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 });
           }
-          interactiveAbortController.abort();
-        }
-      });
-      opts.session.setHandler("abort", () => {
-        if (onMessage) {
-          onMessage();
         }
-      });
-      onMessage = () => {
-        if (!interactiveAbortController.signal.aborted) {
-          abortedOutside = true;
-          if (mode !== "remote") {
-            mode = "remote";
-            if (opts.onModeChange) {
-              opts.onModeChange(mode);
-            }
+      }
+    }
+    if (message.type === "user") {
+      let umessage = message;
+      if (umessage.message.content && Array.isArray(umessage.message.content)) {
+        for (let c of umessage.message.content) {
+          if (c.type === "tool_result" && c.tool_use_id) {
+            ongoingToolCalls.delete(c.tool_use_id);
           }
-          opts.session.sendSessionEvent({ type: "message", message: "Inference aborted" });
-          interactiveAbortController.abort();
-        }
-        onMessage = null;
-      };
-      try {
-        if (opts.onProcessStart) {
-          opts.onProcessStart("local");
-        }
-        await claudeLocal({
-          path: opts.path,
-          sessionId,
-          onSessionFound,
-          onThinkingChange: opts.onThinkingChange,
-          abort: interactiveAbortController.signal,
-          claudeEnvVars: opts.claudeEnvVars,
-          claudeArgs: opts.claudeArgs
-        });
-      } catch (e) {
-        if (!interactiveAbortController.signal.aborted) {
-          opts.session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
-        }
-      } finally {
-        if (opts.onProcessStop) {
-          opts.onProcessStop("local");
         }
       }
-      onMessage = null;
-      if (!abortedOutside) {
-        return;
+    }
+    let msg = message;
+    if (message.type === "user") {
+      let umessage = message;
+      if (umessage.message.content && Array.isArray(umessage.message.content)) {
+        msg = {
+          ...umessage,
+          message: {
+            ...umessage.message,
+            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) {
+                  logger.debug("[remote]: hack plan mode exit");
+                  logger.debugLargeJson("[remote]: hack plan mode exit", c);
+                  return {
+                    ...c,
+                    is_error: false,
+                    content: "Plan approved",
+                    mode: c.mode
+                  };
+                } else {
+                  return c;
+                }
+              }
+              return c;
+            })
+          }
+        };
       }
-      if (mode !== "local") {
-        console.log("Switching to remote mode...");
+    }
+    const logMessage = sdkToLogConverter.convert(msg);
+    if (logMessage) {
+      if (logMessage.type !== "system") {
+        session.client.sendClaudeSessionMessage(logMessage);
       }
     }
-    if (mode === "remote") {
-      console.log("Starting remote mode...");
-      logger.debug("Starting " + sessionId);
-      const remoteAbortController = new AbortController();
-      opts.session.setHandler("abort", () => {
-        if (remoteAbortController && !remoteAbortController.signal.aborted) {
-          remoteAbortController.abort();
-        }
-      });
-      const abortHandler = () => {
-        if (remoteAbortController && !remoteAbortController.signal.aborted) {
-          if (mode !== "local") {
-            mode = "local";
-            if (opts.onModeChange) {
-              opts.onModeChange(mode);
+    if (message.type === "assistant") {
+      let umessage = message;
+      if (umessage.message.content && Array.isArray(umessage.message.content)) {
+        for (let c of umessage.message.content) {
+          if (c.type === "tool_use" && c.name === "Task" && c.input && typeof c.input.prompt === "string") {
+            const logMessage2 = sdkToLogConverter.convertSidechainUserMessage(c.id, c.input.prompt);
+            if (logMessage2) {
+              session.client.sendClaudeSessionMessage(logMessage2);
             }
           }
-          opts.session.sendSessionEvent({ type: "message", message: "Inference aborted" });
-          remoteAbortController.abort();
-        }
-        if (process.stdin.isTTY) {
-          process.stdin.setRawMode(false);
         }
-      };
-      process.stdin.resume();
-      if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
       }
-      process.stdin.setEncoding("utf8");
-      process.stdin.on("data", abortHandler);
-      try {
-        logger.debug(`Starting claudeRemote with messages: ${currentMessageQueue.size()}`);
-        logger.debug("[loop] Waiting for messages before starting claudeRemote...");
-        const messageData = await currentMessageQueue.waitForMessagesAndGetAsString(remoteAbortController.signal);
-        if (!messageData) {
-          console.log("[LOOP] No message received (queue closed or aborted), continuing loop");
-          logger.debug("[loop] No message received (queue closed or aborted), skipping remote mode");
+    }
+  }
+  try {
+    while (!exitReason) {
+      logger.debug("[remote]: fetch next message");
+      abortController = new AbortController();
+      abortFuture = new Future();
+      const messageData = await session.queue.waitForMessagesAndGetAsString(abortController.signal);
+      if (!messageData || abortController.signal.aborted) {
+        logger.debug("[remote]: fetch next message done: no message or aborted");
+        abortFuture?.resolve(void 0);
+        if (exitReason) {
+          return exitReason;
+        } else {
           continue;
         }
-        currentPermissionMode = messageData.mode;
-        logger.debug(`[loop] Using permission mode from queue: ${currentPermissionMode}`);
-        if (opts.onProcessStart) {
-          opts.onProcessStart("remote");
-        }
-        opts.session.sendSessionEvent({ type: "permission-mode-changed", mode: currentPermissionMode });
-        logger.debug(`[loop] Sent permission-mode-changed event to app: ${currentPermissionMode}`);
+      }
+      logger.debug("[remote]: fetch next message done: message received");
+      abortFuture?.resolve(void 0);
+      abortFuture = null;
+      abortController = null;
+      logger.debug("[remote]: launch");
+      messageBuffer.addMessage("\u2550".repeat(40), "status");
+      messageBuffer.addMessage("Starting new Claude session...", "status");
+      abortController = new AbortController();
+      abortFuture = new Future();
+      permissions.reset();
+      sdkToLogConverter.resetParentChain();
+      try {
         await claudeRemote({
-          abort: remoteAbortController.signal,
-          sessionId,
-          path: opts.path,
-          mcpServers: opts.mcpServers,
-          permissionPromptToolName: opts.permissionPromptToolName,
-          permissionMode: currentPermissionMode,
-          onSessionFound,
-          onThinkingChange: opts.onThinkingChange,
+          sessionId: session.sessionId,
+          path: session.path,
+          responses: permissions.responses,
+          mcpServers: {
+            ...session.mcpServers,
+            permission: {
+              type: "http",
+              url: permissions.server.url
+            }
+          },
+          permissionPromptToolName: "mcp__permission__" + permissions.server.toolName,
+          permissionMode: messageData.mode,
+          onSessionFound: (sessionId) => {
+            sdkToLogConverter.updateSessionId(sessionId);
+            session.onSessionFound(sessionId);
+            scanner.onNewSession(sessionId);
+          },
+          onThinkingChange: session.onThinkingChange,
           message: messageData.message,
-          onAssistantResult: opts.onAssistantResult,
-          interruptController: opts.interruptController,
-          claudeEnvVars: opts.claudeEnvVars,
-          claudeArgs: opts.claudeArgs,
-          onToolCallResolver: opts.onToolCallResolver
+          claudeEnvVars: session.claudeEnvVars,
+          claudeArgs: session.claudeArgs,
+          onMessage,
+          signal: abortController.signal
         });
+        if (!exitReason && abortController.signal.aborted) {
+          session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
+        }
       } catch (e) {
-        if (!remoteAbortController.signal.aborted) {
-          opts.session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+        if (!exitReason) {
+          session.client.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          continue;
         }
       } finally {
-        if (opts.onProcessStop) {
-          opts.onProcessStop("remote");
-        }
-        process.stdin.off("data", abortHandler);
-        if (process.stdin.isTTY) {
-          process.stdin.setRawMode(false);
-        }
-      }
-      if (mode !== "remote") {
-        console.log("Switching back to good old claude...");
-      }
-    }
-  }
-}
-
-async function startPermissionServerV2(handler) {
-  const mcp = new McpServer({
-    name: "Permission Server",
-    version: "1.0.0",
-    description: "A server that allows you to request permissions from the user"
-  });
-  mcp.registerTool("ask_permission", {
-    description: "Request permission to execute a tool",
-    title: "Request Permission",
-    inputSchema: {
-      tool_name: z$1.string().describe("The tool that needs permission"),
-      input: z$1.any().describe("The arguments for the tool")
-    }
-    // outputSchema: {
-    //     approved: z.boolean().describe('Whether the tool was approved'),
-    //     reason: z.string().describe('The reason for the approval or denial'),
-    // },
-  }, async (args) => {
-    const response = await handler({ name: args.tool_name, arguments: args.input });
-    const result = response.approved ? { behavior: "allow", updatedInput: args.input || {} } : { behavior: "deny", message: response.reason || "Permission denied by user" };
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(result)
+        for (let [toolCallId, { parentToolCallId }] of ongoingToolCalls) {
+          const converted = sdkToLogConverter.generateInterruptedToolResult(toolCallId, parentToolCallId);
+          if (converted) {
+            logger.debug("[remote]: terminating tool call " + toolCallId + " parent: " + parentToolCallId);
+            session.client.sendClaudeSessionMessage(converted);
+          }
         }
-      ],
-      isError: false
-    };
-  });
-  const transport = new StreamableHTTPServerTransport({
-    // NOTE: Returning session id here will result in claude
-    // sdk spawn to fail with `Invalid Request: Server already initialized`
-    sessionIdGenerator: void 0
-  });
-  await mcp.connect(transport);
-  const server = createServer(async (req, res) => {
-    try {
-      await transport.handleRequest(req, res);
-    } catch (error) {
-      logger.debug("Error handling request:", error);
-      if (!res.headersSent) {
-        res.writeHead(500).end();
+        ongoingToolCalls.clear();
+        abortController = null;
+        abortFuture?.resolve(void 0);
+        abortFuture = null;
+        logger.debug("[remote]: launch done");
+        permissions.reset();
       }
     }
-  });
-  const baseUrl = await new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      resolve(new URL(`http://127.0.0.1:${addr.port}`));
-    });
-  });
-  return {
-    url: baseUrl.toString(),
-    toolName: "ask_permission"
-  };
-}
-
-class InterruptController {
-  interruptFn;
-  isInterrupting = false;
-  /**
-   * Register an interrupt function from claudeRemote
-   */
-  register(fn) {
-    this.interruptFn = fn;
-  }
-  /**
-   * Unregister the interrupt function (cleanup)
-   */
-  unregister() {
-    this.interruptFn = void 0;
-    this.isInterrupting = false;
-  }
-  /**
-   * Trigger the interrupt - can be called from anywhere
-   */
-  async interrupt() {
-    if (!this.interruptFn || this.isInterrupting) {
-      return false;
+  } finally {
+    permissions.server.stop();
+    process.stdin.off("data", abort);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
     }
-    this.isInterrupting = true;
-    try {
-      await this.interruptFn();
-      return true;
-    } catch (error) {
-      logger.debug("Failed to interrupt Claude:", error);
-      return false;
-    } finally {
-      this.isInterrupting = false;
+    inkInstance.unmount();
+    messageBuffer.clear();
+    if (abortFuture) {
+      abortFuture.resolve(void 0);
     }
+    await scanner.cleanup();
   }
-  /**
-   * Check if interrupt is available
-   */
-  canInterrupt() {
-    return !!this.interruptFn && !this.isInterrupting;
+  return exitReason || "exit";
+}
+
+async function loop(opts) {
+  const logPath = await logger.logFilePathPromise;
+  let session = new Session({
+    api: opts.api,
+    client: opts.session,
+    path: opts.path,
+    sessionId: null,
+    claudeEnvVars: opts.claudeEnvVars,
+    claudeArgs: opts.claudeArgs,
+    mcpServers: opts.mcpServers,
+    logPath,
+    messageQueue: opts.messageQueue,
+    onModeChange: opts.onModeChange
+  });
+  let mode = opts.startingMode ?? "local";
+  while (true) {
+    logger.debug(`[loop] Iteration with mode: ${mode}`);
+    if (mode === "local") {
+      let reason = await claudeLocalLauncher(session);
+      if (reason === "exit") {
+        return;
+      }
+      mode = "remote";
+      if (opts.onModeChange) {
+        opts.onModeChange(mode);
+      }
+      continue;
+    }
+    if (mode === "remote") {
+      let reason = await claudeRemoteLauncher(session);
+      if (reason === "exit") {
+        return;
+      }
+      mode = "local";
+      if (opts.onModeChange) {
+        opts.onModeChange(mode);
+      }
+      continue;
+    }
   }
 }
 
-var version = "0.2.2";
+var name = "happy-coder";
+var version = "0.2.3-beta.1";
+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"
+};
+var main = "./dist/index.cjs";
+var module = "./dist/index.mjs";
+var types = "./dist/index.d.cts";
+var exports = {
+	".": {
+		require: {
+			types: "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		},
+		"import": {
+			types: "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"./lib": {
+		require: {
+			types: "./dist/lib.d.cts",
+			"default": "./dist/lib.cjs"
+		},
+		"import": {
+			types: "./dist/lib.d.mts",
+			"default": "./dist/lib.mjs"
+		}
+	}
+};
+var files = [
+	"dist",
+	"bin",
+	"scripts",
+	"ripgrep",
+	"package.json"
+];
+var scripts = {
+	test: "vitest run",
+	"test:watch": "vitest",
+	build: "tsc --noEmit && pkgroll",
+	prepublishOnly: "yarn build && yarn test",
+	typecheck: "tsc --noEmit",
+	dev: "npx tsx --env-file .env.sample src/index.ts",
+	"dev:local-server": "HANDY_SERVER_URL=http://localhost:3005 npx tsx --env-file .env.sample src/index.ts",
+	prerelease: "npm version prerelease --preid=beta"
+};
+var dependencies = {
+	"@anthropic-ai/claude-code": "^1.0.72",
+	"@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",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.5",
+	ink: "^6.1.0",
+	"ink-box": "^2.0.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": ">=18",
+	eslint: "^9",
+	"eslint-config-prettier": "^10",
+	pkgroll: "^2.14.2",
+	shx: "^0.3.3",
+	"ts-node": "^10",
+	tsx: "^4.20.3",
+	typescript: "^5",
+	vitest: "^3.2.4"
+};
+var overrides = {
+	"whatwg-url": "14.2.0"
+};
 var packageJson = {
-	version: version};
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	license: license,
+	type: type,
+	homepage: homepage,
+	bugs: bugs,
+	repository: repository,
+	bin: bin,
+	main: main,
+	module: module,
+	types: types,
+	exports: exports,
+	files: files,
+	scripts: scripts,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	overrides: overrides
+};
 
 const __dirname = dirname$1(fileURLToPath$1(import.meta.url));
 const RUNNER_PATH = join$1(__dirname, "..", "..", "scripts", "ripgrep_launcher.cjs");
@@ -1603,51 +2352,9 @@ function run(args, options) {
 }
 
 const execAsync = promisify(exec);
-function registerHandlers(session, interruptController, permissionCallbacks, onSwitchRemoteRequested) {
-  session.setHandler("abort", async () => {
-    logger.info("Abort request - interrupting Claude");
-    await interruptController.interrupt();
-  });
-  if (permissionCallbacks) {
-    session.setHandler("permission", async (message) => {
-      logger.info("Permission response" + JSON.stringify(message));
-      const id = message.id;
-      const resolve = permissionCallbacks.requests.get(id);
-      if (resolve) {
-        if (!message.approved) {
-          logger.debug("Permission denied, interrupting Claude");
-          await interruptController.interrupt();
-        }
-        resolve({ approved: message.approved, reason: message.reason });
-        permissionCallbacks.requests.delete(id);
-      } else {
-        logger.info("Permission request stale, likely timed out");
-        return;
-      }
-      session.updateAgentState((currentState) => {
-        const request = currentState.requests?.[id];
-        if (!request) return currentState;
-        let r = { ...currentState.requests };
-        delete r[id];
-        const isExitPlanModeSuccess = request.tool === "exit_plan_mode" && !message.approved && message.reason === PLAN_FAKE_REJECT;
-        return {
-          ...currentState,
-          requests: r,
-          completedRequests: {
-            ...currentState.completedRequests,
-            [id]: {
-              ...request,
-              completedAt: Date.now(),
-              status: isExitPlanModeSuccess ? "approved" : message.approved ? "approved" : "denied",
-              reason: isExitPlanModeSuccess ? "Plan approved" : message.reason
-            }
-          }
-        };
-      });
-    });
-  }
+function registerHandlers(session) {
   session.setHandler("bash", async (data) => {
-    logger.info("Shell command request:", data.command);
+    logger.debug("Shell command request:", data.command);
     try {
       const options = {
         cwd: data.cwd,
@@ -1682,7 +2389,7 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
     }
   });
   session.setHandler("readFile", async (data) => {
-    logger.info("Read file request:", data.path);
+    logger.debug("Read file request:", data.path);
     try {
       const buffer = await readFile$1(data.path);
       const content = buffer.toString("base64");
@@ -1693,7 +2400,7 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
     }
   });
   session.setHandler("writeFile", async (data) => {
-    logger.info("Write file request:", data.path);
+    logger.debug("Write file request:", data.path);
     try {
       if (data.expectedHash !== null && data.expectedHash !== void 0) {
         try {
@@ -1739,7 +2446,7 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
     }
   });
   session.setHandler("listDirectory", async (data) => {
-    logger.info("List directory request:", data.path);
+    logger.debug("List directory request:", data.path);
     try {
       const entries = await readdir(data.path, { withFileTypes: true });
       const directoryEntries = await Promise.all(
@@ -1780,7 +2487,7 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
     }
   });
   session.setHandler("getDirectoryTree", async (data) => {
-    logger.info("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
     async function buildTree(path, name, currentDepth) {
       try {
         const stats = await stat(path);
@@ -1836,7 +2543,7 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
     }
   });
   session.setHandler("ripgrep", async (data) => {
-    logger.info("Ripgrep request with args:", data.args, "cwd:", data.cwd);
+    logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
     try {
       const result = await run(data.args, { cwd: data.cwd });
       return {
@@ -1855,53 +2562,306 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
   });
 }
 
-const defaultSettings = {
-  onboardingCompleted: false
-};
-async function readSettings() {
-  if (!existsSync(configuration.settingsFile)) {
-    return { ...defaultSettings };
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await readFile(configuration.settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
+}
+async function writeSettings(settings) {
+  if (!existsSync(configuration.happyDir)) {
+    await mkdir(configuration.happyDir, { recursive: true });
+  }
+  await writeFile$1(configuration.settingsFile, JSON.stringify(settings, null, 2));
+}
+const credentialsSchema = z.object({
+  secret: z.string().base64(),
+  token: z.string()
+});
+async function readCredentials() {
+  if (!existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    return {
+      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
+      token: credentials.token
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCredentials(credentials) {
+  if (!existsSync(configuration.happyDir)) {
+    await mkdir(configuration.happyDir, { recursive: true });
+  }
+  await writeFile$1(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
+}
+
+class MessageQueue2 {
+  constructor(modeHasher) {
+    this.modeHasher = modeHasher;
+    logger.debug(`[MessageQueue2] Initialized`);
+  }
+  queue = [];
+  waiter = null;
+  closed = false;
+  onMessageHandler = null;
+  /**
+   * Set a handler that will be called when a message arrives
+   */
+  setOnMessage(handler) {
+    this.onMessageHandler = handler;
+  }
+  /**
+   * Push a message to the queue with a mode.
+   */
+  push(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message to the beginning of the queue with a mode.
+   */
+  unshift(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot unshift to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
+    this.queue.unshift({
+      message,
+      mode,
+      modeHash
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Reset the queue - clears all messages and resets to empty state
+   */
+  reset() {
+    logger.debug(`[MessageQueue2] reset() called. Clearing ${this.queue.length} messages`);
+    this.queue = [];
+    this.closed = false;
+    this.waiter = null;
+  }
+  /**
+   * Close the queue - no more messages can be pushed
+   */
+  close() {
+    logger.debug(`[MessageQueue2] close() called`);
+    this.closed = true;
+    if (this.waiter) {
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(false);
+    }
+  }
+  /**
+   * Check if the queue is closed
+   */
+  isClosed() {
+    return this.closed;
+  }
+  /**
+   * Get the current queue size
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Wait for messages and return all messages with the same mode as a single string
+   * Returns { message: string, mode: T } or null if aborted/closed
+   */
+  async waitForMessagesAndGetAsString(abortSignal) {
+    if (this.queue.length > 0) {
+      return this.collectBatch();
+    }
+    if (this.closed || abortSignal?.aborted) {
+      return null;
+    }
+    const hasMessages = await this.waitForMessages(abortSignal);
+    if (!hasMessages) {
+      return null;
+    }
+    return this.collectBatch();
+  }
+  /**
+   * Collect a batch of messages with the same mode
+   */
+  collectBatch() {
+    if (this.queue.length === 0) {
+      return null;
+    }
+    const firstItem = this.queue[0];
+    const sameModeMessages = [];
+    let mode = firstItem.mode;
+    const targetModeHash = firstItem.modeHash;
+    while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash) {
+      const item = this.queue.shift();
+      sameModeMessages.push(item.message);
+    }
+    const combinedMessage = sameModeMessages.join("\n");
+    logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
+    return {
+      message: combinedMessage,
+      mode
+    };
+  }
+  /**
+   * Wait for messages to arrive
+   */
+  waitForMessages(abortSignal) {
+    return new Promise((resolve) => {
+      let abortHandler = null;
+      if (abortSignal) {
+        abortHandler = () => {
+          logger.debug("[MessageQueue2] Wait aborted");
+          if (this.waiter === waiterFunc) {
+            this.waiter = null;
+          }
+          resolve(false);
+        };
+        abortSignal.addEventListener("abort", abortHandler);
+      }
+      const waiterFunc = (hasMessages) => {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(hasMessages);
+      };
+      if (this.queue.length > 0) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(true);
+        return;
+      }
+      if (this.closed || abortSignal?.aborted) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(false);
+        return;
+      }
+      this.waiter = waiterFunc;
+      logger.debug("[MessageQueue2] Waiting for messages...");
+    });
+  }
+}
+
+let caffeinateProcess = null;
+function startCaffeinate() {
+  if (process.platform !== "darwin") {
+    logger.debug("[caffeinate] Not on macOS, skipping caffeinate");
+    return false;
   }
-  try {
-    const content = await readFile(configuration.settingsFile, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return { ...defaultSettings };
+  if (caffeinateProcess && !caffeinateProcess.killed) {
+    logger.debug("[caffeinate] Caffeinate already running");
+    return true;
   }
-}
-async function writeSettings(settings) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
+  try {
+    caffeinateProcess = spawn$1("caffeinate", ["-dim"], {
+      stdio: "ignore",
+      detached: false
+    });
+    caffeinateProcess.on("error", (error) => {
+      logger.debug("[caffeinate] Error starting caffeinate:", error);
+      caffeinateProcess = null;
+    });
+    caffeinateProcess.on("exit", (code, signal) => {
+      logger.debug(`[caffeinate] Process exited with code ${code}, signal ${signal}`);
+      caffeinateProcess = null;
+    });
+    logger.debug(`[caffeinate] Started with PID ${caffeinateProcess.pid}`);
+    setupCleanupHandlers();
+    return true;
+  } catch (error) {
+    logger.debug("[caffeinate] Failed to start caffeinate:", error);
+    return false;
   }
-  await writeFile$1(configuration.settingsFile, JSON.stringify(settings, null, 2));
 }
-const credentialsSchema = z.object({
-  secret: z.string().base64(),
-  token: z.string()
-});
-async function readCredentials() {
-  if (!existsSync(configuration.privateKeyFile)) {
-    return null;
-  }
-  try {
-    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
-    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
-    return {
-      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
-      token: credentials.token
-    };
-  } catch {
-    return null;
+function stopCaffeinate() {
+  if (caffeinateProcess && !caffeinateProcess.killed) {
+    logger.debug(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
+    try {
+      caffeinateProcess.kill("SIGTERM");
+      setTimeout(() => {
+        if (caffeinateProcess && !caffeinateProcess.killed) {
+          logger.debug("[caffeinate] Force killing caffeinate process");
+          caffeinateProcess.kill("SIGKILL");
+        }
+        caffeinateProcess = null;
+      }, 1e3);
+    } catch (error) {
+      logger.debug("[caffeinate] Error stopping caffeinate:", error);
+    }
   }
 }
-async function writeCredentials(credentials) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
+let cleanupHandlersSet = false;
+function setupCleanupHandlers() {
+  if (cleanupHandlersSet) {
+    return;
   }
-  await writeFile$1(configuration.privateKeyFile, JSON.stringify({
-    secret: encodeBase64(credentials.secret),
-    token: credentials.token
-  }, null, 2));
+  cleanupHandlersSet = true;
+  const cleanup = () => {
+    stopCaffeinate();
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.on("SIGUSR1", cleanup);
+  process.on("SIGUSR2", cleanup);
+  process.on("uncaughtException", (error) => {
+    logger.debug("[caffeinate] Uncaught exception, cleaning up:", error);
+    cleanup();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason, promise) => {
+    logger.debug("[caffeinate] Unhandled rejection, cleaning up:", reason);
+    cleanup();
+    process.exit(1);
+  });
 }
 
 async function start(credentials, options = {}) {
@@ -1927,227 +2887,59 @@ async function start(credentials, options = {}) {
     console.log(`daemon:sessionIdCreated:${response.id}`);
   }
   const session = api.session(response);
-  const pushClient = api.push();
-  let thinking = false;
-  let mode = "local";
-  let pingInterval = setInterval(() => {
-    session.keepAlive(thinking, mode);
-  }, 2e3);
   const logPath = await logger.logFilePathPromise;
   logger.infoDeveloper(`Session: ${response.id}`);
   logger.infoDeveloper(`Logs: ${logPath}`);
-  const interruptController = new InterruptController();
-  const { MessageQueue2 } = await Promise.resolve().then(function () { return MessageQueue2$1; });
-  const messageQueue = new MessageQueue2(
-    (mode2) => mode2
-    // Simple string hasher since modes are already strings
-  );
-  let requests = /* @__PURE__ */ new Map();
-  let toolCallResolver = null;
-  const sessionScanner = createSessionScanner({
-    workingDirectory,
-    onMessage: (message) => {
-      session.sendClaudeSessionMessage(message);
-    }
-  });
-  const permissionServer = await startPermissionServerV2(async (request) => {
-    if (!toolCallResolver) {
-      const error = `Tool call resolver not available for permission request: ${request.name}`;
-      logger.info(`ERROR: ${error}`);
-      throw new Error(error);
-    }
-    const toolCallId = toolCallResolver(request.name, request.arguments);
-    if (!toolCallId) {
-      const error = `Could not resolve tool call ID for permission request: ${request.name}`;
-      logger.info(`ERROR: ${error}`);
-      throw new Error(error);
-    }
-    const id = toolCallId;
-    logger.debug(`Using tool call ID as permission request ID: ${id} for ${request.name}`);
-    let promise = new Promise((resolve) => {
-      if (request.name === "exit_plan_mode") {
-        const wrappedResolve = (response2) => {
-          if (response2.approved) {
-            logger.debug("[HACK] exit_plan_mode approved - injecting approval message and denying");
-            sessionScanner.onRemoteUserMessageForDeduplication(PLAN_FAKE_RESTART);
-            messageQueue.unshift(PLAN_FAKE_RESTART, "default");
-            logger.debug(`[HACK] Message queue size after unshift: ${messageQueue.size()}`);
-            resolve({
-              approved: false,
-              reason: PLAN_FAKE_REJECT
-            });
-          } else {
-            resolve(response2);
-          }
-        };
-        requests.set(id, wrappedResolve);
+  const caffeinateStarted = startCaffeinate();
+  if (caffeinateStarted) {
+    logger.infoDeveloper("Sleep prevention enabled (macOS)");
+  }
+  const messageQueue = new MessageQueue2((mode) => mode);
+  registerHandlers(session);
+  let currentPermissionMode = options.permissionMode;
+  session.onUserMessage((message) => {
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      const validModes = ["default", "acceptEdits", "bypassPermissions", "plan"];
+      if (validModes.includes(message.meta.permissionMode)) {
+        messagePermissionMode = message.meta.permissionMode;
+        currentPermissionMode = messagePermissionMode;
+        logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
       } else {
-        requests.set(id, resolve);
-      }
-    });
-    let timeout = setTimeout(async () => {
-      logger.debug("Permission timeout - attempting to interrupt Claude");
-      const interrupted = await interruptController.interrupt();
-      if (interrupted) {
-        logger.debug("Claude interrupted successfully");
+        logger.debug(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
       }
-      requests.delete(id);
-      session.updateAgentState((currentState) => {
-        const request2 = currentState.requests?.[id];
-        if (!request2) return currentState;
-        let r = { ...currentState.requests };
-        delete r[id];
-        return {
-          ...currentState,
-          requests: r,
-          completedRequests: {
-            ...currentState.completedRequests,
-            [id]: {
-              ...request2,
-              completedAt: Date.now(),
-              status: "canceled",
-              reason: "Timeout"
-            }
-          }
-        };
-      });
-    }, 1e3 * 60 * 4.5);
-    logger.debug("Permission request" + id + " " + JSON.stringify(request));
-    try {
-      await pushClient.sendToAllDevices(
-        "Permission Request",
-        `Claude wants to use ${request.name}`,
-        {
-          sessionId: response.id,
-          requestId: id,
-          tool: request.name,
-          type: "permission_request"
-        }
-      );
-      logger.debug("Push notification sent for permission request");
-    } catch (error) {
-      logger.debug("Failed to send push notification:", error);
+    } else {
+      logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
     }
-    session.updateAgentState((currentState) => ({
-      ...currentState,
-      requests: {
-        ...currentState.requests,
-        [id]: {
-          tool: request.name,
-          arguments: request.arguments,
-          createdAt: Date.now()
-        }
-      }
-    }));
-    promise.then(() => clearTimeout(timeout)).catch(() => clearTimeout(timeout));
-    return promise;
+    messageQueue.push(message.content.text, messagePermissionMode || "default");
+    logger.debugLargeJson("User message pushed to queue:", message);
   });
-  registerHandlers(session, interruptController, { requests });
-  const onAssistantResult = async (result) => {
-    try {
-      const summary = "result" in result && result.result ? result.result.substring(0, 100) + (result.result.length > 100 ? "..." : "") : "";
-      await pushClient.sendToAllDevices(
-        "Your move :D",
-        summary,
-        {
-          sessionId: response.id,
-          type: "assistant_result",
-          turns: result.num_turns,
-          duration_ms: result.duration_ms,
-          cost_usd: result.total_cost_usd
-        }
-      );
-      logger.debug("Push notification sent: Assistant result");
-    } catch (error) {
-      logger.debug("Failed to send assistant result push notification:", error);
-    }
-  };
   await loop({
     path: workingDirectory,
     model: options.model,
     permissionMode: options.permissionMode,
     startingMode: options.startingMode,
     messageQueue,
-    sessionScanner,
+    api,
     onModeChange: (newMode) => {
-      mode = newMode;
       session.sendSessionEvent({ type: "switch", mode: newMode });
-      session.keepAlive(thinking, mode);
-      if (newMode === "local") {
-        logger.debug("Switching to local mode - clearing pending permission requests");
-        toolCallResolver = null;
-        for (const [id, resolve] of requests) {
-          logger.debug(`Rejecting pending permission request: ${id}`);
-          resolve({ approved: false, reason: "Session switched to local mode" });
-        }
-        requests.clear();
-        session.updateAgentState((currentState) => {
-          const pendingRequests = currentState.requests || {};
-          const completedRequests = { ...currentState.completedRequests };
-          for (const [id, request] of Object.entries(pendingRequests)) {
-            completedRequests[id] = {
-              ...request,
-              completedAt: Date.now(),
-              status: "canceled",
-              reason: "Session switched to local mode"
-            };
-          }
-          return {
-            ...currentState,
-            controlledByUser: true,
-            requests: {},
-            // Clear all pending requests
-            completedRequests
-          };
-        });
-      } else {
-        session.updateAgentState((currentState) => ({
-          ...currentState,
-          controlledByUser: false
-        }));
-      }
-    },
-    onProcessStart: (processMode) => {
-      logger.debug(`[Process Lifecycle] Starting ${processMode} mode`);
-      logger.debug("Starting process - clearing any stale permission requests");
-      for (const [id, resolve] of requests) {
-        logger.debug(`Rejecting stale permission request: ${id}`);
-        resolve({ approved: false, reason: "Process restarted" });
-      }
-      requests.clear();
+      session.updateAgentState((currentState) => ({
+        ...currentState,
+        controlledByUser: false
+      }));
     },
-    onProcessStop: (processMode) => {
-      logger.debug(`[Process Lifecycle] Stopped ${processMode} mode`);
-      logger.debug("Stopping process - clearing any stale permission requests");
-      for (const [id, resolve] of requests) {
-        logger.debug(`Rejecting stale permission request: ${id}`);
-        resolve({ approved: false, reason: "Process restarted" });
-      }
-      requests.clear();
-      thinking = false;
-      session.keepAlive(thinking, mode);
-    },
-    mcpServers: {
-      "permission": {
-        type: "http",
-        url: permissionServer.url
-      }
-    },
-    permissionPromptToolName: "mcp__permission__" + permissionServer.toolName,
+    mcpServers: {},
     session,
-    onAssistantResult,
-    interruptController,
     claudeEnvVars: options.claudeEnvVars,
-    claudeArgs: options.claudeArgs,
-    onThinkingChange: (newThinking) => {
-      thinking = newThinking;
-      session.keepAlive(thinking, mode);
-    },
-    onToolCallResolver: (resolver) => {
-      toolCallResolver = resolver;
-    }
+    claudeArgs: options.claudeArgs
   });
-  clearInterval(pingInterval);
+  session.sendSessionDeath();
+  logger.debug("Waiting for socket to flush...");
+  await session.flush();
+  logger.debug("Closing session...");
+  await session.close();
+  stopCaffeinate();
+  logger.debug("Stopped sleep prevention");
   process.exit(0);
 }
 
@@ -2233,7 +3025,7 @@ class ApiDaemonSession extends EventEmitter {
     this.token = token;
     this.secret = secret;
     this.machineIdentity = machineIdentity;
-    logger.daemonDebug(`Connecting to server: ${configuration.serverUrl}`);
+    logger.debug(`[DAEMON SESSION] Connecting to server: ${configuration.serverUrl}`);
     const socket = io(configuration.serverUrl, {
       auth: {
         token: this.token,
@@ -2250,19 +3042,19 @@ class ApiDaemonSession extends EventEmitter {
       autoConnect: false
     });
     socket.on("connect", () => {
-      logger.daemonDebug("Socket connected");
-      logger.daemonDebug(`Connected with auth - token: ${this.token.substring(0, 10)}..., machineId: ${this.machineIdentity.machineId}`);
+      logger.debug("[DAEMON SESSION] Socket connected");
+      logger.debug(`[DAEMON SESSION] Connected with auth - token: ${this.token.substring(0, 10)}..., machineId: ${this.machineIdentity.machineId}`);
       const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
       socket.emit("rpc-register", { method: rpcMethod });
-      logger.daemonDebug(`Emitted RPC registration: ${rpcMethod}`);
+      logger.debug(`[DAEMON SESSION] Emitted RPC registration: ${rpcMethod}`);
       this.emit("connected");
       this.startKeepAlive();
     });
     socket.on("rpc-request", async (data, callback) => {
-      logger.daemonDebug(`Received RPC request: ${JSON.stringify(data)}`);
+      logger.debug(`[DAEMON SESSION] Received RPC request: ${JSON.stringify(data)}`);
       const expectedMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
       if (data.method === expectedMethod) {
-        logger.daemonDebug("Processing spawn-happy-session RPC");
+        logger.debug("[DAEMON SESSION] Processing spawn-happy-session RPC");
         try {
           const { directory } = data.params || {};
           if (!directory) {
@@ -2277,26 +3069,25 @@ class ApiDaemonSession extends EventEmitter {
           if (configuration.installationLocation === "local") {
             args.push("--local");
           }
-          if (configuration.serverUrl !== "https://handy-api.korshakov.org") {
-            args.push("--happy-server-url", configuration.serverUrl);
-          }
-          logger.daemonDebug(`Spawning happy in directory: ${directory} with args: ${args.join(" ")}`);
+          logger.debug(`[DAEMON SESSION] Spawning happy in directory: ${directory} with args: ${args.join(" ")}`);
           const happyPath = process.argv[1];
-          const isTypeScript = happyPath.endsWith(".ts");
-          const happyProcess = isTypeScript ? spawn$1("npx", ["tsx", happyPath, ...args], {
-            cwd: directory,
-            env: { ...process.env, EXPERIMENTAL_FEATURES: "1" },
-            detached: true,
-            stdio: ["ignore", "pipe", "pipe"]
-            // We need stdout
-          }) : spawn$1(process.argv[0], [happyPath, ...args], {
+          const runningFromBuiltBinary = happyPath.endsWith("happy") || happyPath.endsWith("happy.cmd");
+          let executable, spawnArgs;
+          if (runningFromBuiltBinary) {
+            executable = happyPath;
+            spawnArgs = args;
+          } else {
+            executable = "npx";
+            spawnArgs = ["tsx", happyPath, ...args];
+          }
+          const happyProcess = spawn$1(executable, spawnArgs, {
             cwd: directory,
-            env: { ...process.env, EXPERIMENTAL_FEATURES: "1" },
             detached: true,
             stdio: ["ignore", "pipe", "pipe"]
             // We need stdout
           });
           this.spawnedProcesses.add(happyProcess);
+          this.updateChildPidsInMetadata();
           let sessionId = null;
           let output = "";
           let timeoutId = null;
@@ -2315,17 +3106,17 @@ class ApiDaemonSession extends EventEmitter {
             const match = output.match(/daemon:sessionIdCreated:(.+?)[\n\r]/);
             if (match && !sessionId) {
               sessionId = match[1];
-              logger.daemonDebug(`Session spawned successfully: ${sessionId}`);
+              logger.debug(`[DAEMON SESSION] Session spawned successfully: ${sessionId}`);
               callback({ sessionId });
               cleanup();
               happyProcess.unref();
             }
           });
           happyProcess.stderr.on("data", (data2) => {
-            logger.daemonDebug(`Spawned process stderr: ${data2.toString()}`);
+            logger.debug(`[DAEMON SESSION] Spawned process stderr: ${data2.toString()}`);
           });
           happyProcess.on("error", (error) => {
-            logger.daemonDebug("Error spawning session:", error);
+            logger.debug("[DAEMON SESSION] Error spawning session:", error);
             if (!sessionId) {
               callback({ error: `Failed to spawn: ${error.message}` });
               cleanup();
@@ -2333,8 +3124,9 @@ class ApiDaemonSession extends EventEmitter {
             }
           });
           happyProcess.on("exit", (code, signal) => {
-            logger.daemonDebug(`Spawned process exited with code ${code}, signal ${signal}`);
+            logger.debug(`[DAEMON SESSION] Spawned process exited with code ${code}, signal ${signal}`);
             this.spawnedProcesses.delete(happyProcess);
+            this.updateChildPidsInMetadata();
             if (!sessionId) {
               callback({ error: `Process exited before session ID received` });
               cleanup();
@@ -2342,53 +3134,54 @@ class ApiDaemonSession extends EventEmitter {
           });
           timeoutId = setTimeout(() => {
             if (!sessionId) {
-              logger.daemonDebug("Timeout waiting for session ID");
+              logger.debug("[DAEMON SESSION] Timeout waiting for session ID");
               callback({ error: "Timeout waiting for session" });
               cleanup();
               happyProcess.kill();
               this.spawnedProcesses.delete(happyProcess);
+              this.updateChildPidsInMetadata();
             }
           }, 1e4);
         } catch (error) {
-          logger.daemonDebug("Error spawning session:", error);
+          logger.debug("[DAEMON SESSION] Error spawning session:", error);
           callback({ error: error instanceof Error ? error.message : "Unknown error" });
         }
       } else {
-        logger.daemonDebug(`Unknown RPC method: ${data.method}`);
+        logger.debug(`[DAEMON SESSION] Unknown RPC method: ${data.method}`);
         callback({ error: `Unknown method: ${data.method}` });
       }
     });
     socket.on("disconnect", (reason) => {
-      logger.daemonDebug(`Disconnected from server. Reason: ${reason}`);
+      logger.debug(`[DAEMON SESSION] Disconnected from server. Reason: ${reason}`);
       this.emit("disconnected");
       this.stopKeepAlive();
     });
     socket.on("reconnect", () => {
-      logger.daemonDebug("Reconnected to server");
+      logger.debug("[DAEMON SESSION] Reconnected to server");
       const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
       socket.emit("rpc-register", { method: rpcMethod });
-      logger.daemonDebug(`Re-registered RPC method: ${rpcMethod}`);
+      logger.debug(`[DAEMON SESSION] Re-registered RPC method: ${rpcMethod}`);
     });
     socket.on("rpc-registered", (data) => {
-      logger.daemonDebug(`RPC registration confirmed: ${data.method}`);
+      logger.debug(`[DAEMON SESSION] RPC registration confirmed: ${data.method}`);
     });
     socket.on("rpc-unregistered", (data) => {
-      logger.daemonDebug(`RPC unregistered: ${data.method}`);
+      logger.debug(`[DAEMON SESSION] RPC unregistered: ${data.method}`);
     });
     socket.on("rpc-error", (data) => {
-      logger.daemonDebug(`RPC error: ${JSON.stringify(data)}`);
+      logger.debug(`[DAEMON SESSION] RPC error: ${JSON.stringify(data)}`);
     });
     socket.onAny((event, ...args) => {
       if (!event.startsWith("machine-alive")) {
-        logger.daemonDebug(`Socket event: ${event}, args: ${JSON.stringify(args)}`);
+        logger.debug(`[DAEMON SESSION] Socket event: ${event}, args: ${JSON.stringify(args)}`);
       }
     });
     socket.on("connect_error", (error) => {
-      logger.daemonDebug(`Connection error: ${error.message}`);
-      logger.daemonDebug(`Error: ${JSON.stringify(error, null, 2)}`);
+      logger.debug(`[DAEMON SESSION] Connection error: ${error.message}`);
+      logger.debug(`[DAEMON SESSION] Error: ${JSON.stringify(error, null, 2)}`);
     });
     socket.on("error", (error) => {
-      logger.daemonDebug(`Socket error: ${error}`);
+      logger.debug(`[DAEMON SESSION] Socket error: ${error}`);
     });
     socket.on("daemon-command", (data) => {
       switch (data.command) {
@@ -2416,14 +3209,27 @@ class ApiDaemonSession extends EventEmitter {
       this.keepAliveInterval = null;
     }
   }
+  updateChildPidsInMetadata() {
+    try {
+      if (existsSync$1(configuration.daemonMetadataFile)) {
+        const content = readFileSync$1(configuration.daemonMetadataFile, "utf-8");
+        const metadata = JSON.parse(content);
+        const childPids = Array.from(this.spawnedProcesses).map((proc) => proc.pid).filter((pid) => pid !== void 0);
+        metadata.childPids = childPids;
+        writeFileSync(configuration.daemonMetadataFile, JSON.stringify(metadata, null, 2));
+      }
+    } catch (error) {
+      logger.debug("[DAEMON SESSION] Error updating child PIDs in metadata:", error);
+    }
+  }
   connect() {
     this.socket.connect();
   }
   shutdown() {
-    logger.daemonDebug(`Shutting down daemon, killing ${this.spawnedProcesses.size} spawned processes`);
+    logger.debug(`[DAEMON SESSION] Shutting down daemon, killing ${this.spawnedProcesses.size} spawned processes`);
     for (const process2 of this.spawnedProcesses) {
       try {
-        logger.daemonDebug(`Killing spawned process with PID: ${process2.pid}`);
+        logger.debug(`[DAEMON SESSION] Killing spawned process with PID: ${process2.pid}`);
         process2.kill("SIGTERM");
         setTimeout(() => {
           try {
@@ -2432,39 +3238,66 @@ class ApiDaemonSession extends EventEmitter {
           }
         }, 1e3);
       } catch (error) {
-        logger.daemonDebug(`Error killing process: ${error}`);
+        logger.debug(`[DAEMON SESSION] Error killing process: ${error}`);
       }
     }
     this.spawnedProcesses.clear();
+    this.updateChildPidsInMetadata();
     this.stopKeepAlive();
     this.socket.close();
     this.emit("shutdown");
   }
 }
 
-let pidFileFd = null;
 async function startDaemon() {
   if (process.platform !== "darwin") {
     console.error("ERROR: Daemon is only supported on macOS");
     process.exit(1);
   }
-  logger.daemonDebug("Starting daemon process...");
-  logger.daemonDebug(`Server URL: ${configuration.serverUrl}`);
-  if (await isDaemonRunning()) {
-    logger.daemonDebug("Happy daemon is already running");
-    process.exit(0);
+  logger.debug("[DAEMON RUN] Starting daemon process...");
+  logger.debug(`[DAEMON RUN] Server URL: ${configuration.serverUrl}`);
+  const runningDaemon = await getDaemonMetadata();
+  if (runningDaemon) {
+    if (runningDaemon.version !== packageJson.version) {
+      logger.debug(`[DAEMON RUN] Daemon version mismatch (running: ${runningDaemon.version}, current: ${packageJson.version}), restarting...`);
+      await stopDaemon();
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    } else if (await isDaemonProcessRunning(runningDaemon.pid)) {
+      logger.debug("[DAEMON RUN] Happy daemon is already running with correct version");
+      process.exit(0);
+    } else {
+      logger.debug("[DAEMON RUN] Stale daemon metadata found, cleaning up");
+      await cleanupDaemonMetadata();
+    }
+  }
+  const oldMetadata = await getDaemonMetadata();
+  if (oldMetadata && oldMetadata.childPids && oldMetadata.childPids.length > 0) {
+    logger.debug(`[DAEMON RUN] Found ${oldMetadata.childPids.length} potential orphaned child processes from previous run`);
+    for (const childPid of oldMetadata.childPids) {
+      try {
+        process.kill(childPid, 0);
+        const isHappy = await isProcessHappyChild(childPid);
+        if (isHappy) {
+          logger.debug(`[DAEMON RUN] Killing orphaned happy process ${childPid}`);
+          process.kill(childPid, "SIGTERM");
+          await new Promise((resolve) => setTimeout(resolve, 500));
+          try {
+            process.kill(childPid, 0);
+            process.kill(childPid, "SIGKILL");
+          } catch {
+          }
+        }
+      } catch {
+        logger.debug(`[DAEMON RUN] Process ${childPid} doesn't exist (already dead)`);
+      }
+    }
+  }
+  writeDaemonMetadata();
+  logger.debug("[DAEMON RUN] Daemon metadata written");
+  const caffeinateStarted = startCaffeinate();
+  if (caffeinateStarted) {
+    logger.debug("[DAEMON RUN] Sleep prevention enabled for daemon");
   }
-  pidFileFd = writePidFile();
-  logger.daemonDebug("PID file written");
-  process.on("SIGINT", () => {
-    stopDaemon().catch(console.error);
-  });
-  process.on("SIGTERM", () => {
-    stopDaemon().catch(console.error);
-  });
-  process.on("exit", () => {
-    stopDaemon().catch(console.error);
-  });
   try {
     const settings = await readSettings() || { onboardingCompleted: false };
     if (!settings.machineId) {
@@ -2476,11 +3309,11 @@ async function startDaemon() {
       machineId: settings.machineId,
       machineHost: settings.machineHost || hostname(),
       platform: process.platform,
-      version: process.env.npm_package_version || "unknown"
+      version: packageJson.version
     };
     let credentials = await readCredentials();
     if (!credentials) {
-      logger.daemonDebug("No credentials found, running auth");
+      logger.debug("[DAEMON RUN] No credentials found, running auth");
       await doAuth();
       credentials = await readCredentials();
       if (!credentials) {
@@ -2494,20 +3327,37 @@ async function startDaemon() {
       machineIdentity
     );
     daemon.on("connected", () => {
-      logger.daemonDebug("Connected to server event received");
+      logger.debug("[DAEMON RUN] Connected to server event received");
     });
     daemon.on("disconnected", () => {
-      logger.daemonDebug("Disconnected from server event received");
+      logger.debug("[DAEMON RUN] Disconnected from server event received");
     });
     daemon.on("shutdown", () => {
-      logger.daemonDebug("Shutdown requested");
-      stopDaemon();
+      logger.debug("[DAEMON RUN] Shutdown requested");
+      daemon?.shutdown();
+      cleanupDaemonMetadata();
       process.exit(0);
     });
     daemon.connect();
-    logger.daemonDebug("Daemon started successfully");
+    logger.debug("[DAEMON RUN] Daemon started successfully");
+    process.on("SIGINT", async () => {
+      logger.debug("[DAEMON RUN] Received SIGINT, shutting down...");
+      if (daemon) {
+        daemon.shutdown();
+      }
+      await cleanupDaemonMetadata();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      logger.debug("[DAEMON RUN] Received SIGTERM, shutting down...");
+      if (daemon) {
+        daemon.shutdown();
+      }
+      await cleanupDaemonMetadata();
+      process.exit(0);
+    });
   } catch (error) {
-    logger.daemonDebug("Failed to start daemon", error);
+    logger.debug("[DAEMON RUN] Failed to start daemon", error);
     stopDaemon();
     process.exit(1);
   }
@@ -2517,96 +3367,114 @@ async function startDaemon() {
 }
 async function isDaemonRunning() {
   try {
-    logger.daemonDebug("[isDaemonRunning] Checking if daemon is running...");
-    if (existsSync$1(configuration.daemonPidFile)) {
-      logger.daemonDebug("[isDaemonRunning] PID file exists");
-      const pid = parseInt(readFileSync$1(configuration.daemonPidFile, "utf-8"));
-      logger.daemonDebug("[isDaemonRunning] PID from file:", pid);
-      try {
-        process.kill(pid, 0);
-        logger.daemonDebug("[isDaemonRunning] Process exists, checking if it's a happy daemon...");
-        const isHappyDaemon = await isProcessHappyDaemon(pid);
-        logger.daemonDebug("[isDaemonRunning] isHappyDaemon:", isHappyDaemon);
-        if (isHappyDaemon) {
-          return true;
-        } else {
-          logger.daemonDebug("[isDaemonRunning] PID is not a happy daemon, cleaning up");
-          logger.debug(`PID ${pid} is not a happy daemon, cleaning up`);
-          unlinkSync(configuration.daemonPidFile);
-        }
-      } catch (error) {
-        logger.daemonDebug("[isDaemonRunning] Process not running, cleaning up stale PID file");
-        logger.debug("Process not running, cleaning up stale PID file");
-        unlinkSync(configuration.daemonPidFile);
-      }
-    } else {
-      logger.daemonDebug("[isDaemonRunning] No PID file found");
+    logger.debug("[DAEMON RUN] [isDaemonRunning] Checking if daemon is running...");
+    const metadata = await getDaemonMetadata();
+    if (!metadata) {
+      logger.debug("[DAEMON RUN] [isDaemonRunning] No daemon metadata found");
+      return false;
     }
-    return false;
+    logger.debug("[DAEMON RUN] [isDaemonRunning] Daemon metadata exists");
+    logger.debug("[DAEMON RUN] [isDaemonRunning] PID from metadata:", metadata.pid);
+    const isRunning = await isDaemonProcessRunning(metadata.pid);
+    if (!isRunning) {
+      logger.debug("[DAEMON RUN] [isDaemonRunning] Process not running, cleaning up stale metadata");
+      await cleanupDaemonMetadata();
+      return false;
+    }
+    return true;
   } catch (error) {
-    logger.daemonDebug("[isDaemonRunning] Error:", error);
+    logger.debug("[DAEMON RUN] [isDaemonRunning] Error:", error);
     logger.debug("Error checking daemon status", error);
     return false;
   }
 }
-function writePidFile() {
+async function isDaemonProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    logger.debug("[DAEMON RUN] Process exists, checking if it's a happy daemon...");
+    const isHappyDaemon = await isProcessHappyDaemon(pid);
+    logger.debug("[DAEMON RUN] isHappyDaemon:", isHappyDaemon);
+    return isHappyDaemon;
+  } catch (error) {
+    return false;
+  }
+}
+function writeDaemonMetadata(childPids) {
   const happyDir = join$1(homedir$1(), ".happy");
   if (!existsSync$1(happyDir)) {
     mkdirSync$1(happyDir, { recursive: true });
   }
+  const metadata = {
+    pid: process.pid,
+    startTime: (/* @__PURE__ */ new Date()).toISOString(),
+    version: packageJson.version,
+    ...childPids
+  };
+  writeFileSync(configuration.daemonMetadataFile, JSON.stringify(metadata, null, 2));
+}
+async function getDaemonMetadata() {
   try {
-    const fd = openSync(configuration.daemonPidFile, "wx");
-    writeSync(fd, process.pid.toString());
-    return fd;
+    if (!existsSync$1(configuration.daemonMetadataFile)) {
+      return null;
+    }
+    const content = readFileSync$1(configuration.daemonMetadataFile, "utf-8");
+    return JSON.parse(content);
   } catch (error) {
-    if (error.code === "EEXIST") {
-      try {
-        const fd = openSync(configuration.daemonPidFile, "r+");
-        const existingPid = readFileSync$1(configuration.daemonPidFile, "utf-8").trim();
-        closeSync(fd);
-        try {
-          process.kill(parseInt(existingPid), 0);
-          logger.daemonDebug("PID file exists and process is running");
-          logger.daemonDebug("Happy daemon is already running");
-          process.exit(0);
-        } catch {
-          logger.daemonDebug("PID file exists but process is dead, cleaning up");
-          unlinkSync(configuration.daemonPidFile);
-          return writePidFile();
-        }
-      } catch (lockError) {
-        logger.daemonDebug("Cannot acquire write lock on PID file, daemon is running");
-        logger.daemonDebug("Happy daemon is already running");
-        process.exit(0);
-      }
+    logger.debug("Error reading daemon metadata", error);
+    return null;
+  }
+}
+async function cleanupDaemonMetadata() {
+  try {
+    if (existsSync$1(configuration.daemonMetadataFile)) {
+      unlinkSync(configuration.daemonMetadataFile);
     }
-    throw error;
+  } catch (error) {
+    logger.debug("Error cleaning up daemon metadata", error);
   }
 }
 async function stopDaemon() {
   try {
-    if (pidFileFd !== null) {
+    stopCaffeinate();
+    logger.debug("Stopped sleep prevention");
+    const metadata = await getDaemonMetadata();
+    if (metadata) {
+      logger.debug(`Stopping daemon with PID ${metadata.pid}`);
       try {
-        closeSync(pidFileFd);
-      } catch {
-      }
-      pidFileFd = null;
-    }
-    if (existsSync$1(configuration.daemonPidFile)) {
-      const pid = parseInt(readFileSync$1(configuration.daemonPidFile, "utf-8"));
-      logger.debug(`Stopping daemon with PID ${pid}`);
-      try {
-        process.kill(pid, "SIGTERM");
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        process.kill(metadata.pid, "SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
         try {
-          process.kill(pid, 0);
-          process.kill(pid, "SIGKILL");
+          process.kill(metadata.pid, 0);
+          logger.debug("Daemon still running, force killing...");
+          process.kill(metadata.pid, "SIGKILL");
         } catch {
+          logger.debug("Daemon exited cleanly");
         }
       } catch (error) {
-        logger.debug("Process already dead or inaccessible", error);
+        logger.debug("Daemon process already dead or inaccessible", error);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (metadata.childPids && metadata.childPids.length > 0) {
+        logger.debug(`Checking for ${metadata.childPids.length} potential orphaned child processes...`);
+        for (const childPid of metadata.childPids) {
+          try {
+            process.kill(childPid, 0);
+            const isHappy = await isProcessHappyChild(childPid);
+            if (isHappy) {
+              logger.debug(`Killing orphaned happy process ${childPid}`);
+              process.kill(childPid, "SIGTERM");
+              await new Promise((resolve) => setTimeout(resolve, 500));
+              try {
+                process.kill(childPid, 0);
+                process.kill(childPid, "SIGKILL");
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
       }
-      unlinkSync(configuration.daemonPidFile);
+      await cleanupDaemonMetadata();
     }
   } catch (error) {
     logger.debug("Error stopping daemon", error);
@@ -2628,6 +3496,22 @@ async function isProcessHappyDaemon(pid) {
     });
   });
 }
+async function isProcessHappyChild(pid) {
+  return new Promise((resolve) => {
+    const ps = spawn$1("ps", ["-p", pid.toString(), "-o", "command="]);
+    let output = "";
+    ps.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+    ps.on("close", () => {
+      const isHappyChild = output.includes("--daemon-spawn") && (output.includes("happy") || output.includes("src/index"));
+      resolve(isHappyChild);
+    });
+    ps.on("error", () => {
+      resolve(false);
+    });
+  });
+}
 
 function trimIdent(text) {
   const lines = text.split("\n");
@@ -2655,7 +3539,7 @@ async function install$1() {
   try {
     if (existsSync$1(PLIST_FILE$1)) {
       logger.info("Daemon plist already exists. Uninstalling first...");
-      execSync(`launchctl unload ${PLIST_FILE$1}`, { stdio: "inherit" });
+      execSync$1(`launchctl unload ${PLIST_FILE$1}`, { stdio: "inherit" });
     }
     const happyPath = process.argv[0];
     const scriptPath = process.argv[1];
@@ -2700,7 +3584,7 @@ async function install$1() {
     writeFileSync(PLIST_FILE$1, plistContent);
     chmodSync(PLIST_FILE$1, 420);
     logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
-    execSync(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
+    execSync$1(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
     logger.info("Daemon installed and started successfully");
     logger.info("Check logs at ~/.happy/daemon.log");
   } catch (error) {
@@ -2729,7 +3613,7 @@ async function uninstall$1() {
       return;
     }
     try {
-      execSync(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
+      execSync$1(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
       logger.info("Daemon stopped successfully");
     } catch (error) {
       logger.info("Failed to unload daemon (it might not be running)");
@@ -2757,12 +3641,7 @@ async function uninstall() {
 (async () => {
   const args = process.argv.slice(2);
   let installationLocation = args.includes("--local") || process.env.HANDY_LOCAL ? "local" : "global";
-  let serverUrl;
-  const serverUrlIndex = args.indexOf("--happy-server-url");
-  if (serverUrlIndex !== -1 && serverUrlIndex + 1 < args.length) {
-    serverUrl = args[serverUrlIndex + 1];
-  }
-  initializeConfiguration(installationLocation, serverUrl);
+  initializeConfiguration(installationLocation);
   initLoggerWithGlobalConfiguration();
   logger.debug("Starting happy CLI with args: ", process.argv);
   const subcommand = args[0];
@@ -2846,8 +3725,6 @@ Currently only supported on macOS.
         options.claudeArgs = [...options.claudeArgs || [], claudeArg];
       } else if (arg === "--daemon-spawn") {
         options.daemonSpawn = true;
-      } else if (arg === "--happy-server-url") {
-        i++;
       } else {
         console.error(chalk.red(`Unknown argument: ${arg}`));
         process.exit(1);
@@ -2855,7 +3732,7 @@ Currently only supported on macOS.
     }
     if (showHelp) {
       console.log(`
-${chalk.bold("happy")} - Claude Code session sharing
+${chalk.bold("happy")} - Claude Code On the Go
 
 ${chalk.bold("Usage:")}
   happy [options]
@@ -2896,6 +3773,10 @@ ${chalk.bold("Examples:")}
   happy --claude-arg --option
                           Pass argument to Claude CLI
   happy logout            Logs out of your account and removes data directory
+
+[TODO: add after steve's refactor lands]
+${chalk.bold("Happy is a seamless passthrough to Claude CLI - so any commands that Claude CLI supports will work with Happy. Here is the help for Claude CLI:")}
+TODO: exec cluade --help and show inline here
 `);
       process.exit(0);
     }
@@ -2912,7 +3793,6 @@ ${chalk.bold("Examples:")}
       credentials = res;
     }
     const settings = await readSettings() || { onboardingCompleted: false };
-    process.env.EXPERIMENTAL_FEATURES !== void 0;
     if (settings.daemonAutoStartWhenRunningHappy === void 0) {
       console.log(chalk.cyan("\n\u{1F680} Happy Daemon Setup\n"));
       const rl = createInterface({
@@ -2938,39 +3818,26 @@ ${chalk.bold("Examples:")}
       await writeSettings(settings);
     }
     if (settings.daemonAutoStartWhenRunningHappy) {
-      console.debug("Starting Happy background service...");
+      logger.debug("Starting Happy background service...");
       if (!await isDaemonRunning()) {
         const happyPath = process.argv[1];
-        const isBuiltBinary = happyPath.endsWith("/bin/happy") || happyPath.endsWith("\\bin\\happy");
+        const runningFromBuiltBinary = happyPath.endsWith("happy") || happyPath.endsWith("happy.cmd");
         const daemonArgs = ["daemon", "start"];
-        if (serverUrl) {
-          daemonArgs.push("--happy-server-url", serverUrl);
-        }
         if (installationLocation === "local") {
           daemonArgs.push("--local");
         }
-        const daemonProcess = isBuiltBinary ? spawn$1(happyPath, daemonArgs, {
-          detached: true,
-          stdio: ["ignore", "inherit", "inherit"],
-          // Show stdout/stderr for debugging
-          env: {
-            ...process.env,
-            HANDY_SERVER_URL: serverUrl || process.env.HANDY_SERVER_URL,
-            // Pass through server URL
-            HANDY_LOCAL: process.env.HANDY_LOCAL
-            // Pass through local flag
-          }
-        }) : spawn$1("npx", ["tsx", happyPath, ...daemonArgs], {
+        let executable, args2;
+        if (runningFromBuiltBinary) {
+          executable = happyPath;
+          args2 = daemonArgs;
+        } else {
+          executable = "npx";
+          args2 = ["tsx", happyPath, ...daemonArgs];
+        }
+        const daemonProcess = spawn$1(executable, args2, {
           detached: true,
-          stdio: ["ignore", "inherit", "inherit"],
+          stdio: ["ignore", "inherit", "inherit"]
           // Show stdout/stderr for debugging
-          env: {
-            ...process.env,
-            HANDY_SERVER_URL: serverUrl || process.env.HANDY_SERVER_URL,
-            // Pass through server URL
-            HANDY_LOCAL: process.env.HANDY_LOCAL
-            // Pass through local flag
-          }
         });
         daemonProcess.unref();
         await new Promise((resolve) => setTimeout(resolve, 200));