happy-imou-cloud 2.0.13 → 2.0.16

package/dist/{runClaude-D7dF4RDM.mjs → runClaude-kRPXCaBj.mjs}

@@ -1,8 +1,8 @@
 import { randomUUID } from 'node:crypto';
-import { l as logger, d as backoff, f as delay, g as AsyncLock, c as configuration, s as startOfflineReconnection, b as connectionState, A as ApiClient, i as isAuthenticationRequiredError } from './api-D1meoL-9.mjs';
+import { l as logger, d as backoff, f as delay, g as AsyncLock, c as configuration, s as startOfflineReconnection, b as connectionState, A as ApiClient, i as isAuthenticationRequiredError } from './api-sRF6xXi-.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
-import { j as getProjectPath, k as claudeLocal, E as ExitCodeError, l as isBun, m as trimIdent, n as claudeCheckSession, p as projectPath, o as mapToClaudeMode, b as stopCaffeinate, e as publishSessionRegistration, q as getEnvironmentInfo, u as startCaffeinate } from './index-Cxrx9m5D.mjs';
+import { j as getProjectPath, F as Future, k as claudeLocal, E as ExitCodeError, l as trimIdent, m as createClaudeBackend, f as formatDisplayMessage, t as truncateDisplayMessage, n as claudeCheckSession, e as projectPath, o as mapToClaudeMode, P as PushableAsyncIterable, q as query, A as AbortError, b as stopCaffeinate, p as publishSessionRegistration, u as getEnvironmentInfo, w as startCaffeinate } from './index-DpWeKfvS.mjs';
 import 'ps-list';
 import 'fs';
 import 'path';
@@ -11,11 +11,12 @@ import 'child_process';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
 import { dirname, basename, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
-import './persistence-9Iu0wGNM.mjs';
+import { execSync } from 'node:child_process';
+import 'node:readline';
+import './persistence-B89V4xY5.mjs';
 import { readFile } from 'node:fs/promises';
 import { stat, watch, access } from 'fs/promises';
 import 'crypto';
-import { execSync, spawn } from 'node:child_process';
 import 'chalk';
 import 'node:events';
 import 'axios';
@@ -23,11 +24,9 @@ import 'tweetnacl';
 import 'open';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { useStdout, useInput, Box, Text, render } from 'ink';
-import { c as createKeepAliveController, r as runModeLoop } from './createKeepAliveController-C5cQlDRr.mjs';
+import { c as createKeepAliveController, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-DDWyn9Lo.mjs';
 import { R as RawJSONLinesSchema } from './types-CiliQpqS.mjs';
-import { b as MessageBuffer, s as syncControlledByUserState, e as ensureManagedProviderMachine, M as MissingMachineIdError, d as createSessionMetadata, a as MessageQueue2, h as hashObject, r as registerKillSessionHandler, c as closeProviderSession } from './registerKillSessionHandler-BElGmD1E.mjs';
-import { createInterface } from 'node:readline';
-import { fileURLToPath } from 'node:url';
+import { B as BasePermissionHandler, d as MessageBuffer, C as ConversationHistory$1, w as waitForResponseCompleteWithAbort, l as launchRuntimeHandleWithFactoryResult, j as forwardAgentMessageToProviderSession, s as syncControlledByUserState, e as ensureManagedProviderMachine, M as MissingMachineIdError, c as createSessionMetadata, b as MessageQueue2, h as hashObject, r as registerKillSessionHandler, f as closeProviderSession } from './registerKillSessionHandler-CwmYlUfS.mjs';
 import 'socket.io-client';
 import 'expo-server-sdk';
 import { isDeepStrictEqual } from 'node:util';
@@ -41,6 +40,7 @@ import 'fastify';
 import 'fastify-type-provider-zod';
 import 'http';
 import 'util';
+import 'node:url';
 
 class Session {
   path;
@@ -201,27 +201,6 @@ class Session {
   };
 }
 
-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;
-  }
-}
-
 class InvalidateSync {
   _invalidated = false;
   _invalidatedDouble = false;
@@ -715,6 +694,50 @@ async function claudeLocalLauncher(session) {
   return exitReason || { type: "exit", code: 0 };
 }
 
+function parseCompact(message) {
+  const trimmed = message.trim();
+  if (trimmed === "/compact") {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  if (trimmed.startsWith("/compact ")) {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  return {
+    isCompact: false,
+    originalMessage: message
+  };
+}
+function parseClear(message) {
+  const trimmed = message.trim();
+  return {
+    isClear: trimmed === "/clear"
+  };
+}
+function parseSpecialCommand(message) {
+  const compactResult = parseCompact(message);
+  if (compactResult.isCompact) {
+    return {
+      type: "compact",
+      originalMessage: compactResult.originalMessage
+    };
+  }
+  const clearResult = parseClear(message);
+  if (clearResult.isClear) {
+    return {
+      type: "clear"
+    };
+  }
+  return {
+    type: null
+  };
+}
+
 const RemoteModeDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal }) => {
   const [messages, setMessages] = useState([]);
   const [confirmationMode, setConfirmationMode] = useState(null);
@@ -840,699 +863,593 @@ const RemoteModeDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal })
   ));
 };
 
-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";
-  }
+function getClaudeSettingsPath() {
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeConfigDir, "settings.json");
 }
-
-const __filename$1 = fileURLToPath(import.meta.url);
-const __dirname$1 = join(__filename$1, "..");
-function getGlobalClaudeVersion() {
+function readClaudeSettings() {
   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 {
+    const settingsPath = getClaudeSettingsPath();
+    if (!existsSync(settingsPath)) {
+      logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
+      return null;
+    }
+    const settingsContent = readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsContent);
+    logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
+    logger.debug(`[ClaudeSettings] includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
+    return settings;
+  } catch (error) {
+    logger.debug(`[ClaudeSettings] Error reading Claude settings: ${error}`);
     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");
+function shouldIncludeCoAuthoredBy() {
+  const settings = readClaudeSettings();
+  if (!settings || settings.includeCoAuthoredBy === void 0) {
+    return true;
   }
-  return env;
+  return settings.includeCoAuthoredBy;
 }
-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 {
-    }
+
+const BASE_SYSTEM_PROMPT = (() => trimIdent(`
+    Help human.
+`))();
+const CO_AUTHORED_CREDITS = (() => trimIdent(`
+    When making commit messages, instead of just giving co-credit to Claude, also give credit to Happy like so:
+
+    <main commit message>
+
+    Generated with [Claude Code](https://claude.ai/code)
+    via [Happy](https://happy.engineering)
+
+    Co-Authored-By: Claude <noreply@anthropic.com>
+    Co-Authored-By: Happy <yesreply@happy.engineering>
+`))();
+const systemPrompt = (() => {
+  const includeCoAuthored = shouldIncludeCoAuthoredBy();
+  if (includeCoAuthored) {
+    return BASE_SYSTEM_PROMPT + "\n\n" + CO_AUTHORED_CREDITS;
+  } else {
+    return BASE_SYSTEM_PROMPT;
   }
-  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 (process.env.DEBUG) {
-    logger.debug(message);
-    console.log(message);
+})();
+
+function getToolDescriptor(toolName) {
+  if (toolName === "exit_plan_mode" || toolName === "ExitPlanMode") {
+    return { edit: false, exitPlan: true };
   }
-}
-async function streamToStdin(stream, stdin, abort) {
-  for await (const message of stream) {
-    if (abort?.aborted) break;
-    stdin.write(JSON.stringify(message) + "\n");
+  if (toolName === "Edit" || toolName === "MultiEdit" || toolName === "Write" || toolName === "NotebookEdit") {
+    return { edit: true, exitPlan: false };
   }
-  stdin.end();
+  return { edit: false, exitPlan: false };
 }
 
-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);
+class ClaudeAcpPermissionHandler extends BasePermissionHandler {
+  currentPermissionMode = "default";
+  constructor(session) {
+    super(session);
   }
-  /**
-   * AsyncIterableIterator implementation
-   */
-  next(...args) {
-    return this.sdkMessages.next(...args);
+  getLogPrefix() {
+    return "[ClaudeACP]";
   }
-  return(value) {
-    if (this.sdkMessages.return) {
-      return this.sdkMessages.return(value);
-    }
-    return Promise.resolve({ done: true, value: void 0 });
+  setPermissionMode(mode) {
+    this.currentPermissionMode = mode;
+    logger.debug(`${this.getLogPrefix()} Permission mode set to: ${mode}`);
   }
-  throw(e) {
-    if (this.sdkMessages.throw) {
-      return this.sdkMessages.throw(e);
+  shouldAutoApprove(toolName) {
+    const descriptor = getToolDescriptor(toolName);
+    switch (this.currentPermissionMode) {
+      case "bypassPermissions":
+      case "yolo":
+        return true;
+      case "acceptEdits":
+        return descriptor.edit;
+      default:
+        return false;
     }
-    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 handler = this.pendingControlResponses.get(controlResponse.response.request_id);
-              if (handler) {
-                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);
+  async handleToolCall(toolCallId, toolName, input) {
+    if (this.shouldAutoApprove(toolName)) {
+      const decision = this.currentPermissionMode === "bypassPermissions" || this.currentPermissionMode === "yolo" ? "approved_for_session" : "approved";
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now(),
+            completedAt: Date.now(),
+            status: "approved",
+            decision
           }
         }
-      }
-      await this.processExitPromise;
-    } catch (error) {
-      this.inputStream.error(error);
-    } finally {
-      this.inputStream.done();
-      this.cleanupControllers();
-      rl.close();
+      }));
+      logger.debug(`${this.getLogPrefix()} Auto-approved tool ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
+      return { decision };
     }
+    return this.registerPendingRequest(
+      toolCallId,
+      toolName,
+      input,
+      ` in ${this.currentPermissionMode} mode`
+    );
   }
-  /**
-   * Async generator for SDK messages
-   */
-  async *readSdkMessages() {
-    for await (const message of this.inputStream) {
-      yield message;
+}
+
+function normalizeClaudeBackendError(error) {
+  const record = typeof error === "object" && error !== null ? error : null;
+  const text = formatDisplayMessage(error).trim();
+  const stderrText = record ? formatDisplayMessage(record.stderr).trim() : "";
+  const detailText = record ? formatDisplayMessage(record.detail).trim() : "";
+  const searchable = [text, stderrText, detailText].filter(Boolean).join("\n").trim();
+  return searchable || "Claude ACP backend exited unexpectedly";
+}
+const CLAUDE_ACP_LEGACY_FINAL_MESSAGE_SHADOW = "claude-acp-final-message-shadow";
+async function claudeAcpRemoteLauncher(session) {
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  const messageBuffer = new MessageBuffer({ enabled: hasTTY });
+  let inkInstance = null;
+  let shouldExit = false;
+  let abortController = new AbortController();
+  let runtimeHandle = null;
+  let unsubscribeRuntimeMessages = null;
+  let currentModeHash = null;
+  let pending = null;
+  let accumulatedResponse = "";
+  let isResponseInProgress = false;
+  let taskStartedSent = false;
+  let currentAssistantMessageId = null;
+  let currentThinkingMessageId = null;
+  let shouldInjectHistoryOnNextSession = false;
+  let readyAlreadySent = false;
+  const permissionHandler = new ClaudeAcpPermissionHandler(session.client);
+  const selectionHandler = new ProviderSelectionHandler(session.client, "Claude");
+  const conversationHistory = new ConversationHistory$1({
+    maxMessages: 20,
+    maxCharacters: 5e4
+  });
+  const rotateAbortController = () => {
+    const activeController = abortController;
+    abortController = new AbortController();
+    return activeController;
+  };
+  const sendReady = () => {
+    session.client.sendSessionEvent({ type: "ready" });
+    try {
+      session.api.push().sendToAllDevices(
+        "It's ready!",
+        "Claude is waiting for your command",
+        { sessionId: session.client.sessionId }
+      );
+    } catch (pushError) {
+      logger.debug("[ClaudeACP] Failed to send ready push", pushError);
     }
-  }
-  /**
-   * Send interrupt request to Claude
-   */
-  async interrupt() {
-    if (!this.childStdin) {
-      throw new Error("Interrupt requires --input-format stream-json");
+  };
+  const emitStatusMessage = (message) => {
+    messageBuffer.addMessage(message, "status");
+    session.client.sendSessionEvent({ type: "message", message });
+  };
+  const emitUserVisibleErrorMessage = (message) => {
+    emitStatusMessage(message);
+    session.client.sendAgentMessage("claude", {
+      type: "message",
+      message
+    });
+  };
+  const resetTurnState = () => {
+    accumulatedResponse = "";
+    isResponseInProgress = false;
+    taskStartedSent = false;
+    currentAssistantMessageId = null;
+    currentThinkingMessageId = null;
+    session.onThinkingChange(false);
+  };
+  const emitFinalAssistantMessage = () => {
+    const finalMessage = accumulatedResponse.trim();
+    if (!finalMessage) {
+      accumulatedResponse = "";
+      isResponseInProgress = false;
+      return;
     }
-    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");
+    conversationHistory.addAssistantMessage(finalMessage);
+    session.client.sendAgentMessage("claude", {
+      type: "message",
+      message: finalMessage
     });
-  }
-  /**
-   * 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");
+    session.client.sendClaudeSessionMessage({
+      type: "assistant",
+      uuid: randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: session.sessionId ?? void 0,
+      happyCompatibilityShadow: CLAUDE_ACP_LEGACY_FINAL_MESSAGE_SHADOW,
+      message: {
+        role: "assistant",
+        content: [{
+          type: "text",
+          text: finalMessage,
+          happyCompatibilityShadow: CLAUDE_ACP_LEGACY_FINAL_MESSAGE_SHADOW
+        }]
+      }
+    });
+    accumulatedResponse = "";
+    isResponseInProgress = false;
+  };
+  const disposeRuntimeHandle = async () => {
+    if (!runtimeHandle) {
       return;
     }
-    const controller = new AbortController();
-    this.cancelControllers.set(request.request_id, controller);
+    const activeHandle = runtimeHandle;
+    runtimeHandle = null;
+    unsubscribeRuntimeMessages?.();
+    unsubscribeRuntimeMessages = null;
     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");
+      await activeHandle.dispose();
     } 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);
+      logger.debug("[ClaudeACP] Error disposing runtime handle:", error);
     }
-  }
-  /**
-   * 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);
+  };
+  const queueHistoryInjectionForRestart = (reason) => {
+    messageBuffer.addMessage("\u2550".repeat(40), "status");
+    if (conversationHistory.hasHistory()) {
+      shouldInjectHistoryOnNextSession = true;
+      const message = `${reason} Preserving ${conversationHistory.size()} earlier messages of context.`;
+      emitStatusMessage(message);
+      logger.debug(`[ClaudeACP] Will inject conversation history after restart: ${conversationHistory.getSummary()}`);
+      return;
     }
-  }
-  /**
-   * 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
+    emitStatusMessage(reason);
+  };
+  const setupRuntimeMessageHandler = (activeRuntimeHandle) => {
+    const forwardAgentMessage = (agentMessage) => {
+      forwardAgentMessageToProviderSession(agentMessage, {
+        provider: "claude",
+        send: (body) => session.client.sendAgentMessage("claude", body)
       });
-    }
-    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,
-      model,
-      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 (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 (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"],
-    signal: config.options?.abort,
-    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;
-  }
-  if (process.env.DEBUG) {
-    child.stderr.on("data", (data) => {
-      console.error("Claude Code stderr:", data.toString());
+    };
+    unsubscribeRuntimeMessages?.();
+    unsubscribeRuntimeMessages = activeRuntimeHandle.onMessage((msg) => {
+      switch (msg.type) {
+        case "model-output": {
+          const text = msg.textDelta ?? msg.fullText ?? "";
+          if (!text) {
+            return;
+          }
+          if (!isResponseInProgress) {
+            if (currentThinkingMessageId) {
+              messageBuffer.removeMessage(currentThinkingMessageId);
+              currentThinkingMessageId = null;
+            }
+            currentAssistantMessageId = messageBuffer.addMessage(text, "assistant");
+            isResponseInProgress = true;
+          } else if (currentAssistantMessageId) {
+            const updated = messageBuffer.updateMessage(currentAssistantMessageId, text);
+            if (!updated) {
+              currentAssistantMessageId = messageBuffer.addMessage(text, "assistant");
+            }
+          }
+          accumulatedResponse += text;
+          return;
+        }
+        case "status": {
+          if (msg.status === "running") {
+            session.onThinkingChange(true);
+            if (!taskStartedSent) {
+              session.client.sendAgentMessage("claude", {
+                type: "task_started",
+                id: randomUUID()
+              });
+              taskStartedSent = true;
+            }
+            if (!isResponseInProgress && !currentThinkingMessageId) {
+              currentThinkingMessageId = messageBuffer.addMessage("Thinking...", "system");
+            }
+            return;
+          }
+          if (msg.status === "idle" || msg.status === "stopped") {
+            session.onThinkingChange(false);
+            return;
+          }
+          if (msg.status === "error") {
+            messageBuffer.addMessage(`Error: ${normalizeClaudeBackendError(msg.detail)}`, "status");
+          }
+          return;
+        }
+        case "tool-call": {
+          const toolArgs = truncateDisplayMessage(msg.args, 100);
+          messageBuffer.addMessage(
+            `Executing: ${msg.toolName}${toolArgs ? ` ${toolArgs}` : ""}`,
+            "tool"
+          );
+          forwardAgentMessage(msg);
+          return;
+        }
+        case "tool-result": {
+          const resultText = truncateDisplayMessage(msg.result, 200);
+          messageBuffer.addMessage(resultText ? `Result: ${resultText}` : "Tool completed", "result");
+          forwardAgentMessage(msg);
+          return;
+        }
+        case "fs-edit": {
+          messageBuffer.addMessage(`File edit: ${msg.description}`, "tool");
+          forwardAgentMessage(msg);
+          return;
+        }
+        case "terminal-output": {
+          const output = formatDisplayMessage(msg.data);
+          messageBuffer.addMessage(output, "result");
+          forwardAgentMessage({
+            ...msg,
+            data: output
+          });
+          return;
+        }
+        case "permission-request": {
+          forwardAgentMessage(msg);
+          return;
+        }
+        case "token-count": {
+          forwardAgentMessage(msg);
+          return;
+        }
+        case "exec-approval-request":
+        case "patch-apply-begin":
+        case "patch-apply-end": {
+          forwardAgentMessage(msg);
+          return;
+        }
+        case "event": {
+          if (msg.name === "thinking") {
+            const payload = msg.payload;
+            const thinkingText = typeof payload?.text === "string" ? payload.text : "";
+            if (thinkingText) {
+              session.client.sendAgentMessage("claude", {
+                type: "thinking",
+                text: thinkingText
+              });
+              if (!isResponseInProgress) {
+                const preview = `[Thinking] ${thinkingText.substring(0, 100)}...`;
+                if (currentThinkingMessageId) {
+                  messageBuffer.updateMessage(currentThinkingMessageId, preview, { mode: "replace" });
+                } else {
+                  currentThinkingMessageId = messageBuffer.addMessage(preview, "system");
+                }
+              }
+            }
+          }
+          return;
+        }
+        default:
+          return;
+      }
     });
-  }
-  const cleanup = () => {
-    if (!child.killed) {
-      child.kill("SIGTERM");
-    }
   };
-  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) {
-        query2.setError(new Error(`Claude Code process exited with code ${code}`));
-      } else {
-        resolve();
-      }
+  const createRuntimeHandle = async (mode) => {
+    const { session: nextRuntimeHandle, factoryResult } = await launchRuntimeHandleWithFactoryResult({
+      provider: "claude",
+      cwd: session.path,
+      createBackendResult: (opts) => createClaudeBackend({
+        ...opts,
+        baseArgs: session.claudeArgs,
+        mcpServers: session.mcpServers,
+        permissionHandler,
+        permissionMode: mode.permissionMode,
+        model: mode.model,
+        fallbackModel: mode.fallbackModel,
+        customSystemPrompt: mode.customSystemPrompt ? `${mode.customSystemPrompt}
+
+${systemPrompt}` : void 0,
+        appendSystemPrompt: mode.appendSystemPrompt ? `${mode.appendSystemPrompt}
+
+${systemPrompt}` : systemPrompt,
+        allowedTools: mode.allowedTools ? mode.allowedTools.concat(session.allowedTools ?? []) : session.allowedTools,
+        disallowedTools: mode.disallowedTools,
+        settingsPath: session.hookSettingsPath
+      })
     });
-  });
-  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;
+    logger.debug("[ClaudeACP] Started Claude ACP backend", {
+      command: factoryResult.command,
+      args: factoryResult.args
+    });
+    runtimeHandle = nextRuntimeHandle;
+    setupRuntimeMessageHandler(nextRuntimeHandle);
+    session.consumeOneTimeFlags();
+    return nextRuntimeHandle;
+  };
+  const abortActiveTurn = async () => {
+    const activeController = rotateAbortController();
+    activeController.abort();
+    session.onThinkingChange(false);
+    if (runtimeHandle) {
+      await runtimeHandle.cancel().catch((error) => {
+        logger.debug("[ClaudeACP] Error cancelling runtime handle:", error);
+      });
     }
-  });
-  return query2;
-}
-
-function parseCompact(message) {
-  const trimmed = message.trim();
-  if (trimmed === "/compact") {
-    return {
-      isCompact: true,
-      originalMessage: trimmed
-    };
-  }
-  if (trimmed.startsWith("/compact ")) {
-    return {
-      isCompact: true,
-      originalMessage: trimmed
-    };
-  }
-  return {
-    isCompact: false,
-    originalMessage: message
   };
-}
-function parseClear(message) {
-  const trimmed = message.trim();
-  return {
-    isClear: trimmed === "/clear"
+  const completeSyntheticTurn = () => {
+    session.client.sendAgentMessage("claude", {
+      type: "task_complete",
+      id: randomUUID()
+    });
   };
-}
-function parseSpecialCommand(message) {
-  const compactResult = parseCompact(message);
-  if (compactResult.isCompact) {
-    return {
-      type: "compact",
-      originalMessage: compactResult.originalMessage
-    };
-  }
-  const clearResult = parseClear(message);
-  if (clearResult.isClear) {
-    return {
-      type: "clear"
-    };
-  }
-  return {
-    type: null
+  const handleClearCommand = async () => {
+    logger.debug("[ClaudeACP] /clear command received - resetting runtime and local history");
+    conversationHistory.clear();
+    shouldInjectHistoryOnNextSession = false;
+    await disposeRuntimeHandle();
+    session.clearSessionId();
+    currentModeHash = null;
+    permissionHandler.reset();
+    selectionHandler.reset();
+    resetTurnState();
+    emitStatusMessage("Context was reset");
+    completeSyntheticTurn();
   };
-}
-
-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();
+  const handleSwitchToLocal = async () => {
+    const message = "Daemon-spawned Claude ACP sessions stay in remote mode.";
+    logger.debug("[ClaudeACP] Ignoring switch request because daemon sessions are remote-only");
+    emitStatusMessage(message);
+  };
+  const handleAbort = async () => {
+    logger.debug("[ClaudeACP] Abort requested - stopping current task");
+    await abortActiveTurn();
+  };
+  if (hasTTY) {
+    console.clear();
+    inkInstance = render(React.createElement(RemoteModeDisplay, {
+      messageBuffer,
+      logPath: process.env.DEBUG ? session.logPath : void 0,
+      onExit: async () => {
+        shouldExit = true;
+        await handleAbort();
+      },
+      onSwitchToLocal: () => {
+        void handleSwitchToLocal();
+      }
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
   }
-  /**
-   * Set an error on the iterable
-   */
-  setError(err) {
-    if (this.isDone) {
-      return;
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
     }
-    this.error = err;
-    this.isDone = true;
-    this.cleanup();
+    process.stdin.setEncoding("utf8");
   }
-  /**
-   * 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 });
+  session.client.rpcHandlerManager.registerHandler("abort", handleAbort);
+  session.client.rpcHandlerManager.registerHandler("switch", handleSwitchToLocal);
+  try {
+    while (!shouldExit) {
+      let message = pending;
+      pending = null;
+      if (!message) {
+        const waitSignal = abortController.signal;
+        const batch = await session.queue.waitForMessagesAndGetAsString(waitSignal);
+        if (!batch) {
+          if (waitSignal.aborted && !shouldExit) {
+            continue;
+          }
+          break;
+        }
+        message = batch;
+      }
+      if (!message) {
+        break;
+      }
+      if (runtimeHandle && currentModeHash && message.hash !== currentModeHash) {
+        queueHistoryInjectionForRestart("Starting new Claude ACP session (execution settings changed)...");
+        await disposeRuntimeHandle();
+        session.clearSessionId();
+        currentModeHash = null;
+        pending = message;
+        permissionHandler.reset();
+        selectionHandler.reset();
+        resetTurnState();
+        continue;
+      }
+      currentModeHash = message.hash;
+      readyAlreadySent = false;
+      const specialCommand = parseSpecialCommand(message.message);
+      if (specialCommand.type === "clear") {
+        await handleClearCommand();
+        if (!shouldExit && !pending && session.queue.size() === 0 && !readyAlreadySent) {
+          sendReady();
+          readyAlreadySent = true;
+        }
+        continue;
+      }
+      permissionHandler.setPermissionMode(message.mode.permissionMode);
+      messageBuffer.addMessage(message.message, "user");
+      let shouldClearHistoryAfterTurn = false;
+      try {
+        const activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
+        let promptToSend = message.message;
+        if (shouldInjectHistoryOnNextSession && conversationHistory.hasHistory()) {
+          const historyContext = conversationHistory.getContextForNewSession(
+            "Continue from the prior Claude ACP session using the conversation below as context."
+          );
+          promptToSend = historyContext + promptToSend;
+          logger.debug(`[ClaudeACP] Injected conversation history context (${historyContext.length} chars)`);
+        }
+        if (specialCommand.type === "compact") {
+          emitStatusMessage("Compaction started");
+        }
+        conversationHistory.addUserMessage(message.message);
+        await activeRuntimeHandle.sendPrompt(promptToSend);
+        await waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, abortController.signal);
+        shouldInjectHistoryOnNextSession = false;
+        shouldClearHistoryAfterTurn = specialCommand.type === "compact";
+      } catch (error) {
+        logger.warn("[ClaudeACP] Error in Claude ACP session:", error);
+        const isAbortError = error instanceof Error && error.name === "AbortError";
+        const isExpectedInterruption = isAbortError || abortController.signal.aborted || shouldExit;
+        if (isExpectedInterruption) {
+          session.client.sendAgentMessage("claude", {
+            type: "turn_aborted",
+            id: randomUUID()
+          });
+          emitStatusMessage("Aborted by user");
+        } else {
+          const errorMessage = normalizeClaudeBackendError(error);
+          emitUserVisibleErrorMessage(errorMessage);
+          if (conversationHistory.hasHistory()) {
+            shouldInjectHistoryOnNextSession = true;
+          }
+          await disposeRuntimeHandle();
+          session.clearSessionId();
+          currentModeHash = null;
+        }
+      } finally {
+        emitFinalAssistantMessage();
+        if (shouldClearHistoryAfterTurn) {
+          conversationHistory.clear();
+          emitStatusMessage("Compaction completed");
+        }
+        if (!shouldExit) {
+          session.client.sendAgentMessage("claude", {
+            type: "task_complete",
+            id: randomUUID()
+          });
+        }
+        permissionHandler.reset();
+        selectionHandler.reset();
+        resetTurnState();
+        if (!shouldExit && !pending && session.queue.size() === 0 && !readyAlreadySent) {
+          sendReady();
+          readyAlreadySent = true;
+        }
       }
     }
-  }
-  /**
-   * AsyncIterableIterator implementation
-   */
-  async next() {
-    if (this.queue.length > 0) {
-      return { done: false, value: this.queue.shift() };
+  } finally {
+    await disposeRuntimeHandle();
+    permissionHandler.reset();
+    selectionHandler.reset();
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
     }
-    if (this.isDone) {
-      if (this.error) {
-        throw this.error;
+    if (hasTTY) {
+      try {
+        process.stdin.pause();
+      } catch {
       }
-      return { done: true, value: void 0 };
     }
-    return new Promise((resolve, reject) => {
-      this.waiters.push({ resolve, reject });
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
     });
-  }
-  /**
-   * 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");
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    if (inkInstance) {
+      inkInstance.unmount();
     }
-    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;
+    messageBuffer.clear();
   }
+  logger.debug("[ClaudeACP] Remote launcher returning: exit");
+  return "exit";
 }
 
 async function awaitFileExist(file, timeout = 1e4) {
@@ -1548,58 +1465,6 @@ async function awaitFileExist(file, timeout = 1e4) {
   return false;
 }
 
-function getClaudeSettingsPath() {
-  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
-  return join(claudeConfigDir, "settings.json");
-}
-function readClaudeSettings() {
-  try {
-    const settingsPath = getClaudeSettingsPath();
-    if (!existsSync(settingsPath)) {
-      logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
-      return null;
-    }
-    const settingsContent = readFileSync(settingsPath, "utf-8");
-    const settings = JSON.parse(settingsContent);
-    logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
-    logger.debug(`[ClaudeSettings] includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
-    return settings;
-  } catch (error) {
-    logger.debug(`[ClaudeSettings] Error reading Claude settings: ${error}`);
-    return null;
-  }
-}
-function shouldIncludeCoAuthoredBy() {
-  const settings = readClaudeSettings();
-  if (!settings || settings.includeCoAuthoredBy === void 0) {
-    return true;
-  }
-  return settings.includeCoAuthoredBy;
-}
-
-const BASE_SYSTEM_PROMPT = (() => trimIdent(`
-    Help human.
-`))();
-const CO_AUTHORED_CREDITS = (() => trimIdent(`
-    When making commit messages, instead of just giving co-credit to Claude, also give credit to Happy like so:
-
-    <main commit message>
-
-    Generated with [Claude Code](https://claude.ai/code)
-    via [Happy](https://happy.engineering)
-
-    Co-Authored-By: Claude <noreply@anthropic.com>
-    Co-Authored-By: Happy <yesreply@happy.engineering>
-`))();
-const systemPrompt = (() => {
-  const includeCoAuthored = shouldIncludeCoAuthoredBy();
-  if (includeCoAuthored) {
-    return BASE_SYSTEM_PROMPT + "\n\n" + CO_AUTHORED_CREDITS;
-  } else {
-    return BASE_SYSTEM_PROMPT;
-  }
-})();
-
 async function claudeRemote(opts) {
   let startFrom = opts.sessionId;
   if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path, opts.transcriptPath)) {
@@ -1803,16 +1668,6 @@ function getToolName(toolName) {
   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();
@@ -2982,9 +2837,7 @@ async function loop(opts) {
         return { type: "exit", value: result.code };
       },
       remote: async () => {
-        const reason = await claudeRemoteLauncher(session, {
-          allowSwitchToLocal: opts.startedBy !== "daemon"
-        });
+        const reason = opts.startedBy === "daemon" ? await claudeAcpRemoteLauncher(session) : await claudeRemoteLauncher(session);
         if (reason === "switch") {
           return { type: "switch", mode: "local" };
         }