very-happy-cli 0.2.160 → 0.2.162

package/dist/{runClaude-Da3RirzE.cjs → runClaude-KN-4Y4LH.cjs}

@@ -1,65 +1,71 @@
 'use strict';
 
 var os = require('node:os');
-var sessionLock = require('./sessionLock-Bys1PNSo.cjs');
+var sessionLock = require('./sessionLock-y9rnA4LK.cjs');
 var node_crypto = require('node:crypto');
-var api = require('./api-CgundNNX.cjs');
-var logger = require('./logger-CS0mw3fa.cjs');
-var _package = require('./package-BwMrPwqH.cjs');
-var persistence = require('./persistence-yKTH3-5X.cjs');
-var createSessionMetadata = require('./createSessionMetadata-BJxEnM-o.cjs');
-var index = require('./index-DA7yINuk.cjs');
-var configuration = require('./configuration-BSYpcPwE.cjs');
-var controlClient = require('./controlClient-Bcwv3D21.cjs');
-var machineMetadata = require('./machineMetadata-DyDbODYd.cjs');
+var api = require('./api-CQnLOqRS.cjs');
+var logger = require('./logger-7ucWm9wp.cjs');
+var _package = require('./package-D1A-8ZJy.cjs');
+var persistence = require('./persistence-i0nQMLlk.cjs');
+var createSessionMetadata = require('./createSessionMetadata-EX1eAlHx.cjs');
+var index = require('./index-DJ-oV52i.cjs');
+var configuration = require('./configuration-UsI0sxEv.cjs');
+var controlClient = require('./controlClient-BXktrQ4z.cjs');
+var machineMetadata = require('./machineMetadata-lMPtpF16.cjs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
 var path = require('node:path');
 var permissionMode = require('./permissionMode-CrV-XuMs.cjs');
 var authRelay = require('./authRelay-BdYkC1Po.cjs');
 var promises = require('node:fs/promises');
 var defaultPermissionMode = require('./defaultPermissionMode-CxmTXUQR.cjs');
-var attachmentContent = require('./attachmentContent-DpiTJZb4.cjs');
+var attachmentContent = require('./attachmentContent-GHOk6Muq.cjs');
 var startupPlan = require('./startupPlan-BLMbfQIH.cjs');
 require('node:fs');
 require('axios');
 require('node:events');
 require('socket.io-client');
-require('./attachmentLimits-CzVrqgLR.cjs');
+require('./attachmentLimits-DzlBPyJP.cjs');
 require('zod');
 require('./limits-C-a7gr04.cjs');
-require('./time-DCuTyook.cjs');
-require('./lidState-BeDfxxEX.cjs');
+require('./time-CLwVAz6s.cjs');
+require('./lidState-Ds-6ytZV.cjs');
 require('os');
 require('child_process');
-require('./registerCommonHandlers-DskirN-_.cjs');
+require('./registerCommonHandlers-CMROPdJz.cjs');
 require('util');
 require('fs/promises');
 require('crypto');
 require('path');
 require('cross-spawn');
 require('@paralleldrive/cuid2');
-require('./sync-DccIKZ5_.cjs');
+require('./sync-Dj92ZJ8Y.cjs');
 require('./backgroundTaskActivity-CBvUdj39.cjs');
 require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
 require('node:util');
 require('./detectCLI-DR9ZaN6B.cjs');
 require('fs');
-require('./localHappyAgentAuth-D6rFhaoc.cjs');
+require('./localHappyAgentAuth-l0Na-5Ys.cjs');
 require('tweetnacl');
 require('url');
 
 const DEFAULT_CLAUDE_MODEL = void 0;
 const DEFAULT_CLAUDE_EFFORT = void 0;
+const importRunClaudeDeps = () => Promise.resolve().then(function () { return require('./runClaudeDeps-DW-8lnHv.cjs'); });
 async function runClaude(credentials, options = {}) {
   logger.logger.debug(`[CLAUDE] ===== CLAUDE MODE STARTING =====`);
   logger.logger.debug(`[CLAUDE] This is the Claude agent, NOT Gemini`);
   options = { ...options, claudeEnvVars: { ...options.claudeEnvVars, HAPPY_MANAGED: "1" } };
+  const prewarmSpawnEnv = {};
+  for (const key of ["HAPPY_CLAUDE_AUTH_STATUS", "HAPPY_FIRST_MESSAGE_FROM_CLI"]) {
+    prewarmSpawnEnv[key] = process.env[key];
+    delete process.env[key];
+  }
   const workingDirectory = process.cwd();
   const isAssistantVariant = process.env.HAPPY_SESSION_VARIANT === "assistant";
   if (isAssistantVariant) {
     try {
-      const { bootstrapAssistantHome } = await Promise.resolve().then(function () { return require('./bootstrap-B5G1TijC.cjs'); });
+      const { bootstrapAssistantHome } = await Promise.resolve().then(function () { return require('./bootstrap-DvZjEa9_.cjs'); });
       await bootstrapAssistantHome();
     } catch (error) {
       logger.logger.debug("[START] Assistant home bootstrap failed:", error);
@@ -70,9 +76,15 @@ async function runClaude(credentials, options = {}) {
   if (options.startedBy === "daemon" && options.startingMode === "local") {
     throw new Error("Daemon-spawned sessions cannot use local/interactive mode. Use --happy-starting-mode remote or spawn sessions directly from terminal.");
   }
-  const depsLoad = Promise.resolve().then(function () { return require('./runClaudeDeps-DOzEBMls.cjs'); });
-  depsLoad.catch(() => {
-  });
+  let depsLoadPromise = null;
+  const loadDeps = () => {
+    if (!depsLoadPromise) {
+      depsLoadPromise = importRunClaudeDeps();
+      depsLoadPromise.catch(() => {
+      });
+    }
+    return depsLoadPromise;
+  };
   const reconnectRequested = Boolean(
     process.env.HAPPY_RECONNECT_SESSION_ID && process.env.HAPPY_RECONNECT_ENCRYPTION_KEY && process.env.HAPPY_RECONNECT_ENCRYPTION_VARIANT
   );
@@ -171,8 +183,8 @@ async function runClaude(credentials, options = {}) {
   }
   if (!response) {
     let offlineSessionId = null;
-    const { claudeLocal } = await Promise.resolve().then(function () { return require('./claudeLocal-CRGG4Pea.cjs'); });
-    const { createSessionScanner: createSessionScanner2 } = await depsLoad;
+    const { claudeLocal } = await Promise.resolve().then(function () { return require('./claudeLocal-Bpw-u9et.cjs'); });
+    const { createSessionScanner: createSessionScanner2 } = await loadDeps();
     const reconnection = api.startOfflineReconnection({
       serverUrl: configuration.configuration.serverUrl,
       onReconnected: async () => {
@@ -247,12 +259,13 @@ async function runClaude(credentials, options = {}) {
   } catch (error) {
     logger.logger.debug("[START] Failed to report to daemon (may not be running):", error);
   }
+  loadDeps();
   if (!startupPlan$1.registerMachine) {
     void Promise.resolve().then(() => api$1.getOrCreateMachine({ machineId, metadata: machineMetadata.getInitialMachineMetadata() })).catch((error) => logger.logger.debug("[START] Background machine registration failed:", error));
   }
   let deps;
   try {
-    deps = await depsLoad;
+    deps = await loadDeps();
   } catch (error) {
     logger.logger.warn(`[START] Failed to load the Claude runner modules for session ${response.id}; marking it offline and exiting: ${error instanceof Error ? error.message : String(error)}`);
     try {
@@ -293,7 +306,21 @@ async function runClaude(credentials, options = {}) {
     FileRateLimiter,
     createSelfReportState,
     withAssistantDenylist,
-    contentLogMetadata
+    contentLogMetadata,
+    resolveMessageMode,
+    claudePrewarmEligibility,
+    claudePrewarmSessionEligibility,
+    prewarmCacheFile,
+    readPrewarmCache,
+    writePrewarmCache,
+    prewarmPredictionMeta,
+    evaluatePrewarmPrediction,
+    acquirePrewarmSlot,
+    prewarmSlotDir,
+    PrewarmHookGate,
+    createClaudePrewarmLease,
+    disposeAllClaudePrewarms,
+    formatPrewarmLine
   } = deps;
   logger.logger.debugLargeJson("[START] Happy process started", getEnvironmentInfo());
   const session = earlySession ?? api$1.sessionSyncClient(response, reconnectSeeded ? { initialSeq: response.seq } : void 0);
@@ -412,10 +439,21 @@ async function runClaude(credentials, options = {}) {
   const happyServer = await startHappyServer(session, { assistant: isAssistantVariant, selfReportState: boardSelfReport });
   logger.logger.debug(`[START] Happy MCP server started at ${happyServer.url}`);
   let currentSession = null;
+  const prewarmHookGate = new PrewarmHookGate();
+  let scannerAnnouncedSessionId = null;
+  const announceSessionToScanner = (sessionId) => {
+    if (sessionId === scannerAnnouncedSessionId) return;
+    scannerAnnouncedSessionId = sessionId;
+    void Promise.resolve(remoteScanner.onNewSession(sessionId, { treatExistingAsProcessed: true })).catch((error) => logger.logger.debug("[START] remote scanner onNewSession failed:", error));
+  };
   const hookServer = await startHookServer({
-    onSessionHook: (sessionId, data) => {
+    onSessionHook: (sessionId, data, hookMeta) => {
+      if (!prewarmHookGate.accepts(hookMeta?.source)) {
+        logger.logger.debug(`[START] Session hook from an unadopted warm Claude process ignored (${hookMeta?.source})`);
+        return;
+      }
       logger.logger.debug(`[START] Session hook received: ${sessionId}`, contentLogMetadata(data));
-      remoteScanner.onNewSession(sessionId, { treatExistingAsProcessed: true });
+      announceSessionToScanner(sessionId);
       if (currentSession) {
         const previousSessionId = currentSession.sessionId;
         if (previousSessionId !== sessionId) {
@@ -511,6 +549,94 @@ async function runClaude(credentials, options = {}) {
     currentEffort = DEFAULT_CLAUDE_EFFORT;
     logger.logger.debug("[loop] Reset current mode defaults after abort");
   };
+  const currentModeState = () => ({
+    permissionMode: currentPermissionMode,
+    model: currentModel,
+    fallbackModel: currentFallbackModel,
+    customSystemPrompt: currentCustomSystemPrompt,
+    appendSystemPrompt: currentAppendSystemPrompt,
+    allowedTools: currentAllowedTools,
+    disallowedTools: currentDisallowedTools,
+    effort: currentEffort
+  });
+  const prewarmCachePath = prewarmCacheFile(configuration.configuration.happyHomeDir);
+  let prewarmCache = readPrewarmCache(prewarmCachePath);
+  const prewarmSessionInput = {
+    env: { ...process.env, ...prewarmSpawnEnv },
+    startedBy: options.startedBy,
+    startingMode: options.startingMode,
+    claudeArgs: options.claudeArgs,
+    setting: settings?.claudePrewarm
+  };
+  const prewarmCtx = () => ({ sandboxEnabled, isAssistantVariant, staleModeSnapshot: false });
+  const predictFirstMessageMode = () => prewarmCache ? resolveMessageMode(currentModeState(), prewarmPredictionMeta(prewarmCache), prewarmCtx()).mode : null;
+  let firstMessageScored = false;
+  const scoreFirstMessage = (meta, predicted, actual) => {
+    if (firstMessageScored) return;
+    firstMessageScored = true;
+    if (meta?.sentFrom !== "web") return;
+    if (!claudePrewarmSessionEligibility({ ...prewarmSessionInput, env: { ...process.env, ...prewarmSpawnEnv } }).eligible) return;
+    const { outcome, next } = evaluatePrewarmPrediction({ predicted, actual, meta, previous: prewarmCache });
+    logger.logger.debug(`[CLAUDE PREWARM] prediction ${outcome}${next ? ` consecutiveMisses=${next.consecutiveMisses}` : ""}`);
+    if (next && writePrewarmCache(prewarmCachePath, next)) prewarmCache = next;
+  };
+  let userMessageSeen = false;
+  const prewarmTagFiles = /* @__PURE__ */ new Set();
+  const createPrewarm = () => {
+    const eligibility = claudePrewarmEligibility({
+      ...prewarmSessionInput,
+      env: { ...process.env, ...prewarmSpawnEnv },
+      cache: prewarmCache
+    });
+    if (!eligibility.eligible) {
+      logger.logger.debug(formatPrewarmLine("skipped", eligibility.reason));
+      return null;
+    }
+    if (userMessageSeen) {
+      logger.logger.debug(formatPrewarmLine("skipped", "message-already-received"));
+      return null;
+    }
+    const slot = acquirePrewarmSlot(prewarmSlotDir(configuration.configuration.happyHomeDir));
+    if (!slot) {
+      logger.logger.debug(formatPrewarmLine("skipped", "concurrency-limit"));
+      return null;
+    }
+    const predicted = predictFirstMessageMode();
+    if (!predicted) {
+      slot.release();
+      return null;
+    }
+    const tag = prewarmHookGate.newTag();
+    let tagHookSettingsPath;
+    try {
+      tagHookSettingsPath = generateHookSettingsFile(hookServer.port, tag);
+    } catch (error) {
+      slot.release();
+      logger.logger.debug(formatPrewarmLine("skipped", "hook-settings"));
+      return null;
+    }
+    prewarmTagFiles.add(tagHookSettingsPath);
+    return createClaudePrewarmLease({
+      mode: predicted,
+      hookSettingsPath: tagHookSettingsPath,
+      tag,
+      gate: prewarmHookGate,
+      slot,
+      // Only removed on discard: an adopted process keeps reading its
+      // settings file (later SessionStart events, e.g. /compact); it goes
+      // with the other hook files at exit.
+      cleanupHookSettings: () => {
+        cleanupHookSettingsFile(tagHookSettingsPath);
+        prewarmTagFiles.delete(tagHookSettingsPath);
+      },
+      log: (line) => logger.logger.debug(line)
+    });
+  };
+  const cleanupPrewarm = () => {
+    disposeAllClaudePrewarms("shutdown");
+    for (const file of prewarmTagFiles) cleanupHookSettingsFile(file);
+    prewarmTagFiles.clear();
+  };
   session.onFileEvent((fileEvent) => {
     const ev = fileEvent.content.data.ev;
     logger.logger.debug(`[loop] File event received: ${ev.name} (${ev.size} bytes, ref: ${ev.ref})`);
@@ -531,112 +657,42 @@ async function runClaude(credentials, options = {}) {
     session.trackAttachmentDownload(downloadPromise);
   });
   session.onUserMessage(async (message) => {
+    userMessageSeen = true;
     if (message?.content?.text) {
       titleGenerator.maybeGenerate(message.content.text);
       boardAnalyzer.noteUserMessage(message.content.text);
     }
     const attachmentsForThisMessage = await session.drainAttachmentsForUserMessage();
-    let messagePermissionMode = currentPermissionMode;
     const messageCreatedAt = message.createdAt;
     const staleModeSnapshot = message.meta?.permissionMode !== void 0 && typeof messageCreatedAt === "number" && messageCreatedAt < lastExplicitModeSwitchAt;
     if (staleModeSnapshot) {
       logger.logger.debug(`[loop] Ignoring stale meta.permissionMode=${message.meta?.permissionMode} (message ${messageCreatedAt} predates explicit switch ${lastExplicitModeSwitchAt}); keeping ${currentPermissionMode}`);
-    } else if (message.meta?.permissionMode) {
-      const previousPermissionMode = currentPermissionMode;
-      messagePermissionMode = permissionMode.resolveRemoteClaudePermissionMode(
-        currentPermissionMode,
-        message.meta.permissionMode,
-        sandboxEnabled
-      );
-      publishPermissionMode(messagePermissionMode);
-      const ignoredDefaultDowngrade = (previousPermissionMode === "bypassPermissions" || previousPermissionMode === "yolo") && message.meta.permissionMode === "default" && currentPermissionMode === previousPermissionMode;
-      if (ignoredDefaultDowngrade) {
-        logger.logger.debug(`[loop] Ignoring permission mode downgrade from ${previousPermissionMode} to default`);
-      } else {
-        logger.logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
-      }
-    } else {
-      logger.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.logger.debug(`[loop] Model updated from user message: ${messageModel || "reset to default"}`);
-    } else {
-      logger.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.logger.debug(`[loop] Custom system prompt updated from user message: ${messageCustomSystemPrompt ? "set" : "reset to none"}`);
-    } else {
-      logger.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.logger.debug(`[loop] Fallback model updated from user message: ${messageFallbackModel || "reset to none"}`);
-    } else {
-      logger.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.logger.debug(`[loop] Append system prompt updated from user message: ${messageAppendSystemPrompt ? "set" : "reset to none"}`);
-    } else {
-      logger.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.logger.debug(`[loop] Allowed tools updated from user message: ${messageAllowedTools ? messageAllowedTools.join(", ") : "reset to none"}`);
-    } else {
-      logger.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 = withAssistantDenylist(message.meta.disallowedTools || void 0, isAssistantVariant);
-      currentDisallowedTools = messageDisallowedTools;
-      logger.logger.debug(`[loop] Disallowed tools updated from user message: ${messageDisallowedTools ? messageDisallowedTools.join(", ") : "reset to none"}`);
-    } else {
-      logger.logger.debug(`[loop] User message received with no disallowed tools override, using current: ${currentDisallowedTools ? currentDisallowedTools.join(", ") : "none"}`);
-    }
-    let messageEffort = currentEffort;
-    const VALID_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
-    if (message.meta?.hasOwnProperty("effort")) {
-      const incoming = message.meta.effort;
-      if (incoming === null || incoming === void 0) {
-        messageEffort = void 0;
-        currentEffort = void 0;
-        logger.logger.debug(`[loop] Effort reset to default`);
-      } else if (typeof incoming === "string" && VALID_EFFORTS.has(incoming)) {
-        messageEffort = incoming;
-        currentEffort = messageEffort;
-        logger.logger.debug(`[loop] Effort updated from user message: ${messageEffort}`);
-      } else {
-        logger.logger.debug(`[loop] Ignoring invalid effort from user message: ${String(incoming)}`);
-      }
-    } else {
-      logger.logger.debug(`[loop] User message received with no effort override, using current: ${currentEffort ?? "default"}`);
     }
+    const previousPermissionMode = currentPermissionMode;
+    const predictedFirstMode = firstMessageScored ? null : predictFirstMessageMode();
+    const resolved = resolveMessageMode(currentModeState(), message.meta, { sandboxEnabled, isAssistantVariant, staleModeSnapshot });
+    if ("publishPermissionMode" in resolved) {
+      publishPermissionMode(resolved.publishPermissionMode);
+      const ignoredDefaultDowngrade = (previousPermissionMode === "bypassPermissions" || previousPermissionMode === "yolo") && message.meta?.permissionMode === "default" && currentPermissionMode === previousPermissionMode;
+      logger.logger.debug(ignoredDefaultDowngrade ? `[loop] Ignoring permission mode downgrade from ${previousPermissionMode} to default` : `[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
+    }
+    currentModel = resolved.next.model;
+    currentFallbackModel = resolved.next.fallbackModel;
+    currentCustomSystemPrompt = resolved.next.customSystemPrompt;
+    currentAppendSystemPrompt = resolved.next.appendSystemPrompt;
+    currentAllowedTools = resolved.next.allowedTools;
+    currentDisallowedTools = resolved.next.disallowedTools;
+    currentEffort = resolved.next.effort;
+    if (resolved.ignoredEffort !== void 0) {
+      logger.logger.debug(`[loop] Ignoring invalid effort from user message: ${resolved.ignoredEffort}`);
+    }
+    logger.logger.debug(`[loop] Message mode: permission=${resolved.mode.permissionMode} model=${resolved.mode.model || "default"} effort=${resolved.mode.effort ?? "default"} appendSystemPrompt=${resolved.mode.appendSystemPrompt ? "set" : "none"} customSystemPrompt=${resolved.mode.customSystemPrompt ? "set" : "none"}`);
+    scoreFirstMessage(message.meta, predictedFirstMode, resolved.mode);
+    const resolvedMode = resolved.mode;
     const specialCommand = parseSpecialCommand(message.content.text);
     if (specialCommand.type === "compact") {
       logger.logger.debug("[start] Detected /compact command");
-      const enhancedMode2 = {
-        permissionMode: messagePermissionMode || "default",
-        model: messageModel,
-        fallbackModel: messageFallbackModel,
-        customSystemPrompt: messageCustomSystemPrompt,
-        appendSystemPrompt: messageAppendSystemPrompt,
-        allowedTools: messageAllowedTools,
-        disallowedTools: messageDisallowedTools,
-        effort: messageEffort
-      };
+      const enhancedMode2 = resolvedMode;
       messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2, attachmentsForThisMessage, message.localKey);
       logger.logger.debug("[start] /compact command pushed to queue:", {
         ...contentLogMetadata(message.content.text),
@@ -647,16 +703,7 @@ async function runClaude(credentials, options = {}) {
     }
     if (specialCommand.type === "clear") {
       logger.logger.debug("[start] Detected /clear command");
-      const enhancedMode2 = {
-        permissionMode: messagePermissionMode || "default",
-        model: messageModel,
-        fallbackModel: messageFallbackModel,
-        customSystemPrompt: messageCustomSystemPrompt,
-        appendSystemPrompt: messageAppendSystemPrompt,
-        allowedTools: messageAllowedTools,
-        disallowedTools: messageDisallowedTools,
-        effort: messageEffort
-      };
+      const enhancedMode2 = resolvedMode;
       messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2, attachmentsForThisMessage, message.localKey);
       logger.logger.debug("[start] /clear command pushed to queue:", {
         ...contentLogMetadata(message.content.text),
@@ -703,16 +750,7 @@ async function runClaude(credentials, options = {}) {
         return;
       }
     }
-    const enhancedMode = {
-      permissionMode: messagePermissionMode || "default",
-      model: messageModel,
-      fallbackModel: messageFallbackModel,
-      customSystemPrompt: messageCustomSystemPrompt,
-      appendSystemPrompt: messageAppendSystemPrompt,
-      allowedTools: messageAllowedTools,
-      disallowedTools: messageDisallowedTools,
-      effort: messageEffort
-    };
+    const enhancedMode = resolvedMode;
     if (message.meta?.delivery === "steer" && currentRunMode === "remote") {
       const accepted = await currentSession?.trySteer({
         message: message.content.text,
@@ -744,6 +782,7 @@ async function runClaude(credentials, options = {}) {
     }
     logger.logger.debug(`[START] Received termination signal, cleaning up (archive=${intent === "archive"})...`);
     promptQueueDrain.close();
+    cleanupPrewarm();
     try {
       if (session) {
         currentSession?.cleanup();
@@ -809,7 +848,11 @@ async function runClaude(credentials, options = {}) {
     },
     onSessionReady: (sessionInstance) => {
       currentSession = sessionInstance;
+      sessionInstance.addSessionFoundCallback?.(announceSessionToScanner);
     },
+    // B-515: lease for a warm Claude process, taken once by the first
+    // remote launch (null when not eligible).
+    claudePrewarm: createPrewarm,
     // B-355: remember exactly what the SDK is about to write to the Claude
     // transcript, so the JSONL scanner below recognises it as ours.
     onPromptFinalized: recordAppPrompt,
@@ -834,6 +877,7 @@ async function runClaude(credentials, options = {}) {
     jsRuntime: options.jsRuntime
   });
   currentSession?.cleanup();
+  cleanupPrewarm();
   session.sendSessionDeath();
   logger.logger.debug("Waiting for socket to flush...");
   await session.flush();