happy-imou-cloud 2.0.10 → 2.0.11

package/dist/{runClaude-B_fTMxc4.mjs → runClaude-cQ-UT0Ke.mjs}

@@ -1,45 +1,46 @@
-import os, { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { l as logger, d as backoff, f as delay, g as AsyncLock, c as configuration, b as connectionState, A as ApiClient, p as packageJson, i as isAuthenticationRequiredError, s as startOfflineReconnection } from './api-BjxmW-0W.mjs';
-import { h as getProjectPath, j as claudeLocal, E as ExitCodeError, k as isBun, l as trimIdent, m as claudeCheckSession, d as projectPath, n as getEnvironmentInfo, i as initialMachineMetadata, b as stopCaffeinate, p as publishSessionRegistration, o as startCaffeinate } from './index-CzvgPwr1.mjs';
-import { R as RawJSONLinesSchema } from './types-CiliQpqS.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-BcWf5v4i.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 'ps-list';
+import 'fs';
+import 'path';
+import 'os';
+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 { readFile } from 'node:fs/promises';
 import { stat, watch, access } from 'fs/promises';
-import { useStdout, useInput, Box, Text, render } from 'ink';
-import { a as MessageBuffer, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler } from './registerKillSessionHandler-ARQrPvnT.mjs';
-import React, { useState, useRef, useEffect, useCallback } from 'react';
+import 'crypto';
 import { execSync, spawn } from 'node:child_process';
+import 'chalk';
+import 'node:events';
+import 'axios';
+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 { 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 { createInterface } from 'node:readline';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import 'axios';
-import 'node:events';
 import 'socket.io-client';
-import 'tweetnacl';
 import 'expo-server-sdk';
-import 'chalk';
 import { isDeepStrictEqual } from 'node:util';
-import { readSettings } from './persistence-BxP6Jw1f.mjs';
 import { createServer } from 'node:http';
-import 'fs';
 import 'zod';
-import 'child_process';
-import 'util';
-import 'crypto';
-import 'path';
-import 'os';
 import 'tmp';
 import 'qrcode-terminal';
 import 'node:module';
-import 'open';
 import 'url';
-import 'ps-list';
-import 'cross-spawn';
 import 'fastify';
 import 'fastify-type-provider-zod';
 import 'http';
-import '@agentclientprotocol/sdk';
+import 'util';
 
 class Session {
   path;
@@ -63,8 +64,7 @@ class Session {
   thinking = false;
   /** Callbacks to be notified when session ID is found/changed */
   sessionFoundCallbacks = [];
-  /** Keep alive interval reference for cleanup */
-  keepAliveInterval;
+  keepAliveController;
   constructor(opts) {
     this.path = opts.path;
     this.api = opts.api;
@@ -79,26 +79,29 @@ class Session {
     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);
+    this.keepAliveController = createKeepAliveController({
+      initialMode: this.mode,
+      initialThinking: this.thinking,
+      send: (thinking, mode) => {
+        this.client.keepAlive(thinking, mode);
+      }
+    });
   }
   /**
    * Cleanup resources (call when session is no longer needed)
    */
   cleanup = () => {
-    clearInterval(this.keepAliveInterval);
+    this.keepAliveController.dispose();
     this.sessionFoundCallbacks = [];
     logger.debug("[Session] Cleaned up resources");
   };
   onThinkingChange = (thinking) => {
     this.thinking = thinking;
-    this.client.keepAlive(thinking, this.mode);
+    this.keepAliveController.setThinking(thinking);
   };
   onModeChange = (mode) => {
     this.mode = mode;
-    this.client.keepAlive(this.thinking, mode);
+    this.keepAliveController.setMode(mode);
     this._onModeChange(mode);
   };
   /**
@@ -712,6 +715,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);
@@ -803,39 +850,615 @@ const RemoteModeDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal })
       for (let i = 0; i < line.length; i += maxLineLength) {
         chunks.push(line.slice(i, i + maxLineLength));
       }
-      return chunks.join("\n");
-    }).join("\n");
-  };
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
-    Box,
-    {
-      flexDirection: "column",
-      width: terminalWidth,
-      height: terminalHeight - 4,
-      borderStyle: "round",
-      borderColor: "gray",
-      paddingX: 1,
-      overflow: "hidden"
-    },
-    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "\u{1F4E1} Remote Mode - Claude Messages"), /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
-    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Waiting for messages...") : (
-      // Show only the last messages that fit in the available space
-      messages.slice(-Math.max(1, terminalHeight - 10)).map((msg) => /* @__PURE__ */ React.createElement(Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
-    ))
-  ), /* @__PURE__ */ React.createElement(
-    Box,
-    {
-      width: terminalWidth,
-      borderStyle: "round",
-      borderColor: actionInProgress ? "gray" : confirmationMode === "exit" ? "red" : confirmationMode === "switch" ? "yellow" : "green",
-      paddingX: 2,
-      justifyContent: "center",
-      alignItems: "center",
-      flexDirection: "column"
-    },
-    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Exiting...") : actionInProgress === "switching" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Switching to local mode...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit completely") : confirmationMode === "switch" ? /* @__PURE__ */ React.createElement(Text, { color: "yellow", bold: true }, "\u23F8\uFE0F  Press space again to switch to local mode") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "\u{1F4F1} Press space to switch to local mode \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
-  ));
-};
+      return chunks.join("\n");
+    }).join("\n");
+  };
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      flexDirection: "column",
+      width: terminalWidth,
+      height: terminalHeight - 4,
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      overflow: "hidden"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "\u{1F4E1} Remote Mode - Claude Messages"), /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Waiting for messages...") : (
+      // Show only the last messages that fit in the available space
+      messages.slice(-Math.max(1, terminalHeight - 10)).map((msg) => /* @__PURE__ */ React.createElement(Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
+    ))
+  ), /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      width: terminalWidth,
+      borderStyle: "round",
+      borderColor: actionInProgress ? "gray" : confirmationMode === "exit" ? "red" : confirmationMode === "switch" ? "yellow" : "green",
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Exiting...") : actionInProgress === "switching" ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Switching to local mode...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit completely") : confirmationMode === "switch" ? /* @__PURE__ */ React.createElement(Text, { color: "yellow", bold: true }, "\u23F8\uFE0F  Press space again to switch to local mode") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "\u{1F4F1} Press space to switch to local mode \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+  ));
+};
+
+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) {
@@ -1362,59 +1985,6 @@ function query(config) {
   return query2;
 }
 
-function mapToClaudeMode(mode) {
-  const codexToClaudeMap = {
-    "yolo": "bypassPermissions",
-    "safe-yolo": "default",
-    "read-only": "default"
-  };
-  return codexToClaudeMap[mode] ?? mode;
-}
-
-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 = [];
@@ -1554,58 +2124,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)) {
@@ -1809,16 +2327,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();
@@ -2960,36 +3468,31 @@ async function loop(opts) {
     jsRuntime: opts.jsRuntime
   });
   opts.onSessionReady?.(session);
-  let mode = opts.startingMode ?? "local";
-  while (true) {
-    logger.debug(`[loop] Iteration with mode: ${mode}`);
-    switch (mode) {
-      case "local": {
+  return await runModeLoop({
+    startingMode: opts.startingMode ?? "local",
+    onIteration: (mode) => {
+      logger.debug(`[loop] Iteration with mode: ${mode}`);
+    },
+    onModeChange: async (mode) => {
+      await opts.onModeChange(mode);
+    },
+    launchers: {
+      local: async () => {
         const result = await claudeLocalLauncher(session);
-        switch (result.type) {
-          case "switch":
-            mode = "remote";
-            opts.onModeChange?.(mode);
-            break;
-          case "exit":
-            return result.code;
+        if (result.type === "switch") {
+          return { type: "switch", mode: "remote" };
         }
-        break;
-      }
-      case "remote": {
-        const reason = await claudeRemoteLauncher(session);
-        switch (reason) {
-          case "exit":
-            return 0;
-          case "switch":
-            mode = "local";
-            opts.onModeChange?.(mode);
-            break;
+        return { type: "exit", value: result.code };
+      },
+      remote: async () => {
+        const reason = opts.startedBy === "daemon" ? await claudeAcpRemoteLauncher(session) : await claudeRemoteLauncher(session);
+        if (reason === "switch") {
+          return { type: "switch", mode: "local" };
         }
-        break;
+        return { type: "exit", value: 0 };
       }
     }
-  }
+  });
 }
 
 async function extractSDKMetadata() {
@@ -3148,6 +3651,143 @@ function cleanupHookSettingsFile(filepath) {
   }
 }
 
+async function runOfflineClaudeLocalFallback(opts) {
+  let offlineSessionId = null;
+  const reconnection = startOfflineReconnection({
+    serverUrl: configuration.serverUrl,
+    onReconnected: async () => {
+      const response = await opts.api.getOrCreateSession({
+        tag: randomUUID(),
+        metadata: opts.metadata,
+        state: opts.state
+      });
+      if (!response) {
+        throw new Error("Server unavailable");
+      }
+      await publishSessionRegistration(response.id, opts.metadata);
+      const session = opts.api.sessionSyncClient(response);
+      await syncControlledByUserState(session, true);
+      const scanner = await createSessionScanner({
+        sessionId: null,
+        workingDirectory: opts.workingDirectory,
+        onMessage: (message) => session.sendClaudeSessionMessage(message)
+      });
+      if (offlineSessionId) {
+        scanner.onNewSession(offlineSessionId);
+      }
+      return { session, scanner };
+    },
+    onNotify: console.log,
+    onCleanup: () => {
+      logger.debug("[claude] Offline reconnection cleanup triggered");
+    }
+  });
+  try {
+    await claudeLocal({
+      path: opts.workingDirectory,
+      sessionId: null,
+      onSessionFound: (sessionId) => {
+        offlineSessionId = sessionId;
+      },
+      onThinkingChange: () => {
+      },
+      abort: new AbortController().signal,
+      claudeEnvVars: opts.claudeEnvVars,
+      claudeArgs: opts.claudeArgs,
+      allowedTools: []
+    });
+  } finally {
+    reconnection.cancel();
+    stopCaffeinate();
+  }
+}
+
+function hasMetaOverride(message, key) {
+  return Object.prototype.hasOwnProperty.call(message.meta ?? {}, key);
+}
+function resolveNullableStringOverride(message, key, currentValue) {
+  if (!hasMetaOverride(message, key)) {
+    return currentValue;
+  }
+  return message.meta?.[key] || void 0;
+}
+function resolveNullableArrayOverride(message, key, currentValue) {
+  if (!hasMetaOverride(message, key)) {
+    return currentValue;
+  }
+  return message.meta?.[key] || void 0;
+}
+function resolveClaudeQueuedMessage(message, currentState) {
+  const permissionMode = message.meta?.permissionMode ?? currentState.permissionMode;
+  const model = resolveNullableStringOverride(message, "model", currentState.model);
+  const fallbackModel = resolveNullableStringOverride(message, "fallbackModel", currentState.fallbackModel);
+  const customSystemPrompt = resolveNullableStringOverride(
+    message,
+    "customSystemPrompt",
+    currentState.customSystemPrompt
+  );
+  const appendSystemPrompt = resolveNullableStringOverride(
+    message,
+    "appendSystemPrompt",
+    currentState.appendSystemPrompt
+  );
+  const allowedTools = resolveNullableArrayOverride(message, "allowedTools", currentState.allowedTools);
+  const disallowedTools = resolveNullableArrayOverride(message, "disallowedTools", currentState.disallowedTools);
+  const mode = {
+    permissionMode: permissionMode || "default",
+    model,
+    fallbackModel,
+    customSystemPrompt,
+    appendSystemPrompt,
+    allowedTools,
+    disallowedTools
+  };
+  const specialCommand = parseSpecialCommand(message.content.text);
+  const nextState = {
+    permissionMode,
+    model,
+    fallbackModel,
+    customSystemPrompt,
+    appendSystemPrompt,
+    allowedTools,
+    disallowedTools
+  };
+  if (specialCommand.type === "compact" || specialCommand.type === "clear") {
+    return {
+      nextState,
+      queuedMessage: {
+        text: specialCommand.originalMessage || message.content.text,
+        mode,
+        isolate: true,
+        specialCommand: specialCommand.type
+      }
+    };
+  }
+  return {
+    nextState,
+    queuedMessage: {
+      text: message.content.text,
+      mode,
+      isolate: false,
+      specialCommand: null
+    }
+  };
+}
+function bindClaudeUserMessageQueue(opts) {
+  let currentState = { ...opts.initialState };
+  opts.session.onUserMessage((message) => {
+    const { nextState, queuedMessage } = resolveClaudeQueuedMessage(message, currentState);
+    currentState = nextState;
+    if (queuedMessage.isolate) {
+      logger.debug(`[claude] Queuing isolated special command: ${queuedMessage.specialCommand}`);
+      opts.messageQueue.pushIsolateAndClear(queuedMessage.text, queuedMessage.mode);
+    } else {
+      opts.messageQueue.push(queuedMessage.text, queuedMessage.mode);
+    }
+    logger.debugLargeJson("[claude] User message queued:", message);
+  });
+}
+
 async function runClaude(credentials, options = {}) {
   logger.debug(`[CLAUDE] ===== CLAUDE MODE STARTING =====`);
   logger.debug(`[CLAUDE] This is the Claude agent, NOT Gemini`);
@@ -3160,36 +3800,25 @@ async function runClaude(credentials, options = {}) {
   }
   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/slopus/happy-cli/issues`);
-    process.exit(1);
+  let machineId;
+  try {
+    machineId = await ensureManagedProviderMachine({
+      api,
+      missingMachineIdMessage: "[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/slopus/happy-cli/issues"
+    });
+  } catch (error) {
+    if (error instanceof MissingMachineIdError) {
+      console.error(error.message);
+      process.exit(1);
+    }
+    throw error;
   }
   logger.debug(`Using machineId: ${machineId}`);
-  await api.getOrCreateMachine({
+  const { state, metadata } = createSessionMetadata({
+    flavor: "claude",
     machineId,
-    metadata: initialMachineMetadata
+    startedBy: options.startedBy
   });
-  let metadata = {
-    path: workingDirectory,
-    host: os.hostname(),
-    version: packageJson.version,
-    os: os.platform(),
-    machineId,
-    homeDir: os.homedir(),
-    happyHomeDir: configuration.happyCloudHomeDir,
-    happyLibDir: projectPath(),
-    happyToolsDir: resolve(projectPath(), "tools", "unpacked"),
-    startedFromDaemon: options.startedBy === "daemon",
-    hostPid: process.pid,
-    startedBy: options.startedBy || "terminal",
-    // Initialize lifecycle state
-    lifecycleState: "running",
-    lifecycleStateSince: Date.now(),
-    flavor: "claude"
-  };
   let response = null;
   try {
     response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
@@ -3200,44 +3829,14 @@ async function runClaude(credentials, options = {}) {
     logger.debug("[START] Falling back to local/offline mode after authentication failure");
   }
   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");
-        await publishSessionRegistration(resp.id, metadata);
-        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: () => {
-      }
+    await runOfflineClaudeLocalFallback({
+      api,
+      metadata,
+      state,
+      workingDirectory,
+      claudeEnvVars: options.claudeEnvVars,
+      claudeArgs: options.claudeArgs
     });
-    try {
-      await claudeLocal({
-        path: workingDirectory,
-        sessionId: null,
-        onSessionFound: (id) => {
-          offlineSessionId = id;
-        },
-        onThinkingChange: () => {
-        },
-        abort: new AbortController().signal,
-        claudeEnvVars: options.claudeEnvVars,
-        claudeArgs: options.claudeArgs,
-        allowedTools: []
-      });
-    } finally {
-      reconnection.cancel();
-      stopCaffeinate();
-    }
     process.exit(0);
   }
   logger.debug(`Session created: ${response.id}`);
@@ -3271,10 +3870,7 @@ async function runClaude(credentials, options = {}) {
   const logPath = logger.logFilePath;
   logger.infoDeveloper(`Session: ${response.id}`);
   logger.infoDeveloper(`Logs: ${logPath}`);
-  session.updateAgentState((currentState) => ({
-    ...currentState,
-    controlledByUser: options.startingMode !== "remote"
-  }));
+  await syncControlledByUserState(session, options.startingMode !== "remote");
   const caffeinateStarted = startCaffeinate();
   if (caffeinateStarted) {
     logger.infoDeveloper("Sleep prevention enabled (macOS)");
@@ -3288,128 +3884,22 @@ async function runClaude(credentials, options = {}) {
     allowedTools: mode.allowedTools,
     disallowedTools: mode.disallowedTools
   }));
-  let currentPermissionMode = options.permissionMode;
-  let currentModel = options.model;
-  let currentFallbackModel = void 0;
-  let currentCustomSystemPrompt = void 0;
-  let currentAppendSystemPrompt = void 0;
-  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 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);
-    if (specialCommand.type === "compact") {
-      logger.debug("[start] Detected /compact command");
-      const enhancedMode2 = {
-        permissionMode: messagePermissionMode || "default",
-        model: messageModel,
-        fallbackModel: messageFallbackModel,
-        customSystemPrompt: messageCustomSystemPrompt,
-        appendSystemPrompt: messageAppendSystemPrompt,
-        allowedTools: messageAllowedTools,
-        disallowedTools: messageDisallowedTools
-      };
-      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
-      logger.debugLargeJson("[start] /compact command pushed to queue:", message);
-      return;
-    }
-    if (specialCommand.type === "clear") {
-      logger.debug("[start] Detected /clear command");
-      const enhancedMode2 = {
-        permissionMode: messagePermissionMode || "default",
-        model: messageModel,
-        fallbackModel: messageFallbackModel,
-        customSystemPrompt: messageCustomSystemPrompt,
-        appendSystemPrompt: messageAppendSystemPrompt,
-        allowedTools: messageAllowedTools,
-        disallowedTools: messageDisallowedTools
-      };
-      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
-      logger.debugLargeJson("[start] /compact command pushed to queue:", message);
-      return;
+  bindClaudeUserMessageQueue({
+    session,
+    messageQueue,
+    initialState: {
+      permissionMode: options.permissionMode,
+      model: options.model
     }
-    const enhancedMode = {
-      permissionMode: messagePermissionMode || "default",
-      model: messageModel,
-      fallbackModel: messageFallbackModel,
-      customSystemPrompt: messageCustomSystemPrompt,
-      appendSystemPrompt: messageAppendSystemPrompt,
-      allowedTools: messageAllowedTools,
-      disallowedTools: messageDisallowedTools
-    };
-    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();
+        await closeProviderSession(session, {
+          archiveReason: "User terminated"
+        });
       }
       stopCaffeinate();
       hookServer.stop();
@@ -3441,12 +3931,9 @@ async function runClaude(credentials, options = {}) {
     api,
     allowedTools: [],
     mcpServers: {},
-    onModeChange: (newMode) => {
+    onModeChange: async (newMode) => {
       session.sendSessionEvent({ type: "switch", mode: newMode });
-      session.updateAgentState((currentState) => ({
-        ...currentState,
-        controlledByUser: newMode === "local"
-      }));
+      await syncControlledByUserState(session, newMode === "local");
     },
     onSessionReady: (sessionInstance) => {
       currentSession = sessionInstance;
@@ -3455,14 +3942,13 @@ async function runClaude(credentials, options = {}) {
     claudeEnvVars: options.claudeEnvVars,
     claudeArgs: options.claudeArgs,
     hookSettingsPath,
-    jsRuntime: options.jsRuntime
+    jsRuntime: options.jsRuntime,
+    startedBy: options.startedBy
   });
   currentSession?.cleanup();
-  session.sendSessionDeath();
   logger.debug("Waiting for socket to flush...");
-  await session.flush();
   logger.debug("Closing session...");
-  await session.close();
+  await closeProviderSession(session);
   stopCaffeinate();
   logger.debug("Stopped sleep prevention");
   hookServer.stop();