@zonease/happy 0.6.38 → 0.6.39

package/dist/runClaude-DNHvERX0.mjs

@@ -0,0 +1,3763 @@
+import os, { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
+import { readFile, mkdir, writeFile, stat, copyFile } from 'node:fs/promises';
+import { I as InvalidateSync, k as AsyncLock, d as connectionState, A as ApiClient, r as resolveToolsDir, s as startOfflineReconnection, l as findClaudeProjectId } from './api-CIZKyfSn.mjs';
+import { l as logger, i as isDebug, c as configuration, a as readSettings, p as packageJson } from './persistence-BFjvtUad.mjs';
+import { g as getProjectPath, a as claudeLocal, E as ExitCodeError, b as claudeCheckSession, s as systemPrompt } from './claudeLocal-CPT3zcIU.mjs';
+import { R as RawJSONLinesSchema } from './types-BoJh4Qfv.mjs';
+import { join, resolve } from 'node:path';
+import { d as delay } from './time-DgsBLJA_.mjs';
+import { watch, access } from 'fs/promises';
+import { useStdout, useInput, Box, Text, render } from 'ink';
+import { e as parseSpecialCommand, b as MessageBuffer, c as createMcpContext, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler, a as detectGitWorktree } from './downloadImage-DfSFLb-h.mjs';
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { execSync, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { i as isBun } from './spawnHappyCLI-CoORX0YW.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import 'axios';
+import 'node:events';
+import 'socket.io-client';
+import 'tweetnacl';
+import 'ws';
+import 'crypto';
+import '@stablelib/base64';
+import 'expo-server-sdk';
+import 'chalk';
+import { a as formatMessageForClaude } from './formatImageMessage-B4lSxlk2.mjs';
+import { isDeepStrictEqual } from 'node:util';
+import { i as initialMachineMetadata, s as stopCaffeinate, a as startCaffeinate } from './run-DBZqN6Kn.mjs';
+import { getEnvironmentInfo } from './doctor-DZYB6IVc.mjs';
+import { notifyDaemonSessionStarted } from './controlClient-CM_QcJnB.mjs';
+import { createServer } from 'node:http';
+import 'zod';
+import './index-CPKdvi7J.mjs';
+import '@paralleldrive/cuid2';
+import 'child_process';
+import 'util';
+import 'path';
+import 'node:module';
+import './sessionKeyCache-D2BwO91C.mjs';
+import 'fs';
+import './prompt-BsAZsPbo.mjs';
+import './trimIdent-BAjmv_TG.mjs';
+import './common-BdNgghUJ.mjs';
+import '@modelcontextprotocol/sdk/server/mcp.js';
+import '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import '@modelcontextprotocol/sdk/types.js';
+import './deviceExec-D93AOVV4.mjs';
+import './auth-BE8dD20T.mjs';
+import 'qrcode-terminal';
+import './browser-Dll5hxOV.mjs';
+import 'open';
+import './mcpToolSchemas-CjeTfrAs.mjs';
+import 'url';
+import 'os';
+import 'tmp';
+import './install-oRAjVLjP.mjs';
+import 'fastify';
+import 'fastify-type-provider-zod';
+import './doctor-ON7pN5G5.mjs';
+import 'ps-list';
+import 'cross-spawn';
+
+class Session {
+  path;
+  logPath;
+  api;
+  client;
+  queue;
+  claudeEnvVars;
+  claudeArgs;
+  // Made mutable to allow filtering
+  mcpServers;
+  allowedTools;
+  _onModeChange;
+  /** Path to temporary settings file with SessionStart hook (required for session tracking) */
+  hookSettingsPath;
+  /** JavaScript runtime to use for spawning Claude Code (default: 'node') */
+  jsRuntime;
+  sessionId;
+  mode = "local";
+  thinking = false;
+  /** Callbacks to be notified when session ID is found/changed */
+  sessionFoundCallbacks = [];
+  /** Keep alive interval reference for cleanup */
+  keepAliveInterval;
+  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.allowedTools = opts.allowedTools;
+    this._onModeChange = opts.onModeChange;
+    this.hookSettingsPath = opts.hookSettingsPath;
+    this.jsRuntime = opts.jsRuntime ?? "node";
+    this.client.keepAlive(this.thinking, this.mode);
+    this.keepAliveInterval = setInterval(() => {
+      this.client.keepAlive(this.thinking, this.mode);
+    }, 2e3);
+  }
+  /**
+   * Cleanup resources (call when session is no longer needed)
+   */
+  cleanup = () => {
+    clearInterval(this.keepAliveInterval);
+    this.sessionFoundCallbacks = [];
+    logger.debug("[Session] Cleaned up resources");
+  };
+  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);
+  };
+  /**
+   * Called when Claude session ID is discovered or changed.
+   * 
+   * This is triggered by the SessionStart hook when:
+   * - Claude starts a new session (fresh start)
+   * - Claude resumes a session (--continue, --resume flags)
+   * - Claude forks a session (/compact, double-escape fork)
+   * 
+   * Updates internal state, syncs to API metadata, and notifies
+   * all registered callbacks (e.g., SessionScanner) about the change.
+   */
+  onSessionFound = (sessionId) => {
+    this.sessionId = sessionId;
+    this.client.updateMetadata((metadata) => ({
+      ...metadata,
+      claudeSessionId: sessionId
+    }));
+    logger.debug(`[Session] Claude Code session ID ${sessionId} added to metadata`);
+    for (const callback of this.sessionFoundCallbacks) {
+      callback(sessionId);
+    }
+  };
+  /**
+   * Register a callback to be notified when session ID is found/changed
+   */
+  addSessionFoundCallback = (callback) => {
+    this.sessionFoundCallbacks.push(callback);
+  };
+  /**
+   * Remove a session found callback
+   */
+  removeSessionFoundCallback = (callback) => {
+    const index = this.sessionFoundCallbacks.indexOf(callback);
+    if (index !== -1) {
+      this.sessionFoundCallbacks.splice(index, 1);
+    }
+  };
+  /**
+   * Clear the current session ID (used by /clear command)
+   */
+  clearSessionId = () => {
+    this.sessionId = null;
+    logger.debug("[Session] Session ID cleared");
+  };
+  /**
+   * Consume one-time Claude flags from claudeArgs after Claude spawn
+   * Handles: --resume (with or without session ID), --continue
+   */
+  consumeOneTimeFlags = () => {
+    if (!this.claudeArgs) return;
+    const filteredArgs = [];
+    for (let i = 0; i < this.claudeArgs.length; i++) {
+      const arg = this.claudeArgs[i];
+      if (arg === "--continue") {
+        logger.debug("[Session] Consumed --continue flag");
+        continue;
+      }
+      if (arg === "--resume") {
+        if (i + 1 < this.claudeArgs.length) {
+          const nextArg = this.claudeArgs[i + 1];
+          if (!nextArg.startsWith("-") && nextArg.includes("-")) {
+            i++;
+            logger.debug(`[Session] Consumed --resume flag with session ID: ${nextArg}`);
+          } else {
+            logger.debug("[Session] Consumed --resume flag (no session ID)");
+          }
+        } else {
+          logger.debug("[Session] Consumed --resume flag (no session ID)");
+        }
+        continue;
+      }
+      filteredArgs.push(arg);
+    }
+    this.claudeArgs = filteredArgs.length > 0 ? filteredArgs : void 0;
+    logger.debug(`[Session] Consumed one-time flags, remaining args:`, this.claudeArgs);
+  };
+}
+
+class Future {
+  _resolve;
+  _reject;
+  _promise;
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+  get promise() {
+    return this._promise;
+  }
+}
+
+function startFileWatcher(file, onFileChange) {
+  const abortController = new AbortController();
+  void (async () => {
+    while (true) {
+      try {
+        logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
+        const watcher = watch(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();
+  };
+}
+
+const INTERNAL_CLAUDE_EVENT_TYPES$1 = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation"
+]);
+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$1(projectDir, opts.sessionId);
+    logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
+    for (let m of messages) {
+      processedMessageKeys.add(messageKey$1(m));
+    }
+    currentSessionId = opts.sessionId;
+  }
+  const sync = new InvalidateSync(async () => {
+    let sessions = [];
+    for (let p of pendingSessions) {
+      sessions.push(p);
+    }
+    if (currentSessionId && !pendingSessions.has(currentSessionId)) {
+      sessions.push(currentSessionId);
+    }
+    for (let [sessionId] of watchers) {
+      if (!sessions.includes(sessionId)) {
+        sessions.push(sessionId);
+      }
+    }
+    for (let session of sessions) {
+      const sessionMessages = await readSessionLog$1(projectDir, session);
+      let skipped = 0;
+      let sent = 0;
+      for (let file of sessionMessages) {
+        let key = messageKey$1(file);
+        if (processedMessageKeys.has(key)) {
+          skipped++;
+          continue;
+        }
+        processedMessageKeys.add(key);
+        logger.debug(`[SESSION_SCANNER] Sending new message: type=${file.type}, uuid=${file.type === "summary" ? file.leafUuid : file.uuid}`);
+        opts.onMessage(file);
+        sent++;
+      }
+      if (sessionMessages.length > 0) {
+        logger.debug(`[SESSION_SCANNER] Session ${session}: found=${sessionMessages.length}, skipped=${skipped}, sent=${sent}`);
+      }
+    }
+    for (let p of sessions) {
+      if (pendingSessions.has(p)) {
+        pendingSessions.delete(p);
+        finishedSessions.add(p);
+      }
+    }
+    for (let p of sessions) {
+      if (!watchers.has(p)) {
+        logger.debug(`[SESSION_SCANNER] Starting watcher for session: ${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$1(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 if (message.type === "progress") {
+    return message.uuid;
+  } else {
+    throw Error();
+  }
+}
+async function readSessionLog$1(projectDir, sessionId) {
+  const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
+  logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
+  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);
+      if (message.type && INTERNAL_CLAUDE_EVENT_TYPES$1.has(message.type)) {
+        continue;
+      }
+      let parsed = RawJSONLinesSchema.safeParse(message);
+      if (!parsed.success) {
+        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) => {
+      if (message.type !== "summary") {
+        session.client.sendClaudeSessionMessage(message);
+      }
+    }
+  });
+  const scannerSessionCallback = (sessionId) => {
+    scanner.onNewSession(sessionId);
+  };
+  session.addSessionFoundCallback(scannerSessionCallback);
+  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 = { type: "switch" };
+      }
+      session.queue.reset();
+      await abort();
+    }
+    async function doSwitch() {
+      logger.debug("[local]: doSwitch");
+      if (!exitReason) {
+        exitReason = { type: "switch" };
+      }
+      await abort();
+    }
+    session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+    session.queue.setOnMessage((message, mode) => {
+      doSwitch();
+    });
+    if (session.queue.size() > 0) {
+      return { type: "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,
+          mcpServers: session.mcpServers,
+          allowedTools: session.allowedTools,
+          hookSettingsPath: session.hookSettingsPath
+        });
+        session.consumeOneTimeFlags();
+        if (!exitReason) {
+          exitReason = { type: "exit", code: 0 };
+          break;
+        }
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        logger.debug("[local]: launch error", e);
+        if (e instanceof ExitCodeError) {
+          if (!exitReason) {
+            exitReason = { type: "exit", code: e.exitCode };
+          }
+          break;
+        }
+        if (!exitReason) {
+          session.client.sendSessionEvent({ type: "message", message: `Process exited unexpectedly: ${errorMessage}` });
+          continue;
+        } else {
+          break;
+        }
+      }
+      logger.debug("[local]: launch done");
+    }
+  } finally {
+    exutFuture.resolve(void 0);
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
+    });
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    session.queue.setOnMessage(null);
+    session.removeSessionFoundCallback(scannerSessionCallback);
+    await scanner.cleanup();
+  }
+  return exitReason || { type: "exit", code: 0 };
+}
+
+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")), isDebug() && 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$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = join(__filename$1, "..");
+function getGlobalClaudeVersion() {
+  try {
+    const cleanEnv = getCleanEnv();
+    const output = execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homedir(),
+      env: cleanEnv
+    }).trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    logger.debug(`[Claude SDK] Global claude --version output: ${output}`);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function getCleanEnv() {
+  const env = { ...process.env };
+  const cwd = process.cwd();
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const actualPathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") || pathKey;
+  if (env[actualPathKey]) {
+    const cleanPath = env[actualPathKey].split(pathSep).filter((p) => {
+      const normalizedP = p.replace(/\\/g, "/").toLowerCase();
+      const normalizedCwd = cwd.replace(/\\/g, "/").toLowerCase();
+      return !normalizedP.startsWith(normalizedCwd);
+    }).join(pathSep);
+    env[actualPathKey] = cleanPath;
+    logger.debug(`[Claude SDK] Cleaned PATH, removed local paths from: ${cwd}`);
+  }
+  if (isBun()) {
+    Object.keys(env).forEach((key) => {
+      if (key.startsWith("BUN_")) {
+        delete env[key];
+      }
+    });
+    logger.debug("[Claude SDK] Removed Bun-specific environment variables for Node.js compatibility");
+  }
+  return env;
+}
+function findGlobalClaudePath() {
+  const homeDir = homedir();
+  const cleanEnv = getCleanEnv();
+  try {
+    execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homeDir,
+      env: cleanEnv
+    });
+    logger.debug("[Claude SDK] Global claude command available (checked with clean PATH)");
+    return "claude";
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      const result = execSync("which claude", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: homeDir,
+        env: cleanEnv
+      }).trim();
+      if (result && existsSync(result)) {
+        logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
+        return result;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getDefaultClaudeCodePath() {
+  const nodeModulesPath = join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  if (process.env.HAPPY_CLAUDE_PATH) {
+    logger.debug(`[Claude SDK] Using HAPPY_CLAUDE_PATH: ${process.env.HAPPY_CLAUDE_PATH}`);
+    return process.env.HAPPY_CLAUDE_PATH;
+  }
+  if (process.env.HAPPY_USE_BUNDLED_CLAUDE === "1") {
+    logger.debug(`[Claude SDK] Forced bundled version: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalPath = findGlobalClaudePath();
+  if (!globalPath) {
+    logger.debug(`[Claude SDK] No global claude found, using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalVersion = getGlobalClaudeVersion();
+  logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
+  if (!globalVersion) {
+    logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  return globalPath;
+}
+function logDebug(message) {
+  if (isDebug()) {
+    logger.debug(message);
+    console.log(message);
+  }
+}
+async function streamToStdin(stream, stdin, abort) {
+  for await (const message of stream) {
+    if (abort?.aborted) break;
+    stdin.write(JSON.stringify(message) + "\n");
+  }
+  stdin.end();
+}
+
+class Query {
+  constructor(childStdin, childStdout, processExitPromise, canCallTool) {
+    this.childStdin = childStdin;
+    this.childStdout = childStdout;
+    this.processExitPromise = processExitPromise;
+    this.canCallTool = canCallTool;
+    this.readMessages();
+    this.sdkMessages = this.readSdkMessages();
+  }
+  pendingControlResponses = /* @__PURE__ */ new Map();
+  cancelControllers = /* @__PURE__ */ new Map();
+  sdkMessages;
+  inputStream = new Stream();
+  canCallTool;
+  /**
+   * Set an error on the stream
+   */
+  setError(error) {
+    this.inputStream.error(error);
+  }
+  /**
+   * AsyncIterableIterator implementation
+   */
+  next(...args) {
+    return this.sdkMessages.next(...args);
+  }
+  return(value) {
+    if (this.sdkMessages.return) {
+      return this.sdkMessages.return(value);
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+  throw(e) {
+    if (this.sdkMessages.throw) {
+      return this.sdkMessages.throw(e);
+    }
+    return Promise.reject(e);
+  }
+  [Symbol.asyncIterator]() {
+    return this.sdkMessages;
+  }
+  /**
+   * Read messages from Claude process stdout
+   */
+  async readMessages() {
+    const rl = createInterface({ input: this.childStdout });
+    try {
+      for await (const line of rl) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line);
+            if (message.type === "control_response") {
+              const controlResponse = message;
+              const requestId = controlResponse.response.request_id;
+              const handler = this.pendingControlResponses.get(requestId);
+              if (handler) {
+                this.pendingControlResponses.delete(requestId);
+                handler(controlResponse.response);
+              }
+              continue;
+            } else if (message.type === "control_request") {
+              await this.handleControlRequest(message);
+              continue;
+            } else if (message.type === "control_cancel_request") {
+              this.handleControlCancelRequest(message);
+              continue;
+            }
+            this.inputStream.enqueue(message);
+          } catch (e) {
+            logger.debug(line);
+          }
+        }
+      }
+      await this.processExitPromise;
+    } catch (error) {
+      this.inputStream.error(error);
+    } finally {
+      this.inputStream.done();
+      this.cleanupControllers();
+      rl.close();
+    }
+  }
+  /**
+   * Async generator for SDK messages
+   */
+  async *readSdkMessages() {
+    for await (const message of this.inputStream) {
+      yield message;
+    }
+  }
+  /**
+   * Send interrupt request to Claude
+   */
+  async interrupt() {
+    if (!this.childStdin) {
+      throw new Error("Interrupt requires --input-format stream-json");
+    }
+    await this.request({
+      subtype: "interrupt"
+    }, this.childStdin);
+  }
+  /**
+   * Send control request to Claude process
+   */
+  request(request, childStdin) {
+    const requestId = Math.random().toString(36).substring(2, 15);
+    const sdkRequest = {
+      request_id: requestId,
+      type: "control_request",
+      request
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingControlResponses.set(requestId, (response) => {
+        if (response.subtype === "success") {
+          resolve(response);
+        } else {
+          reject(new Error(response.error));
+        }
+      });
+      childStdin.write(JSON.stringify(sdkRequest) + "\n");
+    });
+  }
+  /**
+   * Handle incoming control requests for tool permissions
+   * Replicates the exact logic from the SDK's handleControlRequest method
+   */
+  async handleControlRequest(request) {
+    if (!this.childStdin) {
+      logDebug("Cannot handle control request - no stdin available");
+      return;
+    }
+    const controller = new AbortController();
+    this.cancelControllers.set(request.request_id, controller);
+    try {
+      const response = await this.processControlRequest(request, controller.signal);
+      const controlResponse = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id,
+          response
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlResponse) + "\n");
+    } catch (error) {
+      const controlErrorResponse = {
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: request.request_id,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlErrorResponse) + "\n");
+    } finally {
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  /**
+   * Handle control cancel requests
+   * Replicates the exact logic from the SDK's handleControlCancelRequest method
+   */
+  handleControlCancelRequest(request) {
+    const controller = this.cancelControllers.get(request.request_id);
+    if (controller) {
+      controller.abort();
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  /**
+   * Process control requests based on subtype
+   * Replicates the exact logic from the SDK's processControlRequest method
+   */
+  async processControlRequest(request, signal) {
+    if (request.request.subtype === "can_use_tool") {
+      if (!this.canCallTool) {
+        throw new Error("canCallTool callback is not provided.");
+      }
+      return this.canCallTool(request.request.tool_name, request.request.input, {
+        signal
+      });
+    }
+    throw new Error("Unsupported control request subtype: " + request.request.subtype);
+  }
+  /**
+   * Cleanup method to abort all pending control requests
+   */
+  cleanupControllers() {
+    for (const [requestId, controller] of this.cancelControllers.entries()) {
+      controller.abort();
+      this.cancelControllers.delete(requestId);
+    }
+  }
+}
+function query(config) {
+  const {
+    prompt,
+    options: {
+      allowedTools = [],
+      appendSystemPrompt,
+      customSystemPrompt,
+      cwd,
+      disallowedTools = [],
+      executable = "node",
+      executableArgs = [],
+      maxTurns,
+      mcpServers,
+      pathToClaudeCodeExecutable = getDefaultClaudeCodePath(),
+      permissionMode = "default",
+      continue: continueConversation,
+      resume,
+      forkSession,
+      model,
+      effort,
+      fallbackModel,
+      strictMcpConfig,
+      canCallTool,
+      settingsPath
+    } = {}
+  } = config;
+  if (!process.env.CLAUDE_CODE_ENTRYPOINT) {
+    process.env.CLAUDE_CODE_ENTRYPOINT = "sdk-ts";
+  }
+  const args = ["--output-format", "stream-json", "--verbose"];
+  if (customSystemPrompt) args.push("--system-prompt", customSystemPrompt);
+  if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
+  if (maxTurns) args.push("--max-turns", maxTurns.toString());
+  if (model) args.push("--model", model);
+  if (effort) args.push("--effort", effort);
+  if (canCallTool) {
+    if (typeof prompt === "string") {
+      throw new Error("canCallTool callback requires --input-format stream-json. Please set prompt as an AsyncIterable.");
+    }
+    args.push("--permission-prompt-tool", "stdio");
+  }
+  if (continueConversation) args.push("--continue");
+  if (resume) args.push("--resume", resume);
+  if (forkSession) args.push("--fork-session");
+  if (allowedTools.length > 0) args.push("--allowedTools", allowedTools.join(","));
+  if (disallowedTools.length > 0) args.push("--disallowedTools", disallowedTools.join(","));
+  if (mcpServers && Object.keys(mcpServers).length > 0) {
+    args.push("--mcp-config", JSON.stringify({ mcpServers }));
+  }
+  if (strictMcpConfig) args.push("--strict-mcp-config");
+  if (permissionMode) args.push("--permission-mode", permissionMode);
+  if (settingsPath) args.push("--settings", settingsPath);
+  if (fallbackModel) {
+    if (model && fallbackModel === model) {
+      throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
+    }
+    args.push("--fallback-model", fallbackModel);
+  }
+  if (typeof prompt === "string") {
+    args.push("--print", prompt.trim());
+  } else {
+    args.push("--input-format", "stream-json");
+  }
+  const isJsFile = pathToClaudeCodeExecutable.endsWith(".js") || pathToClaudeCodeExecutable.endsWith(".cjs");
+  const isCommandOnly = pathToClaudeCodeExecutable === "claude";
+  if (!isCommandOnly && !existsSync(pathToClaudeCodeExecutable)) {
+    throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
+  }
+  const spawnCommand = isJsFile ? executable : pathToClaudeCodeExecutable;
+  const spawnArgs = isJsFile ? [...executableArgs, pathToClaudeCodeExecutable, ...args] : args;
+  const spawnEnv = isCommandOnly ? getCleanEnv() : process.env;
+  logDebug(`Spawning Claude Code process: ${spawnCommand} ${spawnArgs.join(" ")} (using ${isCommandOnly ? "clean" : "normal"} env)`);
+  const child = spawn(spawnCommand, spawnArgs, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    // Note: `signal` intentionally omitted – the abort signal is handled
+    // by the explicit listener below so that callers can send an SDK
+    // interrupt() control-request *before* the process is killed.
+    env: spawnEnv,
+    // Use shell on Windows for global binaries and command-only mode
+    shell: !isJsFile && process.platform === "win32"
+  });
+  let childStdin = null;
+  if (typeof prompt === "string") {
+    child.stdin.end();
+  } else {
+    streamToStdin(prompt, child.stdin, config.options?.abort);
+    childStdin = child.stdin;
+  }
+  const stderrChunks = [];
+  child.stderr.on("data", (data) => {
+    const text = data.toString().trim();
+    if (text) {
+      logger.debug(`[Claude SDK] stderr: ${text}`);
+      stderrChunks.push(text);
+    }
+  });
+  let exited = false;
+  child.on("close", () => {
+    exited = true;
+  });
+  const cleanup = () => {
+    if (exited) return;
+    child.kill("SIGTERM");
+    const killTimer = setTimeout(() => {
+      if (!exited) {
+        logDebug("Process did not exit after SIGTERM, sending SIGKILL");
+        child.kill("SIGKILL");
+      }
+    }, 3e3);
+    killTimer.unref();
+  };
+  if (config.options?.abort?.aborted) {
+    cleanup();
+  } else {
+    config.options?.abort?.addEventListener("abort", cleanup);
+  }
+  process.on("exit", cleanup);
+  const processExitPromise = new Promise((resolve) => {
+    child.on("close", (code) => {
+      if (config.options?.abort?.aborted) {
+        query2.setError(new AbortError("Claude Code process aborted by user"));
+      }
+      if (code !== 0) {
+        const stderrOutput = stderrChunks.join("\n");
+        const errorMsg = stderrOutput ? `Claude Code process exited with code ${code}: ${stderrOutput}` : `Claude Code process exited with code ${code}`;
+        query2.setError(new Error(errorMsg));
+      } else {
+        resolve();
+      }
+    });
+  });
+  const query2 = new Query(childStdin, child.stdout, processExitPromise, canCallTool);
+  child.on("error", (error) => {
+    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();
+    config.options?.abort?.removeEventListener("abort", cleanup);
+    if (process.env.CLAUDE_SDK_MCP_SERVERS) {
+      delete process.env.CLAUDE_SDK_MCP_SERVERS;
+    }
+  });
+  return query2;
+}
+
+function mapToClaudeMode(mode) {
+  const codexToClaudeMap = {
+    "yolo": "bypassPermissions",
+    "safe-yolo": "default",
+    "read-only": "default"
+  };
+  return codexToClaudeMap[mode] ?? mode;
+}
+
+class PushableAsyncIterable {
+  queue = [];
+  waiters = [];
+  isDone = false;
+  error = null;
+  started = false;
+  constructor() {
+  }
+  /**
+   * Push a value to the iterable
+   */
+  push(value) {
+    if (this.isDone) {
+      throw new Error("Cannot push to completed iterable");
+    }
+    if (this.error) {
+      throw this.error;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  /**
+   * Mark the iterable as complete
+   */
+  end() {
+    if (this.isDone) {
+      return;
+    }
+    this.isDone = true;
+    this.cleanup();
+  }
+  /**
+   * Set an error on the iterable
+   */
+  setError(err) {
+    if (this.isDone) {
+      return;
+    }
+    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 });
+      }
+    }
+  }
+  /**
+   * AsyncIterableIterator implementation
+   */
+  async next() {
+    if (this.queue.length > 0) {
+      return { done: false, value: this.queue.shift() };
+    }
+    if (this.isDone) {
+      if (this.error) {
+        throw this.error;
+      }
+      return { done: true, value: void 0 };
+    }
+    return new Promise((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  /**
+   * AsyncIterableIterator return implementation
+   */
+  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 iterable is done
+   */
+  get done() {
+    return this.isDone;
+  }
+  /**
+   * Check if the iterable has an error
+   */
+  get hasError() {
+    return this.error !== null;
+  }
+  /**
+   * Get the current queue size
+   */
+  get queueSize() {
+    return this.queue.length;
+  }
+  /**
+   * Get the number of waiting consumers
+   */
+  get waiterCount() {
+    return this.waiters.length;
+  }
+}
+
+async function awaitFileExist(file, timeout = 1e4) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      await access(file);
+      return true;
+    } catch (e) {
+      await delay(1e3);
+    }
+  }
+  return false;
+}
+
+async function claudeRemote(opts) {
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
+  }
+  let forkSession = false;
+  if (opts.claudeArgs) {
+    if (opts.claudeArgs.includes("--fork-session")) {
+      forkSession = true;
+      logger.debug("[claudeRemote] Found --fork-session flag");
+    }
+    if (!startFrom) {
+      for (let i = 0; i < opts.claudeArgs.length; i++) {
+        if (opts.claudeArgs[i] === "--resume") {
+          if (i + 1 < opts.claudeArgs.length) {
+            const nextArg = opts.claudeArgs[i + 1];
+            if (!nextArg.startsWith("-") && nextArg.includes("-")) {
+              startFrom = nextArg;
+              logger.debug(`[claudeRemote] Found --resume with session ID: ${startFrom}`);
+              break;
+            } else {
+              logger.debug("[claudeRemote] Found --resume without session ID - not supported in remote mode");
+              break;
+            }
+          } else {
+            logger.debug("[claudeRemote] Found --resume without session ID - not supported in remote mode");
+            break;
+          }
+        }
+      }
+    }
+  }
+  if (opts.claudeEnvVars) {
+    Object.entries(opts.claudeEnvVars).forEach(([key, value]) => {
+      process.env[key] = value;
+    });
+  }
+  const initial = await opts.nextMessage();
+  if (!initial) {
+    return;
+  }
+  const initialText = typeof initial.message === "string" ? initial.message : initial.message.text;
+  const specialCommand = parseSpecialCommand(initialText);
+  if (specialCommand.type === "clear") {
+    if (opts.onCompletionEvent) {
+      opts.onCompletionEvent("Context was reset");
+    }
+    if (opts.onSessionReset) {
+      opts.onSessionReset();
+    }
+    if (opts.onThinkingChange) {
+      opts.onThinkingChange(false);
+    }
+    return;
+  }
+  let isCompactCommand = false;
+  if (specialCommand.type === "compact") {
+    logger.debug("[claudeRemote] /compact command detected - will process as normal but with compaction behavior");
+    isCompactCommand = true;
+    if (opts.onCompletionEvent) {
+      opts.onCompletionEvent("Compaction started");
+    }
+  }
+  let mode = initial.mode;
+  const sdkOptions = {
+    cwd: opts.path,
+    resume: startFrom ?? void 0,
+    forkSession: forkSession || void 0,
+    mcpServers: opts.mcpServers,
+    permissionMode: mapToClaudeMode(initial.mode.permissionMode),
+    model: initial.mode.model,
+    effort: initial.mode.reasoningEffort,
+    fallbackModel: initial.mode.fallbackModel,
+    customSystemPrompt: initial.mode.customSystemPrompt ? initial.mode.customSystemPrompt + "\n\n" + systemPrompt : void 0,
+    appendSystemPrompt: initial.mode.appendSystemPrompt ? initial.mode.appendSystemPrompt + "\n\n" + systemPrompt : systemPrompt,
+    allowedTools: initial.mode.allowedTools ? initial.mode.allowedTools.concat(opts.allowedTools) : opts.allowedTools,
+    disallowedTools: initial.mode.disallowedTools,
+    canCallTool: (toolName, input, options) => opts.canCallTool(toolName, input, mode, options),
+    executable: opts.jsRuntime ?? "node",
+    abort: opts.signal,
+    pathToClaudeCodeExecutable: (() => {
+      return resolve(join(projectPath(), "scripts", "claude_remote_launcher.cjs"));
+    })(),
+    settingsPath: opts.hookSettingsPath
+  };
+  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);
+      }
+    }
+  };
+  let messages = new PushableAsyncIterable();
+  const toClaudeMessageContent = async (message) => {
+    if (typeof message === "object" && "type" in message) {
+      if (message.type === "mixed") {
+        return formatMessageForClaude(message.text, message.images);
+      }
+      return message.text;
+    }
+    return message;
+  };
+  const initialMessageContent = await toClaudeMessageContent(initial.message);
+  messages.push({
+    type: "user",
+    message: {
+      role: "user",
+      content: initialMessageContent
+    }
+  });
+  let awaitingNextUserMessage = false;
+  let streamEnded = false;
+  const pumpNextUserMessage = async () => {
+    if (awaitingNextUserMessage || streamEnded) {
+      return;
+    }
+    awaitingNextUserMessage = true;
+    try {
+      const next = await opts.nextMessage();
+      if (!next) {
+        streamEnded = true;
+        messages.end();
+        return;
+      }
+      mode = next.mode;
+      const messageContent = await toClaudeMessageContent(next.message);
+      messages.push({
+        type: "user",
+        message: {
+          role: "user",
+          content: messageContent
+        }
+      });
+    } catch (error) {
+      logger.debug("[claudeRemote] Failed to fetch next user message", error);
+      streamEnded = true;
+      messages.end();
+    } finally {
+      awaitingNextUserMessage = false;
+    }
+  };
+  const response = query({
+    prompt: messages,
+    options: sdkOptions
+  });
+  opts.onQueryCreated?.(response);
+  updateThinking(true);
+  try {
+    logger.debug(`[claudeRemote] Starting to iterate over response`);
+    for await (const message of response) {
+      logger.debugLargeJson(`[claudeRemote] Message ${message.type}`, message);
+      opts.onMessage(message);
+      if (message.type === "system" && message.subtype === "init") {
+        updateThinking(true);
+        const systemInit = message;
+        if (systemInit.session_id) {
+          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, waiting for next user message");
+        if (isCompactCommand) {
+          logger.debug("[claudeRemote] Compaction completed");
+          if (opts.onCompletionEvent) {
+            opts.onCompletionEvent("Compaction completed");
+          }
+          isCompactCommand = false;
+        }
+        opts.onReady();
+        void pumpNextUserMessage();
+      }
+      if (message.type === "user") {
+        const msg = message;
+        if (msg.message.role === "user" && Array.isArray(msg.message.content)) {
+          for (let c of msg.message.content) {
+            if (c.type === "tool_result" && c.tool_use_id && opts.isAborted(c.tool_use_id)) {
+              logger.debug("[claudeRemote] Tool aborted, exiting claudeRemote");
+              return;
+            }
+          }
+        }
+      }
+    }
+  } catch (e) {
+    if (e instanceof AbortError) {
+      logger.debug(`[claudeRemote] Aborted`);
+    } else {
+      throw e;
+    }
+  } finally {
+    updateThinking(false);
+  }
+}
+
+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.`;
+
+const STANDARD_TOOLS = {
+  // File operations
+  "Read": "Read File",
+  "Write": "Write File",
+  "Edit": "Edit File",
+  "MultiEdit": "Edit File",
+  "NotebookEdit": "Edit Notebook",
+  // Search and navigation
+  "Glob": "Find Files",
+  "Grep": "Search in Files",
+  "LS": "List Directory",
+  // Command execution
+  "Bash": "Run Command",
+  "BashOutput": "Check Command Output",
+  "KillBash": "Stop Command",
+  // Task management
+  "TodoWrite": "Update Tasks",
+  "TodoRead": "Read Tasks",
+  "Task": "Launch Agent",
+  // Web tools
+  "WebFetch": "Fetch Web Page",
+  "WebSearch": "Search Web",
+  // Special cases
+  "exit_plan_mode": "Execute Plan",
+  "ExitPlanMode": "Execute Plan"
+};
+function toTitleCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function getToolName(toolName) {
+  if (STANDARD_TOOLS[toolName]) {
+    return STANDARD_TOOLS[toolName];
+  }
+  if (toolName.startsWith("mcp__") || toolName.startsWith("mcp:")) {
+    const parts = toolName.replace(/:/g, "__").split("__");
+    if (parts.length >= 3) {
+      const server = toTitleCase(parts[1]);
+      const action = toTitleCase(parts.slice(2).join("_"));
+      return `${server}: ${action}`;
+    }
+  }
+  return toTitleCase(toolName);
+}
+
+function getToolDescriptor(toolName) {
+  if (toolName === "exit_plan_mode" || toolName === "ExitPlanMode") {
+    return { edit: false, exitPlan: true };
+  }
+  if (toolName === "Edit" || toolName === "MultiEdit" || toolName === "Write" || toolName === "NotebookEdit") {
+    return { edit: true, exitPlan: false };
+  }
+  return { edit: false, exitPlan: false };
+}
+
+class PermissionHandler {
+  toolCalls = [];
+  responses = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  allowedTools = /* @__PURE__ */ new Set();
+  allowedBashLiterals = /* @__PURE__ */ new Set();
+  allowedBashPrefixes = /* @__PURE__ */ new Set();
+  permissionMode = "default";
+  lastNonPlanPermissionMode = "default";
+  onPermissionRequestCallback;
+  isUserInteractionTool(toolName) {
+    return ["AskUserQuestion", "ExitPlanMode", "exit_plan_mode"].includes(toolName);
+  }
+  constructor(session) {
+    this.session = session;
+    this.setupClientHandler();
+  }
+  /**
+   * Set callback to trigger when permission request is made
+   */
+  setOnPermissionRequest(callback) {
+    this.onPermissionRequestCallback = callback;
+  }
+  handleModeChange(mode) {
+    this.permissionMode = mode;
+    if (mode !== "plan") {
+      this.lastNonPlanPermissionMode = mode;
+    }
+  }
+  getResumeModeAfterPlan(responseMode) {
+    if (responseMode && responseMode !== "plan") {
+      return responseMode;
+    }
+    if (this.permissionMode !== "plan") {
+      return this.permissionMode;
+    }
+    return this.lastNonPlanPermissionMode;
+  }
+  /**
+   * Handler response
+   */
+  handlePermissionResponse(response, pending) {
+    if (response.allowTools && response.allowTools.length > 0) {
+      response.allowTools.forEach((tool) => {
+        if (tool.startsWith("Bash(") || tool === "Bash") {
+          this.parseBashPermission(tool);
+        } else {
+          this.allowedTools.add(tool);
+        }
+      });
+      this.persistAllowedTools(response.allowTools);
+    }
+    if (response.mode) {
+      this.permissionMode = response.mode;
+      if (response.mode !== "plan") {
+        this.lastNonPlanPermissionMode = response.mode;
+      }
+    }
+    if (response.approved && response.mode === "bypassPermissions") {
+      this.approvePendingNonInteractiveRequests(response);
+    }
+    if (pending.toolName === "exit_plan_mode" || pending.toolName === "ExitPlanMode") {
+      logger.debug("Plan mode result received", response);
+      if (response.approved) {
+        logger.debug("Plan approved - injecting PLAN_FAKE_RESTART");
+        const resumeMode = this.getResumeModeAfterPlan(response.mode);
+        this.session.queue.unshift(PLAN_FAKE_RESTART, { permissionMode: resumeMode });
+        pending.resolve({ behavior: "deny", message: PLAN_FAKE_REJECT });
+      } else {
+        pending.resolve({ behavior: "deny", message: response.reason || "Plan rejected" });
+      }
+    } else if (pending.toolName === "AskUserQuestion" && response.approved && response.answers) {
+      pending.resolve({ behavior: "deny", message: formatAskUserQuestionAnswers(response.answers) });
+    } else {
+      const updatedInput = pending.input || {};
+      const result = response.approved ? { behavior: "allow", updatedInput } : { 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.` };
+      pending.resolve(result);
+    }
+  }
+  /**
+   * Creates the canCallTool callback for the SDK
+   */
+  handleToolCall = async (toolName, input, mode, options) => {
+    if (toolName === "Bash") {
+      const inputObj = input;
+      if (inputObj?.command) {
+        if (this.allowedBashLiterals.has(inputObj.command)) {
+          return { behavior: "allow", updatedInput: input };
+        }
+        for (const prefix of this.allowedBashPrefixes) {
+          if (inputObj.command.startsWith(prefix)) {
+            return { behavior: "allow", updatedInput: input };
+          }
+        }
+      }
+    } else if (this.allowedTools.has(toolName)) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    const descriptor = getToolDescriptor(toolName);
+    const isUserInteractionTool = this.isUserInteractionTool(toolName);
+    if (this.permissionMode === "yolo" && !isUserInteractionTool) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    if (this.permissionMode === "bypassPermissions" && !isUserInteractionTool) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    if (this.permissionMode === "acceptEdits" && descriptor.edit) {
+      return { behavior: "allow", updatedInput: input };
+    }
+    let toolCallId = this.resolveToolCallId(toolName, input);
+    if (!toolCallId) {
+      await delay(1e3);
+      toolCallId = this.resolveToolCallId(toolName, input);
+      if (!toolCallId) {
+        throw new Error(`Could not resolve tool call ID for ${toolName}`);
+      }
+    }
+    return this.handlePermissionRequest(toolCallId, toolName, input, options.signal);
+  };
+  /**
+   * Handles individual permission requests
+   */
+  async handlePermissionRequest(id, toolName, input, signal) {
+    return new Promise((resolve, reject) => {
+      const abortHandler = () => {
+        this.pendingRequests.delete(id);
+        reject(new Error("Permission request aborted"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      this.pendingRequests.set(id, {
+        resolve: (result) => {
+          signal.removeEventListener("abort", abortHandler);
+          resolve(result);
+        },
+        reject: (error) => {
+          signal.removeEventListener("abort", abortHandler);
+          reject(error);
+        },
+        toolName,
+        input
+      });
+      if (this.onPermissionRequestCallback) {
+        this.onPermissionRequestCallback(id);
+      }
+      this.session.api.push().sendToAllDevices(
+        "Permission Request",
+        `Claude wants to ${getToolName(toolName)}`,
+        {
+          sessionId: this.session.client.sessionId,
+          requestId: id,
+          tool: toolName,
+          type: "permission_request"
+        }
+      );
+      this.session.client.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [id]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now()
+          }
+        }
+      }));
+      logger.debug(`Permission request sent for tool call ${id}: ${toolName}`);
+    });
+  }
+  approvePendingNonInteractiveRequests(response) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    const completedAt = Date.now();
+    for (const [id, pending] of pendingSnapshot) {
+      if (this.isUserInteractionTool(pending.toolName)) {
+        continue;
+      }
+      this.pendingRequests.delete(id);
+      const updatedInput = pending.input || {};
+      pending.resolve({ behavior: "allow", updatedInput });
+    }
+    if (pendingSnapshot.length === 0) {
+      return;
+    }
+    this.session.client.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests };
+      let changed = false;
+      for (const [id, pending] of pendingSnapshot) {
+        if (this.isUserInteractionTool(pending.toolName)) {
+          continue;
+        }
+        const request = requests[id];
+        if (!request) {
+          continue;
+        }
+        delete requests[id];
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "approved",
+          reason: response.reason,
+          mode: response.mode,
+          allowTools: response.allowTools
+        };
+        changed = true;
+      }
+      if (!changed) {
+        return currentState;
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+  }
+  /**
+   * Persists allowed tools to .claude/settings.local.json so they survive across sessions.
+   * This matches Claude Code CLI's native behavior for "Allow always".
+   */
+  async persistAllowedTools(tools) {
+    try {
+      const settingsDir = join(this.session.path, ".claude");
+      const settingsPath = join(settingsDir, "settings.local.json");
+      let settings = {};
+      try {
+        const content = await readFile(settingsPath, "utf-8");
+        settings = JSON.parse(content);
+      } catch {
+      }
+      if (!settings.permissions) {
+        settings.permissions = {};
+      }
+      if (!Array.isArray(settings.permissions.allow)) {
+        settings.permissions.allow = [];
+      }
+      let changed = false;
+      for (const tool of tools) {
+        if (!settings.permissions.allow.includes(tool)) {
+          settings.permissions.allow.push(tool);
+          changed = true;
+        }
+      }
+      if (changed) {
+        await mkdir(settingsDir, { recursive: true });
+        await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+        logger.debug(`Persisted allowed tools to ${settingsPath}: ${tools.join(", ")}`);
+      }
+    } catch (error) {
+      logger.debug(`Failed to persist allowed tools: ${error}`);
+    }
+  }
+  /**
+   * Parses Bash permission strings into literal and prefix sets
+   */
+  parseBashPermission(permission) {
+    if (permission === "Bash") {
+      return;
+    }
+    const bashPattern = /^Bash\((.+?)\)$/;
+    const match = permission.match(bashPattern);
+    if (!match) {
+      return;
+    }
+    const command = match[1];
+    if (command.endsWith(":*")) {
+      const prefix = command.slice(0, -2);
+      this.allowedBashPrefixes.add(prefix);
+    } else {
+      this.allowedBashLiterals.add(command);
+    }
+  }
+  /**
+   * Resolves tool call ID based on tool name and input
+   */
+  resolveToolCallId(name, args) {
+    for (let i = this.toolCalls.length - 1; i >= 0; i--) {
+      const call = this.toolCalls[i];
+      if (call.name === name && isDeepStrictEqual(call.input, args)) {
+        if (call.used) {
+          return null;
+        }
+        call.used = true;
+        return call.id;
+      }
+    }
+    return null;
+  }
+  /**
+   * Handles messages to track tool calls
+   */
+  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") {
+            this.toolCalls.push({
+              id: block.id,
+              name: block.name,
+              input: block.input,
+              used: false
+            });
+          }
+        }
+      }
+    }
+    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 = this.toolCalls.find((tc) => tc.id === block.tool_use_id);
+            if (toolCall && !toolCall.used) {
+              toolCall.used = true;
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Checks if a tool call is rejected
+   */
+  isAborted(toolCallId) {
+    if (this.responses.get(toolCallId)?.approved === false) {
+      return true;
+    }
+    const toolCall = this.toolCalls.find((tc) => tc.id === toolCallId);
+    if (toolCall && (toolCall.name === "exit_plan_mode" || toolCall.name === "ExitPlanMode")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Resets all state for new sessions
+   */
+  reset() {
+    this.toolCalls = [];
+    this.responses.clear();
+    this.allowedTools.clear();
+    this.allowedBashLiterals.clear();
+    this.allowedBashPrefixes.clear();
+    this.permissionMode = "default";
+    this.lastNonPlanPermissionMode = "default";
+    for (const [, pending] of this.pendingRequests.entries()) {
+      pending.reject(new Error("Session reset"));
+    }
+    this.pendingRequests.clear();
+    this.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"
+        };
+      }
+      return {
+        ...currentState,
+        requests: {},
+        // Clear all pending requests
+        completedRequests
+      };
+    });
+  }
+  /**
+   * Sets up the client handler for permission responses
+   */
+  setupClientHandler() {
+    this.session.client.rpcHandlerManager.registerHandler("permission", async (message) => {
+      logger.debug(`Permission response: ${JSON.stringify(message)}`);
+      const id = message.id;
+      const pending = this.pendingRequests.get(id);
+      if (!pending) {
+        logger.debug("Permission request not found or already resolved");
+        return;
+      }
+      this.responses.set(id, { ...message, receivedAt: Date.now() });
+      this.pendingRequests.delete(id);
+      this.handlePermissionResponse(message, pending);
+      this.session.client.updateAgentState((currentState) => {
+        const request = currentState.requests?.[id];
+        if (!request) return currentState;
+        let r = { ...currentState.requests };
+        delete r[id];
+        return {
+          ...currentState,
+          requests: r,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [id]: {
+              ...request,
+              completedAt: Date.now(),
+              status: message.approved ? "approved" : "denied",
+              reason: message.reason,
+              mode: message.mode,
+              allowTools: message.allowTools,
+              answers: message.answers
+            }
+          }
+        };
+      });
+    });
+  }
+  /**
+   * Gets the responses map (for compatibility with existing code)
+   */
+  getResponses() {
+    return this.responses;
+  }
+}
+function formatAskUserQuestionAnswers(answers) {
+  const lines = Object.entries(answers).map(([header, value]) => `- ${header}\uFF1A${value}`).join("\n");
+  return `\u6211\u7684\u9009\u62E9\u662F\uFF1A
+${lines}
+
+\u8BF7\u6839\u636E\u4EE5\u4E0A\u9009\u62E9\u7EE7\u7EED\u3002`;
+}
+
+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");
+      }
+      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") {
+          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");
+                }
+              }
+            }
+          }
+        } 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");
+              }
+            }
+          }
+        }
+      }
+      break;
+    }
+    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;
+    }
+    default: {
+      if (isDebug()) {
+        messageBuffer.addMessage(`[Unknown message type: ${message.type}]`, "status");
+      }
+    }
+  }
+}
+
+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)) {
+          const toolUseResult = sdkMessage.toolUseResult ?? sdkMessage.tool_use_result;
+          if (toolUseResult !== void 0) {
+            logMessage.toolUseResult = toolUseResult;
+          }
+          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;
+      }
+      case "assistant": {
+        const assistantMsg = sdkMessage;
+        logMessage = {
+          ...baseFields,
+          type: "assistant",
+          message: assistantMsg.message,
+          // Assistant messages often have additional fields
+          requestId: assistantMsg.requestId
+        };
+        break;
+      }
+      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;
+      }
+      case "result": {
+        break;
+      }
+      // 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;
+      }
+      default:
+        logMessage = {
+          ...baseFields,
+          ...sdkMessage,
+          type: sdkMessage.type
+          // Override type last to ensure it's set
+        };
+    }
+    if (logMessage && logMessage.type !== "summary") {
+      this.lastUuid = uuid;
+    }
+    return logMessage;
+  }
+  /**
+   * Convert multiple SDK messages to log format
+   */
+  convertMany(sdkMessages) {
+    return sdkMessages.map((msg) => this.convert(msg)).filter((msg) => msg !== null);
+  }
+  /**
+   * 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;
+  }
+}
+
+class OutgoingMessageQueue {
+  constructor(sendFunction) {
+    this.sendFunction = sendFunction;
+  }
+  queue = [];
+  nextId = 1;
+  lock = new AsyncLock();
+  processTimer;
+  delayTimers = /* @__PURE__ */ new Map();
+  /**
+   * Add message to queue
+   */
+  enqueue(logMessage, options) {
+    this.lock.inLock(async () => {
+      const item = {
+        id: this.nextId++,
+        logMessage,
+        delayed: !!options?.delay,
+        delayMs: options?.delay || 0,
+        toolCallIds: options?.toolCallIds,
+        released: !options?.delay,
+        // Not delayed = already released
+        sent: false
+      };
+      this.queue.push(item);
+      if (item.delayed) {
+        const timer = setTimeout(() => {
+          this.releaseItem(item.id);
+        }, item.delayMs);
+        this.delayTimers.set(item.id, timer);
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release specific item by ID
+   */
+  async releaseItem(itemId) {
+    await this.lock.inLock(async () => {
+      const item = this.queue.find((i) => i.id === itemId);
+      if (item && !item.released) {
+        item.released = true;
+        const timer = this.delayTimers.get(itemId);
+        if (timer) {
+          clearTimeout(timer);
+          this.delayTimers.delete(itemId);
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release all messages with specific tool call ID
+   */
+  async releaseToolCall(toolCallId) {
+    await this.lock.inLock(async () => {
+      for (const item of this.queue) {
+        if (item.toolCallIds?.includes(toolCallId) && !item.released) {
+          item.released = true;
+          const timer = this.delayTimers.get(item.id);
+          if (timer) {
+            clearTimeout(timer);
+            this.delayTimers.delete(item.id);
+          }
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Process queue - send messages in ID order that are released
+   * (Internal implementation without lock)
+   */
+  processQueueInternal() {
+    this.queue.sort((a, b) => a.id - b.id);
+    while (this.queue.length > 0) {
+      const item = this.queue[0];
+      if (!item.released) {
+        break;
+      }
+      if (!item.sent) {
+        if (item.logMessage.type !== "system") {
+          this.sendFunction(item.logMessage);
+        }
+        item.sent = true;
+      }
+      this.queue.shift();
+    }
+  }
+  /**
+   * Process queue - send messages in ID order that are released
+   */
+  async processQueue() {
+    await this.lock.inLock(async () => {
+      this.processQueueInternal();
+    });
+  }
+  /**
+   * Flush all messages immediately (for cleanup)
+   */
+  async flush() {
+    await this.lock.inLock(async () => {
+      for (const timer of this.delayTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.delayTimers.clear();
+      for (const item of this.queue) {
+        item.released = true;
+      }
+      this.processQueueInternal();
+    });
+  }
+  /**
+   * Schedule processing on next tick
+   */
+  scheduleProcessing() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    this.processTimer = setTimeout(() => {
+      this.processQueue();
+    }, 0);
+  }
+  /**
+   * Cleanup timers and resources
+   */
+  destroy() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    for (const timer of this.delayTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.delayTimers.clear();
+  }
+}
+
+async function claudeRemoteLauncher(session) {
+  logger.debug("[claudeRemoteLauncher] Starting remote launcher");
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
+  let messageBuffer = new MessageBuffer();
+  let inkInstance = null;
+  if (hasTTY) {
+    console.clear();
+    inkInstance = render(React.createElement(RemoteModeDisplay, {
+      messageBuffer,
+      logPath: isDebug() ? 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
+    });
+  }
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.setEncoding("utf8");
+  }
+  let exitReason = null;
+  let abortController = null;
+  let abortFuture = null;
+  let currentQuery = null;
+  async function abort() {
+    const query = currentQuery;
+    const controller = abortController;
+    const future = abortFuture;
+    if (controller?.signal.aborted) {
+      await future?.promise;
+      return;
+    }
+    if (query) {
+      try {
+        await Promise.race([
+          query.interrupt(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("interrupt timeout")), 3e3)
+          )
+        ]);
+        logger.debug("[remote]: interrupt() succeeded");
+      } catch (e) {
+        logger.debug("[remote]: interrupt() failed or timed out, falling back to SIGTERM", e);
+      }
+    }
+    if (controller && !controller.signal.aborted) {
+      controller.abort();
+    }
+    await future?.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.rpcHandlerManager.registerHandler("abort", doAbort);
+  session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+  const permissionHandler = new PermissionHandler(session);
+  const validPermissionModes = ["default", "acceptEdits", "bypassPermissions", "plan"];
+  session.client.rpcHandlerManager.registerHandler(
+    "permission-mode-changed",
+    async (payload) => {
+      const mode = payload?.mode;
+      if (!mode || !validPermissionModes.includes(mode)) {
+        logger.debug("[remote]: invalid permission mode via rpc", { mode });
+        return false;
+      }
+      permissionHandler.handleModeChange(mode);
+      logger.debug(`[remote]: permission mode updated via rpc to ${mode}`);
+      return true;
+    }
+  );
+  const messageQueue = new OutgoingMessageQueue(
+    (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
+  );
+  permissionHandler.setOnPermissionRequest((toolCallId) => {
+    messageQueue.releaseToolCall(toolCallId);
+  });
+  const sdkToLogConverter = new SDKToLogConverter({
+    sessionId: session.sessionId || "unknown",
+    cwd: session.path,
+    version: process.env.npm_package_version
+  }, permissionHandler.getResponses());
+  let currentSyncedModel;
+  let currentSyncedEffort;
+  function syncModelMetadata(mode) {
+    const model = mode.model;
+    const effort = mode.reasoningEffort;
+    if (model === currentSyncedModel && effort === currentSyncedEffort) return;
+    currentSyncedModel = model;
+    currentSyncedEffort = effort;
+    session.client.updateMetadata((m) => ({
+      ...m,
+      ...model ? { model } : {},
+      ...effort ? { reasoningEffort: effort } : {}
+    }));
+  }
+  let planModeToolCalls = /* @__PURE__ */ new Set();
+  let ongoingToolCalls = /* @__PURE__ */ new Map();
+  let hadAssistantMessage = false;
+  function onMessage(message) {
+    formatClaudeMessageForInk(message, messageBuffer);
+    if (message.type === "system" && message.subtype === "init") {
+      const initModel = message.model;
+      if (initModel && initModel !== currentSyncedModel) {
+        currentSyncedModel = initModel;
+        session.client.updateMetadata((m) => ({ ...m, model: initModel }));
+      }
+    }
+    if (message.type === "result") {
+      const resultMsg = message;
+      if (resultMsg.subtype === "error_during_execution") {
+        const errors = resultMsg.errors;
+        if (abortController?.signal.aborted) {
+          logger.debug("[remote]: suppressing error_during_execution caused by user abort", { errors });
+        } else if (errors && errors.length > 0) {
+          const errorText = errors.join("\n");
+          session.client.sendSessionEvent({ type: "message", message: `Error: ${errorText}` });
+          logger.debug("[remote]: sent error_during_execution as session event", { errorCount: errors.length });
+        } else {
+          session.client.sendSessionEvent({ type: "message", message: "An error occurred during execution" });
+        }
+      } else if (!hadAssistantMessage && typeof resultMsg.result === "string" && resultMsg.result.length > 0) {
+        session.client.sendSessionEvent({ type: "message", message: resultMsg.result });
+        logger.debug("[remote]: forwarded result text as session event (no assistant output this turn)");
+      }
+      return;
+    }
+    permissionHandler.onMessage(message);
+    if (message.type === "assistant") {
+      hadAssistantMessage = true;
+    }
+    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 (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 });
+          }
+        }
+      }
+    }
+    if (message.type === "user") {
+      let umessage = message;
+      const content = umessage.message.content;
+      if (typeof content === "string") {
+        hadAssistantMessage = false;
+      } else if (Array.isArray(content)) {
+        let hasToolResult = false;
+        let hasNonToolResult = false;
+        for (let c of content) {
+          if (c.type === "tool_result" && c.tool_use_id) {
+            hasToolResult = true;
+            ongoingToolCalls.delete(c.tool_use_id);
+            messageQueue.releaseToolCall(c.tool_use_id);
+          } else {
+            hasNonToolResult = true;
+          }
+        }
+        if (hasNonToolResult && !hasToolResult) {
+          hadAssistantMessage = false;
+        }
+      }
+    }
+    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;
+            })
+          }
+        };
+      }
+    }
+    const logMessage = sdkToLogConverter.convert(msg);
+    if (logMessage) {
+      if (logMessage.type === "user" && logMessage.message?.content) {
+        const content = Array.isArray(logMessage.message.content) ? logMessage.message.content : [];
+        for (let i = 0; i < content.length; i++) {
+          const c = content[i];
+          if (c.type === "tool_result" && c.tool_use_id) {
+            const responses = permissionHandler.getResponses();
+            const response = responses.get(c.tool_use_id);
+            if (response) {
+              const permissions = {
+                date: response.receivedAt || Date.now(),
+                result: response.approved ? "approved" : "denied"
+              };
+              if (response.mode) {
+                permissions.mode = response.mode;
+              }
+              if (response.allowTools && response.allowTools.length > 0) {
+                permissions.allowedTools = response.allowTools;
+              }
+              content[i] = {
+                ...c,
+                permissions
+              };
+            }
+          }
+        }
+      }
+      if (logMessage.type === "assistant" && message.type === "assistant") {
+        const assistantMsg = message;
+        const toolCallIds = [];
+        if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
+          for (const block of assistantMsg.message.content) {
+            if (block.type === "tool_use" && block.id) {
+              toolCallIds.push(block.id);
+            }
+          }
+        }
+        if (toolCallIds.length > 0) {
+          const isSidechain = assistantMsg.parent_tool_use_id !== void 0;
+          if (!isSidechain) {
+            messageQueue.enqueue(logMessage, {
+              delay: 250,
+              toolCallIds
+            });
+            return;
+          }
+        }
+      }
+      messageQueue.enqueue(logMessage);
+    }
+    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) {
+              messageQueue.enqueue(logMessage2);
+            }
+          }
+        }
+      }
+    }
+  }
+  try {
+    let pending = null;
+    let previousSessionId = null;
+    while (!exitReason) {
+      logger.debug("[remote]: launch");
+      messageBuffer.addMessage("\u2550".repeat(40), "status");
+      const isNewSession = session.sessionId !== previousSessionId;
+      if (isNewSession) {
+        messageBuffer.addMessage("Starting new Claude session...", "status");
+        permissionHandler.reset();
+        sdkToLogConverter.resetParentChain();
+        logger.debug(`[remote]: New session detected (previous: ${previousSessionId}, current: ${session.sessionId})`);
+      } else {
+        messageBuffer.addMessage("Continuing Claude session...", "status");
+        logger.debug(`[remote]: Continuing existing session: ${session.sessionId}`);
+      }
+      previousSessionId = session.sessionId;
+      const controller = new AbortController();
+      abortController = controller;
+      abortFuture = new Future();
+      let modeHash = null;
+      let mode = null;
+      try {
+        const remoteResult = await claudeRemote({
+          sessionId: session.sessionId,
+          path: session.path,
+          allowedTools: session.allowedTools ?? [],
+          mcpServers: session.mcpServers,
+          hookSettingsPath: session.hookSettingsPath,
+          jsRuntime: session.jsRuntime,
+          canCallTool: permissionHandler.handleToolCall,
+          isAborted: (toolCallId) => {
+            return permissionHandler.isAborted(toolCallId);
+          },
+          nextMessage: async () => {
+            if (pending) {
+              let p = pending;
+              pending = null;
+              permissionHandler.handleModeChange(p.mode.permissionMode);
+              syncModelMetadata(p.mode);
+              return p;
+            }
+            let msg = await session.queue.waitForMessagesAndGetAsString(controller.signal);
+            if (msg) {
+              if (modeHash && msg.hash !== modeHash || msg.isolate) {
+                logger.debug("[remote]: mode has changed, pending message");
+                pending = msg;
+                return null;
+              }
+              modeHash = msg.hash;
+              mode = msg.mode;
+              permissionHandler.handleModeChange(mode.permissionMode);
+              syncModelMetadata(mode);
+              return {
+                message: msg.message,
+                mode: msg.mode
+              };
+            }
+            return null;
+          },
+          onSessionFound: (sessionId) => {
+            sdkToLogConverter.updateSessionId(sessionId);
+            session.onSessionFound(sessionId);
+          },
+          onThinkingChange: session.onThinkingChange,
+          claudeEnvVars: session.claudeEnvVars,
+          claudeArgs: session.claudeArgs,
+          onMessage,
+          onCompletionEvent: (message) => {
+            logger.debug(`[remote]: Completion event: ${message}`);
+            session.client.sendSessionEvent({ type: "message", message });
+          },
+          onSessionReset: () => {
+            logger.debug("[remote]: Session reset");
+            session.clearSessionId();
+          },
+          onQueryCreated: (q) => {
+            currentQuery = q;
+          },
+          onReady: () => {
+            if (!pending && session.queue.size() === 0) {
+              session.client.sendSessionEvent({ type: "ready" });
+              session.api.push().sendToAllDevices(
+                "It's ready!",
+                `Claude is waiting for your command`,
+                { sessionId: session.client.sessionId }
+              );
+              session.client.flush().finally(() => {
+                session.client.updateAgentState((state) => ({
+                  ...state,
+                  taskCompleted: Date.now()
+                }));
+              });
+            }
+          },
+          signal: abortController.signal
+        });
+        session.consumeOneTimeFlags();
+        if (!exitReason && abortController.signal.aborted) {
+          session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
+        }
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        logger.debug("[remote]: launch error", e);
+        if (!exitReason) {
+          session.client.sendSessionEvent({ type: "message", message: `Process exited unexpectedly: ${errorMessage}` });
+          continue;
+        }
+      } finally {
+        logger.debug("[remote]: launch finally");
+        currentQuery = null;
+        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);
+          }
+        }
+        ongoingToolCalls.clear();
+        logger.debug("[remote]: flushing message queue");
+        await messageQueue.flush();
+        messageQueue.destroy();
+        logger.debug("[remote]: message queue flushed");
+        abortController = null;
+        abortFuture?.resolve(void 0);
+        abortFuture = null;
+        logger.debug("[remote]: launch done");
+        permissionHandler.reset();
+        modeHash = null;
+        mode = null;
+      }
+    }
+  } finally {
+    permissionHandler.reset();
+    process.stdin.off("data", abort);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    if (inkInstance) {
+      inkInstance.unmount();
+    }
+    messageBuffer.clear();
+    session.queue.setOnMessage(null);
+    if (abortFuture) {
+      abortFuture.resolve(void 0);
+    }
+  }
+  return exitReason || "exit";
+}
+
+async function loop(opts) {
+  const logPath = logger.logFilePath;
+  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,
+    allowedTools: opts.allowedTools,
+    onModeChange: opts.onModeChange,
+    hookSettingsPath: opts.hookSettingsPath,
+    jsRuntime: opts.jsRuntime
+  });
+  opts.onSessionReady?.(session);
+  let mode = opts.startingMode ?? "local";
+  while (true) {
+    logger.debug(`[loop] Iteration with mode: ${mode}`);
+    switch (mode) {
+      case "local": {
+        const result = await claudeLocalLauncher(session);
+        switch (result.type) {
+          case "switch":
+            mode = "remote";
+            opts.onModeChange?.(mode);
+            break;
+          case "exit":
+            return result.code;
+        }
+        break;
+      }
+      case "remote": {
+        const reason = await claudeRemoteLauncher(session);
+        switch (reason) {
+          case "exit":
+            return 0;
+          case "switch":
+            mode = "local";
+            opts.onModeChange?.(mode);
+            break;
+        }
+        break;
+      }
+    }
+  }
+}
+
+async function extractSDKMetadata() {
+  const abortController = new AbortController();
+  try {
+    logger.debug("[metadataExtractor] Starting SDK metadata extraction");
+    const sdkQuery = query({
+      prompt: "hello",
+      options: {
+        allowedTools: ["Bash(echo)"],
+        maxTurns: 1,
+        abort: abortController.signal
+      }
+    });
+    for await (const message of sdkQuery) {
+      if (message.type === "system" && message.subtype === "init") {
+        const systemMessage = message;
+        const metadata = {
+          tools: systemMessage.tools,
+          slashCommands: systemMessage.slash_commands
+        };
+        logger.debug("[metadataExtractor] Captured SDK metadata:", metadata);
+        abortController.abort();
+        return metadata;
+      }
+    }
+    logger.debug("[metadataExtractor] No init message received from SDK");
+    return {};
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      logger.debug("[metadataExtractor] SDK query aborted after capturing metadata");
+      return {};
+    }
+    logger.debug("[metadataExtractor] Error extracting SDK metadata:", error);
+    return {};
+  }
+}
+function extractSDKMetadataAsync(onComplete) {
+  extractSDKMetadata().then((metadata) => {
+    if (metadata.tools || metadata.slashCommands) {
+      onComplete(metadata);
+    }
+  }).catch((error) => {
+    logger.debug("[metadataExtractor] Async extraction failed:", error);
+  });
+}
+
+async function startHookServer(options) {
+  const { onSessionHook } = options;
+  return new Promise((resolve, reject) => {
+    const server = createServer(async (req, res) => {
+      if (req.method === "POST" && req.url === "/hook/session-start") {
+        const timeout = setTimeout(() => {
+          if (!res.headersSent) {
+            logger.debug("[hookServer] Request timeout");
+            res.writeHead(408).end("timeout");
+          }
+        }, 5e3);
+        try {
+          const chunks = [];
+          for await (const chunk of req) {
+            chunks.push(chunk);
+          }
+          clearTimeout(timeout);
+          const body = Buffer.concat(chunks).toString("utf-8");
+          logger.debug("[hookServer] Received session hook:", body);
+          let data = {};
+          try {
+            data = JSON.parse(body);
+          } catch (parseError) {
+            logger.debug("[hookServer] Failed to parse hook data as JSON:", parseError);
+          }
+          const sessionId = data.session_id || data.sessionId;
+          if (sessionId) {
+            logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
+            onSessionHook(sessionId, data);
+          } else {
+            logger.debug("[hookServer] Session hook received but no session_id found in data");
+          }
+          res.writeHead(200, { "Content-Type": "text/plain" }).end("ok");
+        } catch (error) {
+          clearTimeout(timeout);
+          logger.debug("[hookServer] Error handling session hook:", error);
+          if (!res.headersSent) {
+            res.writeHead(500).end("error");
+          }
+        }
+        return;
+      }
+      res.writeHead(404).end("not found");
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = address.port;
+      logger.debug(`[hookServer] Started on port ${port}`);
+      resolve({
+        port,
+        stop: () => {
+          server.close();
+          logger.debug("[hookServer] Stopped");
+        }
+      });
+    });
+    server.on("error", (err) => {
+      logger.debug("[hookServer] Server error:", err);
+      reject(err);
+    });
+  });
+}
+
+const INTERNAL_CLAUDE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation"
+]);
+function messageKey(message) {
+  if (message.type === "user") {
+    return message.uuid;
+  }
+  if (message.type === "assistant") {
+    return message.uuid;
+  }
+  if (message.type === "summary") {
+    return `summary:${message.leafUuid}`;
+  }
+  if (message.type === "system") {
+    return message.uuid;
+  }
+  if (message.type === "progress") {
+    return message.uuid;
+  }
+  return `unknown:${Math.random()}`;
+}
+function isPrimaryUserMessage(message) {
+  if (message.type !== "user") return false;
+  if (message.isSidechain) return false;
+  if (message.isMeta) return false;
+  const content = message.message?.content;
+  if (Array.isArray(content)) return false;
+  if (typeof content === "string") {
+    const text = content.trim();
+    if (text.startsWith("<task-notification>") && text.includes("</task-notification>")) {
+      return false;
+    }
+  }
+  return true;
+}
+async function readSessionLog(projectDir, sessionId) {
+  const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
+  logger.debug(`[BACKFILL] Reading session file: ${expectedSessionFile}`);
+  let file;
+  try {
+    file = await readFile(expectedSessionFile, "utf-8");
+  } catch (error) {
+    logger.debug(`[BACKFILL] Session file not found: ${expectedSessionFile}`);
+    return [];
+  }
+  const lines = file.split("\n");
+  const messages = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const parsedLine = JSON.parse(line);
+      if (parsedLine?.type && INTERNAL_CLAUDE_EVENT_TYPES.has(parsedLine.type)) {
+        continue;
+      }
+      const parsed = RawJSONLinesSchema.safeParse(parsedLine);
+      if (!parsed.success) {
+        continue;
+      }
+      messages.push(parsed.data);
+    } catch (error) {
+      logger.debug("[BACKFILL] Failed to parse session line", { error });
+    }
+  }
+  return messages;
+}
+async function backfillClaudeSessionHistory(opts) {
+  const maxMessages = opts.maxMessages ?? 200;
+  const maxUserMessages = opts.maxUserMessages ?? 20;
+  const maxBytes = opts.maxBytes ?? Number.POSITIVE_INFINITY;
+  const projectDir = getProjectPath(opts.workingDirectory);
+  let messages = await readSessionLog(projectDir, opts.sessionId);
+  if (!messages.length) {
+    const rawProjectId = opts.workingDirectory.replace(/[\\\/\.: _]/g, "-");
+    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+    const rawProjectDir = join(claudeConfigDir, "projects", rawProjectId);
+    if (rawProjectDir !== projectDir) {
+      messages = await readSessionLog(rawProjectDir, opts.sessionId);
+    }
+  }
+  if (!messages.length) {
+    logger.debug("[BACKFILL] No messages to backfill");
+    return;
+  }
+  const selected = [];
+  let totalCount = 0;
+  let userCount = 0;
+  let totalBytes = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.type === "summary") {
+      continue;
+    }
+    const estimatedBytes = Buffer.byteLength(JSON.stringify(message), "utf8");
+    if (totalBytes + estimatedBytes > maxBytes) {
+      if (selected.length === 0) {
+        selected.push(message);
+        totalBytes += estimatedBytes;
+      }
+      break;
+    }
+    selected.push(message);
+    totalBytes += estimatedBytes;
+    if (message.type === "progress") {
+      continue;
+    }
+    totalCount += 1;
+    const isPrimaryUser = isPrimaryUserMessage(message);
+    if (isPrimaryUser) {
+      userCount += 1;
+    }
+    if (userCount >= maxUserMessages) {
+      break;
+    }
+    if (totalCount >= maxMessages && isPrimaryUser) {
+      break;
+    }
+  }
+  selected.reverse();
+  logger.debug(`[BACKFILL] Backfilling ${selected.length} messages (users: ${userCount}, total: ${totalCount}, bytes: ${totalBytes})`);
+  const batch = selected.map((message) => ({
+    message,
+    localId: `claude-log:${opts.sessionId}:${messageKey(message)}`
+  }));
+  if (opts.sendBatch) {
+    await opts.sendBatch(batch);
+    return;
+  }
+  if (opts.send) {
+    for (const item of batch) {
+      opts.send(item.message, item.localId);
+    }
+  }
+}
+
+function generateHookSettingsFile(port) {
+  const hooksDir = join(configuration.happyHomeDir, "tmp", "hooks");
+  mkdirSync(hooksDir, { recursive: true });
+  const filename = `session-hook-${process.pid}.json`;
+  const filepath = join(hooksDir, filename);
+  const forwarderScript = resolve(projectPath(), "scripts", "session_hook_forwarder.cjs");
+  const hookCommand = `node "${forwarderScript}" ${port}`;
+  const settings = {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "*",
+          hooks: [
+            {
+              type: "command",
+              command: hookCommand
+            }
+          ]
+        }
+      ]
+    }
+  };
+  writeFileSync(filepath, JSON.stringify(settings, null, 2));
+  logger.debug(`[generateHookSettings] Created hook settings file: ${filepath}`);
+  return filepath;
+}
+function cleanupHookSettingsFile(filepath) {
+  try {
+    if (existsSync(filepath)) {
+      unlinkSync(filepath);
+      logger.debug(`[generateHookSettings] Cleaned up hook settings file: ${filepath}`);
+    }
+  } catch (error) {
+    logger.debug(`[generateHookSettings] Failed to cleanup hook settings file: ${error}`);
+  }
+}
+
+function detectWorktreeMetadata(cwd) {
+  if (process.env.HAPPY_WORKSPACE_REPOS) {
+    try {
+      const repos = JSON.parse(process.env.HAPPY_WORKSPACE_REPOS);
+      return {
+        isWorktree: true,
+        workspaceRepos: repos,
+        workspacePath: process.env.HAPPY_WORKSPACE_PATH
+      };
+    } catch {
+    }
+  }
+  if (process.env.HAPPY_WORKTREE_BASE_PATH) {
+    return {
+      isWorktree: true,
+      worktreeBasePath: process.env.HAPPY_WORKTREE_BASE_PATH,
+      worktreeBranchName: process.env.HAPPY_WORKTREE_BRANCH_NAME
+    };
+  }
+  const info = detectGitWorktree(cwd);
+  if (info.isWorktree) {
+    return {
+      isWorktree: true,
+      worktreeBasePath: info.worktreeBasePath,
+      worktreeBranchName: info.worktreeBranchName
+    };
+  }
+  try {
+    const entries = readdirSync(cwd, { withFileTypes: true });
+    const repos = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const subDir = join(cwd, entry.name);
+      const sub = detectGitWorktree(subDir);
+      if (sub.isWorktree && sub.worktreeBasePath && sub.worktreeBranchName) {
+        repos.push({
+          path: subDir,
+          basePath: sub.worktreeBasePath,
+          branchName: sub.worktreeBranchName,
+          displayName: entry.name
+        });
+      }
+    }
+    if (repos.length > 0) {
+      return {
+        isWorktree: true,
+        workspaceRepos: repos,
+        workspacePath: cwd
+      };
+    }
+  } catch {
+  }
+  return {};
+}
+async function runClaude(credentials, options = {}) {
+  logger.debug(`[CLAUDE] ===== CLAUDE MODE STARTING =====`);
+  logger.debug(`[CLAUDE] This is the Claude agent, NOT Gemini`);
+  const workingDirectory = process.cwd();
+  const sessionTag = randomUUID();
+  logger.debugLargeJson("[START] Happy process started", getEnvironmentInfo());
+  logger.debug(`[START] Options: startedBy=${options.startedBy}, startingMode=${options.startingMode}`);
+  if (options.startedBy === "daemon" && options.startingMode === "local") {
+    throw new Error("Daemon-spawned sessions cannot use local/interactive mode. Use --happy-starting-mode remote or spawn sessions directly from terminal.");
+  }
+  connectionState.setBackend("Claude");
+  const api = await ApiClient.create(credentials);
+  let state = {};
+  const settings = await readSettings();
+  let machineId = settings?.machineId;
+  if (!machineId) {
+    console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/ZonEaseTech/happy-wfs/issues`);
+    process.exit(1);
+  }
+  logger.debug(`Using machineId: ${machineId}`);
+  await api.getOrCreateMachine({
+    machineId,
+    metadata: initialMachineMetadata
+  });
+  let metadata = {
+    path: workingDirectory,
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.happyHomeDir,
+    happyLibDir: projectPath(),
+    happyToolsDir: resolveToolsDir(),
+    startedFromDaemon: options.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: options.startedBy || "terminal",
+    // Initialize lifecycle state
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: "claude",
+    // Worktree metadata: env vars from daemon take priority, otherwise detect via git
+    ...detectWorktreeMetadata(workingDirectory)
+  };
+  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  if (!response) {
+    let offlineSessionId = null;
+    const reconnection = startOfflineReconnection({
+      serverUrl: configuration.serverUrl,
+      onReconnected: async () => {
+        const resp = await api.getOrCreateSession({ tag: randomUUID(), metadata, state });
+        if (!resp) throw new Error("Server unavailable");
+        const session2 = api.sessionSyncClient(resp);
+        const scanner = await createSessionScanner({
+          sessionId: null,
+          workingDirectory,
+          onMessage: (msg) => session2.sendClaudeSessionMessage(msg)
+        });
+        if (offlineSessionId) scanner.onNewSession(offlineSessionId);
+        return { session: session2, scanner };
+      },
+      onNotify: console.log,
+      onCleanup: () => {
+      }
+    });
+    try {
+      await claudeLocal({
+        path: workingDirectory,
+        sessionId: null,
+        onSessionFound: (id) => {
+          offlineSessionId = id;
+        },
+        onThinkingChange: () => {
+        },
+        abort: new AbortController().signal,
+        claudeEnvVars: options.claudeEnvVars,
+        claudeArgs: options.claudeArgs,
+        mcpServers: {},
+        allowedTools: []
+      });
+    } finally {
+      reconnection.cancel();
+      stopCaffeinate();
+    }
+    process.exit(0);
+  }
+  logger.debug(`Session created: ${response.id}`);
+  try {
+    logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await notifyDaemonSessionStarted(response.id, metadata);
+    if (result.error) {
+      logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+    } else {
+      logger.debug(`[START] Reported session ${response.id} to daemon`);
+    }
+  } catch (error) {
+    logger.debug("[START] Failed to report to daemon (may not be running):", error);
+  }
+  extractSDKMetadataAsync(async (sdkMetadata) => {
+    logger.debug("[start] SDK metadata extracted, updating session:", sdkMetadata);
+    try {
+      api.sessionSyncClient(response).updateMetadata((currentMetadata) => ({
+        ...currentMetadata,
+        tools: sdkMetadata.tools,
+        slashCommands: sdkMetadata.slashCommands
+      }));
+      logger.debug("[start] Session metadata updated with SDK capabilities");
+    } catch (error) {
+      logger.debug("[start] Failed to update session metadata:", error);
+    }
+  });
+  const session = api.sessionSyncClient(response);
+  const sessionTitle = process.env.HAPPY_SESSION_TITLE?.trim();
+  const initialClaudeSessionId = process.env.HAPPY_CLAUDE_RESUME_SESSION_ID?.trim();
+  const skipForkSession = process.env.HAPPY_CLAUDE_SKIP_FORK_SESSION === "1";
+  if (sessionTitle || initialClaudeSessionId && skipForkSession) {
+    session.updateMetadata((currentMetadata) => ({
+      ...currentMetadata,
+      ...sessionTitle && {
+        summary: {
+          text: sessionTitle,
+          updatedAt: Date.now()
+        }
+      },
+      ...initialClaudeSessionId && skipForkSession && {
+        claudeSessionId: initialClaudeSessionId
+      }
+    }));
+  }
+  const injectedMemories = await api.listMemories();
+  let initialMemoryAppendPrompt;
+  if (injectedMemories.length > 0) {
+    const memoryBlock = "<user_memory>\n" + injectedMemories.map((m) => m.content).join("\n\n") + "\n</user_memory>";
+    initialMemoryAppendPrompt = memoryBlock;
+    const injectedMemoryIds = injectedMemories.map((m) => m.id);
+    session.updateMetadata((currentMetadata) => ({
+      ...currentMetadata,
+      injectedMemoryIds
+    }));
+    logger.debug(`[START] Injected ${injectedMemoryIds.length} memories into session`);
+  }
+  const mcp = await createMcpContext(session);
+  logger.debug(`[START] MCP context created`);
+  let currentSession = null;
+  const shouldBackfill = ["1", "true", "yes"].includes(String(process.env.HAPPY_CLAUDE_BACKFILL).toLowerCase());
+  const backfillMaxMessages = Number(process.env.HAPPY_CLAUDE_BACKFILL_MAX_MESSAGES) || 200;
+  const backfillMaxUserMessages = Number(process.env.HAPPY_CLAUDE_BACKFILL_MAX_USER_MESSAGES) || 20;
+  const backfillMaxBytes = Number(process.env.HAPPY_CLAUDE_BACKFILL_MAX_BYTES) || 3 * 1024 * 1024;
+  const resumeSessionId = process.env.HAPPY_CLAUDE_RESUME_SESSION_ID || void 0;
+  const backfilledSessions = /* @__PURE__ */ new Set();
+  const backfillInFlight = /* @__PURE__ */ new Set();
+  const ensureResumeSessionFileAvailable = async (sessionId) => {
+    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(os.homedir(), ".claude");
+    const resolvedProjectDir = getProjectPath(workingDirectory);
+    const rawProjectId = workingDirectory.replace(/[\\\/\.: _]/g, "-");
+    const rawProjectDir = join(claudeConfigDir, "projects", rawProjectId);
+    const targetDirs = /* @__PURE__ */ new Set([resolvedProjectDir, rawProjectDir]);
+    const sourceProjectId = await findClaudeProjectId(sessionId);
+    if (!sourceProjectId) {
+      logger.debug(`[START] Resume session file not found in any Claude project: ${sessionId}`);
+      return;
+    }
+    const sourcePath = join(claudeConfigDir, "projects", sourceProjectId, `${sessionId}.jsonl`);
+    logger.debug(`[START] Resume session file source: ${sourcePath}`);
+    for (const targetDir of targetDirs) {
+      const targetPath = join(targetDir, `${sessionId}.jsonl`);
+      if (targetPath === sourcePath) {
+        logger.debug(`[START] Resume session file already present (source): ${targetPath}`);
+        continue;
+      }
+      try {
+        await stat(targetPath);
+        logger.debug(`[START] Resume session file already present: ${targetPath}`);
+        continue;
+      } catch {
+      }
+      try {
+        await mkdir(targetDir, { recursive: true });
+        await copyFile(sourcePath, targetPath);
+        logger.debug(`[START] Copied resume session file into project dir: ${targetPath}`);
+      } catch (error) {
+        logger.debug("[START] Resume session copy error details", { targetPath, error });
+      }
+    }
+  };
+  const runBackfill = async (sessionId) => {
+    if (!shouldBackfill) return;
+    if (backfilledSessions.has(sessionId)) return;
+    if (backfillInFlight.has(sessionId)) return;
+    backfillInFlight.add(sessionId);
+    for (let i = 0; i < 15 && !session.isConnected(); i++) {
+      await new Promise((resolve2) => setTimeout(resolve2, 200));
+    }
+    if (!session.isConnected()) {
+      logger.debug("[START] Backfill skipped: session socket not connected");
+      backfillInFlight.delete(sessionId);
+      return;
+    }
+    try {
+      await backfillClaudeSessionHistory({
+        workingDirectory,
+        sessionId,
+        sendBatch: async (messages) => {
+          await session.sendClaudeSessionMessageBatch(messages, "replace");
+        },
+        maxMessages: backfillMaxMessages,
+        maxUserMessages: backfillMaxUserMessages,
+        maxBytes: backfillMaxBytes
+      });
+      backfilledSessions.add(sessionId);
+    } finally {
+      backfillInFlight.delete(sessionId);
+    }
+  };
+  if (resumeSessionId) {
+    await ensureResumeSessionFileAvailable(resumeSessionId);
+    runBackfill(resumeSessionId).catch((error) => {
+      logger.debug("[START] Backfill failed:", error);
+    });
+  }
+  const hookServer = await startHookServer({
+    onSessionHook: (sessionId, data) => {
+      logger.debug(`[START] Session hook received: ${sessionId}`, data);
+      if (currentSession) {
+        const previousSessionId = currentSession.sessionId;
+        if (previousSessionId !== sessionId) {
+          logger.debug(`[START] Claude session ID changed: ${previousSessionId} -> ${sessionId}`);
+          currentSession.onSessionFound(sessionId);
+        }
+      }
+      runBackfill(sessionId).catch((error) => {
+        logger.debug("[START] Backfill failed:", error);
+      });
+    }
+  });
+  logger.debug(`[START] Hook server started on port ${hookServer.port}`);
+  const hookSettingsPath = generateHookSettingsFile(hookServer.port);
+  logger.debug(`[START] Generated hook settings file: ${hookSettingsPath}`);
+  const logPath = logger.logFilePath;
+  logger.infoDeveloper(`Session: ${response.id}`);
+  logger.infoDeveloper(`Logs: ${logPath}`);
+  session.updateAgentState((currentState) => ({
+    ...currentState,
+    controlledByUser: options.startingMode !== "remote"
+  }));
+  const caffeinateStarted = startCaffeinate();
+  if (caffeinateStarted) {
+    logger.infoDeveloper("Sleep prevention enabled (macOS)");
+  }
+  const messageQueue = new MessageQueue2((mode) => hashObject({
+    isPlan: mode.permissionMode === "plan",
+    model: mode.model,
+    reasoningEffort: mode.reasoningEffort,
+    fallbackModel: mode.fallbackModel,
+    customSystemPrompt: mode.customSystemPrompt,
+    appendSystemPrompt: mode.appendSystemPrompt,
+    allowedTools: mode.allowedTools,
+    disallowedTools: mode.disallowedTools
+  }));
+  let currentPermissionMode = options.permissionMode;
+  let currentModel = options.model;
+  let currentReasoningEffort = void 0;
+  let currentFallbackModel = void 0;
+  let currentCustomSystemPrompt = void 0;
+  let currentAppendSystemPrompt = initialMemoryAppendPrompt;
+  let currentAllowedTools = void 0;
+  let currentDisallowedTools = void 0;
+  session.onUserMessage((message) => {
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      messagePermissionMode = message.meta.permissionMode;
+      currentPermissionMode = messagePermissionMode;
+      logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
+    } else {
+      logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
+    }
+    let messageModel = currentModel;
+    if (message.meta?.hasOwnProperty("model")) {
+      messageModel = message.meta.model || void 0;
+      currentModel = messageModel;
+      logger.debug(`[loop] Model updated from user message: ${messageModel || "reset to default"}`);
+    } else {
+      logger.debug(`[loop] User message received with no model override, using current: ${currentModel || "default"}`);
+    }
+    let messageReasoningEffort = currentReasoningEffort;
+    if (message.meta?.hasOwnProperty("reasoningEffort")) {
+      messageReasoningEffort = message.meta.reasoningEffort || void 0;
+      currentReasoningEffort = messageReasoningEffort;
+      logger.debug(`[loop] Reasoning effort updated from user message: ${messageReasoningEffort || "reset to default"}`);
+    } else {
+      logger.debug(`[loop] User message received with no reasoning effort override, using current: ${currentReasoningEffort || "default"}`);
+    }
+    let messageCustomSystemPrompt = currentCustomSystemPrompt;
+    if (message.meta?.hasOwnProperty("customSystemPrompt")) {
+      messageCustomSystemPrompt = message.meta.customSystemPrompt || void 0;
+      currentCustomSystemPrompt = messageCustomSystemPrompt;
+      logger.debug(`[loop] Custom system prompt updated from user message: ${messageCustomSystemPrompt ? "set" : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no custom system prompt override, using current: ${currentCustomSystemPrompt ? "set" : "none"}`);
+    }
+    let messageFallbackModel = currentFallbackModel;
+    if (message.meta?.hasOwnProperty("fallbackModel")) {
+      messageFallbackModel = message.meta.fallbackModel || void 0;
+      currentFallbackModel = messageFallbackModel;
+      logger.debug(`[loop] Fallback model updated from user message: ${messageFallbackModel || "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no fallback model override, using current: ${currentFallbackModel || "none"}`);
+    }
+    let messageAppendSystemPrompt = currentAppendSystemPrompt;
+    if (message.meta?.hasOwnProperty("appendSystemPrompt")) {
+      messageAppendSystemPrompt = message.meta.appendSystemPrompt || void 0;
+      currentAppendSystemPrompt = messageAppendSystemPrompt;
+      logger.debug(`[loop] Append system prompt updated from user message: ${messageAppendSystemPrompt ? "set" : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no append system prompt override, using current: ${currentAppendSystemPrompt ? "set" : "none"}`);
+    }
+    let messageAllowedTools = currentAllowedTools;
+    if (message.meta?.hasOwnProperty("allowedTools")) {
+      messageAllowedTools = message.meta.allowedTools || void 0;
+      currentAllowedTools = messageAllowedTools;
+      logger.debug(`[loop] Allowed tools updated from user message: ${messageAllowedTools ? messageAllowedTools.join(", ") : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no allowed tools override, using current: ${currentAllowedTools ? currentAllowedTools.join(", ") : "none"}`);
+    }
+    let messageDisallowedTools = currentDisallowedTools;
+    if (message.meta?.hasOwnProperty("disallowedTools")) {
+      messageDisallowedTools = message.meta.disallowedTools || void 0;
+      currentDisallowedTools = messageDisallowedTools;
+      logger.debug(`[loop] Disallowed tools updated from user message: ${messageDisallowedTools ? messageDisallowedTools.join(", ") : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no disallowed tools override, using current: ${currentDisallowedTools ? currentDisallowedTools.join(", ") : "none"}`);
+    }
+    const specialCommand = parseSpecialCommand(message.content.text);
+    const enhancedMode = {
+      permissionMode: messagePermissionMode || "default",
+      model: messageModel,
+      reasoningEffort: messageReasoningEffort,
+      fallbackModel: messageFallbackModel,
+      customSystemPrompt: messageCustomSystemPrompt,
+      appendSystemPrompt: messageAppendSystemPrompt,
+      allowedTools: messageAllowedTools,
+      disallowedTools: messageDisallowedTools
+    };
+    if (specialCommand.type === "compact") {
+      logger.debug("[start] Detected /compact command");
+      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode);
+      logger.debugLargeJson("[start] /compact command pushed to queue:", message);
+      return;
+    }
+    if (specialCommand.type === "clear") {
+      logger.debug("[start] Detected /clear command");
+      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode);
+      logger.debugLargeJson("[start] /clear command pushed to queue:", message);
+      return;
+    }
+    if (message.content.type === "mixed") {
+      messageQueue.push(message.content, enhancedMode);
+    } else {
+      messageQueue.push(message.content.text, enhancedMode);
+    }
+    logger.debugLargeJson("User message pushed to queue:", message);
+  });
+  const cleanup = async () => {
+    logger.debug("[START] Received termination signal, cleaning up...");
+    try {
+      if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
+        currentSession?.cleanup();
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      stopCaffeinate();
+      mcp.stop();
+      hookServer.stop();
+      cleanupHookSettingsFile(hookSettingsPath);
+      logger.debug("[START] Cleanup complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      logger.debug("[START] Error during cleanup:", error);
+      process.exit(1);
+    }
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("uncaughtException", (error) => {
+    logger.debug("[START] Uncaught exception:", error);
+    cleanup();
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger.debug("[START] Unhandled rejection:", reason);
+    cleanup();
+  });
+  registerKillSessionHandler(session.rpcHandlerManager, cleanup);
+  const exitCode = await loop({
+    path: workingDirectory,
+    model: options.model,
+    permissionMode: options.permissionMode,
+    startingMode: options.startingMode,
+    messageQueue,
+    api,
+    allowedTools: mcp.allowedToolNames(),
+    onModeChange: (newMode) => {
+      session.sendSessionEvent({ type: "switch", mode: newMode });
+      session.updateAgentState((currentState) => ({
+        ...currentState,
+        controlledByUser: newMode === "local"
+      }));
+    },
+    onSessionReady: (sessionInstance) => {
+      currentSession = sessionInstance;
+    },
+    mcpServers: mcp.configForClaude(),
+    session,
+    claudeEnvVars: options.claudeEnvVars,
+    claudeArgs: options.claudeArgs,
+    hookSettingsPath,
+    jsRuntime: options.jsRuntime
+  });
+  currentSession?.cleanup();
+  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");
+  mcp.stop();
+  logger.debug("Stopped Happy MCP server");
+  hookServer.stop();
+  cleanupHookSettingsFile(hookSettingsPath);
+  logger.debug("Stopped Hook server and cleaned up settings file");
+  process.exit(exitCode);
+}
+
+export { runClaude };