happy-imou-cloud 2.0.11 → 2.0.13

package/dist/{runClaude-cQ-UT0Ke.mjs → runClaude-D7dF4RDM.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-BcWf5v4i.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-D1meoL-9.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
-import { j as getProjectPath, k as claudeLocal, E as ExitCodeError, l as trimIdent, m as createClaudeBackend, f as formatDisplayMessage, t as truncateDisplayMessage, n as isBun, o as claudeCheckSession, e as projectPath, q as mapToClaudeMode, b as stopCaffeinate, p as publishSessionRegistration, u as getEnvironmentInfo, w as startCaffeinate } from './index-DnsqY6I_.mjs';
+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 'ps-list';
 import 'fs';
 import 'path';
@@ -11,7 +11,7 @@ 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-BMa6cyw9.mjs';
+import './persistence-9Iu0wGNM.mjs';
 import { readFile } from 'node:fs/promises';
 import { stat, watch, access } from 'fs/promises';
 import 'crypto';
@@ -23,9 +23,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, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-BljOLMQn.mjs';
+import { c as createKeepAliveController, r as runModeLoop } from './createKeepAliveController-C5cQlDRr.mjs';
 import { R as RawJSONLinesSchema } from './types-CiliQpqS.mjs';
-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-Dxwg4L4J.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 'socket.io-client';
@@ -715,50 +715,6 @@ 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);
@@ -884,582 +840,6 @@ const RemoteModeDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal })
   ));
 };
 
-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;
-  }
-})();
-
-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 ClaudeAcpPermissionHandler extends BasePermissionHandler {
-  currentPermissionMode = "default";
-  constructor(session) {
-    super(session);
-  }
-  getLogPrefix() {
-    return "[ClaudeACP]";
-  }
-  setPermissionMode(mode) {
-    this.currentPermissionMode = mode;
-    logger.debug(`${this.getLogPrefix()} Permission mode set to: ${mode}`);
-  }
-  shouldAutoApprove(toolName) {
-    const descriptor = getToolDescriptor(toolName);
-    switch (this.currentPermissionMode) {
-      case "bypassPermissions":
-      case "yolo":
-        return true;
-      case "acceptEdits":
-        return descriptor.edit;
-      default:
-        return false;
-    }
-  }
-  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
-          }
-        }
-      }));
-      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`
-    );
-  }
-}
-
-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";
-}
-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);
-    }
-  };
-  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;
-    }
-    conversationHistory.addAssistantMessage(finalMessage);
-    session.client.sendAgentMessage("claude", {
-      type: "message",
-      message: finalMessage
-    });
-    accumulatedResponse = "";
-    isResponseInProgress = false;
-  };
-  const disposeRuntimeHandle = async () => {
-    if (!runtimeHandle) {
-      return;
-    }
-    const activeHandle = runtimeHandle;
-    runtimeHandle = null;
-    unsubscribeRuntimeMessages?.();
-    unsubscribeRuntimeMessages = null;
-    try {
-      await activeHandle.dispose();
-    } catch (error) {
-      logger.debug("[ClaudeACP] Error disposing runtime handle:", error);
-    }
-  };
-  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;
-    }
-    emitStatusMessage(reason);
-  };
-  const setupRuntimeMessageHandler = (activeRuntimeHandle) => {
-    const forwardAgentMessage = (agentMessage) => {
-      forwardAgentMessageToProviderSession(agentMessage, {
-        provider: "claude",
-        send: (body) => session.client.sendAgentMessage("claude", body)
-      });
-    };
-    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 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,
-        selectionHandler: {
-          handleSelection: (request) => selectionHandler.requestSelection(request)
-        },
-        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
-      })
-    });
-    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);
-      });
-    }
-  };
-  const completeSyntheticTurn = () => {
-    session.client.sendAgentMessage("claude", {
-      type: "task_complete",
-      id: randomUUID()
-    });
-  };
-  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();
-  };
-  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
-    });
-  }
-  if (hasTTY) {
-    process.stdin.resume();
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.setEncoding("utf8");
-  }
-  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;
-        }
-      }
-    }
-  } finally {
-    await disposeRuntimeHandle();
-    permissionHandler.reset();
-    selectionHandler.reset();
-    if (process.stdin.isTTY) {
-      try {
-        process.stdin.setRawMode(false);
-      } catch {
-      }
-    }
-    if (hasTTY) {
-      try {
-        process.stdin.pause();
-      } catch {
-      }
-    }
-    session.client.rpcHandlerManager.registerHandler("abort", async () => {
-    });
-    session.client.rpcHandlerManager.registerHandler("switch", async () => {
-    });
-    if (inkInstance) {
-      inkInstance.unmount();
-    }
-    messageBuffer.clear();
-  }
-  logger.debug("[ClaudeACP] Remote launcher returning: exit");
-  return "exit";
-}
-
 class Stream {
   constructor(returned) {
     this.returned = returned;
@@ -1985,6 +1365,50 @@ function query(config) {
   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"
+  };
+}
+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
+  };
+}
+
 class PushableAsyncIterable {
   queue = [];
   waiters = [];
@@ -2124,6 +1548,58 @@ 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)) {
@@ -2327,6 +1803,16 @@ 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();
@@ -3113,8 +2599,9 @@ class OutgoingMessageQueue {
   }
 }
 
-async function claudeRemoteLauncher(session) {
+async function claudeRemoteLauncher(session, options = {}) {
   logger.debug("[claudeRemoteLauncher] Starting remote launcher");
+  const allowSwitchToLocal = options.allowSwitchToLocal ?? true;
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
   let messageBuffer = new MessageBuffer();
@@ -3132,6 +2619,11 @@ async function claudeRemoteLauncher(session) {
         await abort();
       },
       onSwitchToLocal: () => {
+        if (!allowSwitchToLocal) {
+          logger.debug("[remote]: Ignoring switch-to-local request for remote-only session");
+          session.client.sendSessionEvent({ type: "message", message: "Daemon-spawned Claude sessions stay in remote mode." });
+          return;
+        }
         logger.debug("[remote]: Switching to local mode via double space");
         doSwitch();
       }
@@ -3161,6 +2653,11 @@ async function claudeRemoteLauncher(session) {
     await abort();
   }
   async function doSwitch() {
+    if (!allowSwitchToLocal) {
+      logger.debug("[remote]: Ignoring RPC switch-to-local request for remote-only session");
+      session.client.sendSessionEvent({ type: "message", message: "Daemon-spawned Claude sessions stay in remote mode." });
+      return;
+    }
     logger.debug("[remote]: doSwitch");
     if (!exitReason) {
       exitReason = "switch";
@@ -3485,7 +2982,9 @@ async function loop(opts) {
         return { type: "exit", value: result.code };
       },
       remote: async () => {
-        const reason = opts.startedBy === "daemon" ? await claudeAcpRemoteLauncher(session) : await claudeRemoteLauncher(session);
+        const reason = await claudeRemoteLauncher(session, {
+          allowSwitchToLocal: opts.startedBy !== "daemon"
+        });
         if (reason === "switch") {
           return { type: "switch", mode: "local" };
         }