very-happy-cli 0.2.160 → 0.2.162

package/dist/{runClaude-Ba01qT-u.mjs → runClaude-WDBWRtnF.mjs}

@@ -1,63 +1,69 @@
 import os from 'node:os';
-import { c as claimSessionOrExit, a as applyServerSnapshot, w as withoutServerSnapshot, m as mergeReconnectMetadata } from './sessionLock-D-EG2CfG.mjs';
+import { c as claimSessionOrExit, a as applyServerSnapshot, w as withoutServerSnapshot, m as mergeReconnectMetadata } from './sessionLock-CfLqJfeI.mjs';
 import { randomUUID } from 'node:crypto';
-import { c as connectionState, A as ApiClient, s as startOfflineReconnection } from './api-CLMUr-SX.mjs';
-import { l as logger } from './logger-6HYUEXNk.mjs';
-import { p as packageJson } from './package-BhaKlnxz.mjs';
-import { readSettings } from './persistence-HGW_ZVs9.mjs';
-import { s as spawnOriginTags } from './createSessionMetadata-CVVkGjxV.mjs';
-import { P as PROMPT_QUEUE_CAPABILITY } from './index-qdS1friN.mjs';
-import { c as configuration } from './configuration-RfeNjFmd.mjs';
-import { n as notifyDaemonSessionStarted } from './controlClient-BGbDcgWS.mjs';
-import { g as getInitialMachineMetadata } from './machineMetadata-oOzBfDfs.mjs';
+import { c as connectionState, A as ApiClient, s as startOfflineReconnection } from './api-D57dsd6_.mjs';
+import { l as logger } from './logger-CGE4C8ho.mjs';
+import { p as packageJson } from './package-DQsvY1XN.mjs';
+import { readSettings } from './persistence-Cw8aLoyL.mjs';
+import { s as spawnOriginTags } from './createSessionMetadata-Dyg33ZlU.mjs';
+import { P as PROMPT_QUEUE_CAPABILITY } from './index-BBg9j0XK.mjs';
+import { c as configuration } from './configuration-A5gW_0GE.mjs';
+import { n as notifyDaemonSessionStarted } from './controlClient-CYzHrh3e.mjs';
+import { g as getInitialMachineMetadata } from './machineMetadata-ue1nkowa.mjs';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { resolve, join } from 'node:path';
-import { a as applySandboxPermissionPolicy, r as resolveInitialClaudePermissionMode, m as mapToClaudeMode, b as resolveRemoteClaudePermissionMode, c as reconcilePublishedPermissionMode } from './permissionMode-Cr5JCbB7.mjs';
+import { a as applySandboxPermissionPolicy, r as resolveInitialClaudePermissionMode, m as mapToClaudeMode, b as reconcilePublishedPermissionMode } from './permissionMode-CH4FoZfU.mjs';
 import { d as decodeBase64, e as encodeBase64 } from './authRelay-DSAvg1uv.mjs';
 import { readFile } from 'node:fs/promises';
 import { D as DEFAULT_CLAUDE_PERMISSION_MODE } from './defaultPermissionMode-BnxJPVHT.mjs';
-import { C as CLAUDE_ATTACHMENT_KINDS, s as stripAttachmentManifest } from './attachmentContent-_kxRznNf.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, s as stripAttachmentManifest } from './attachmentContent-s1xPha4Q.mjs';
 import { p as planClaudeStartup } from './startupPlan-DFMyNgAs.mjs';
 import 'node:fs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import './attachmentLimits-yba1uHFO.mjs';
+import './attachmentLimits-D5pgmASK.mjs';
 import 'zod';
 import './limits-DIo7rEBR.mjs';
-import './time-D0XyHOid.mjs';
-import './lidState-CeEt442o.mjs';
+import './time-CVvxdEDh.mjs';
+import './lidState-CigXWxhe.mjs';
 import 'os';
 import 'child_process';
-import './registerCommonHandlers-Ccvsz7Ou.mjs';
+import './registerCommonHandlers-Ckv5boQI.mjs';
 import 'util';
 import 'fs/promises';
 import 'crypto';
 import 'path';
 import 'cross-spawn';
 import '@paralleldrive/cuid2';
-import './sync-C8gyQFMc.mjs';
+import './sync-BpLasLu2.mjs';
 import './backgroundTaskActivity-8PdPxrvy.mjs';
 import './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 import 'node:util';
 import './detectCLI-CSGMlV51.mjs';
 import 'fs';
-import './localHappyAgentAuth-C-HQyiv6.mjs';
+import './localHappyAgentAuth-CaCyKzYp.mjs';
 import 'tweetnacl';
 import 'url';
 
 const DEFAULT_CLAUDE_MODEL = void 0;
 const DEFAULT_CLAUDE_EFFORT = void 0;
+const importRunClaudeDeps = () => import('./runClaudeDeps-QaEx8y5r.mjs');
 async function runClaude(credentials, options = {}) {
   logger.debug(`[CLAUDE] ===== CLAUDE MODE STARTING =====`);
   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 import('./bootstrap-hxXPCFMx.mjs');
+      const { bootstrapAssistantHome } = await import('./bootstrap-BKmsYSwh.mjs');
       await bootstrapAssistantHome();
     } catch (error) {
       logger.debug("[START] Assistant home bootstrap failed:", error);
@@ -68,9 +74,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 = import('./runClaudeDeps-DOt79DjU.mjs');
-  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
   );
@@ -169,8 +181,8 @@ async function runClaude(credentials, options = {}) {
   }
   if (!response) {
     let offlineSessionId = null;
-    const { claudeLocal } = await import('./claudeLocal-BaY4fZKi.mjs');
-    const { createSessionScanner: createSessionScanner2 } = await depsLoad;
+    const { claudeLocal } = await import('./claudeLocal-dhdlcQ6F.mjs');
+    const { createSessionScanner: createSessionScanner2 } = await loadDeps();
     const reconnection = startOfflineReconnection({
       serverUrl: configuration.serverUrl,
       onReconnected: async () => {
@@ -245,12 +257,13 @@ async function runClaude(credentials, options = {}) {
   } catch (error) {
     logger.debug("[START] Failed to report to daemon (may not be running):", error);
   }
+  loadDeps();
   if (!startupPlan.registerMachine) {
     void Promise.resolve().then(() => api.getOrCreateMachine({ machineId, metadata: getInitialMachineMetadata() })).catch((error) => logger.debug("[START] Background machine registration failed:", error));
   }
   let deps;
   try {
-    deps = await depsLoad;
+    deps = await loadDeps();
   } catch (error) {
     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 {
@@ -291,7 +304,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.debugLargeJson("[START] Happy process started", getEnvironmentInfo());
   const session = earlySession ?? api.sessionSyncClient(response, reconnectSeeded ? { initialSeq: response.seq } : void 0);
@@ -410,10 +437,21 @@ async function runClaude(credentials, options = {}) {
   const happyServer = await startHappyServer(session, { assistant: isAssistantVariant, selfReportState: boardSelfReport });
   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.debug("[START] remote scanner onNewSession failed:", error));
+  };
   const hookServer = await startHookServer({
-    onSessionHook: (sessionId, data) => {
+    onSessionHook: (sessionId, data, hookMeta) => {
+      if (!prewarmHookGate.accepts(hookMeta?.source)) {
+        logger.debug(`[START] Session hook from an unadopted warm Claude process ignored (${hookMeta?.source})`);
+        return;
+      }
       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) {
@@ -509,6 +547,94 @@ async function runClaude(credentials, options = {}) {
     currentEffort = DEFAULT_CLAUDE_EFFORT;
     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.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.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.debug(formatPrewarmLine("skipped", eligibility.reason));
+      return null;
+    }
+    if (userMessageSeen) {
+      logger.debug(formatPrewarmLine("skipped", "message-already-received"));
+      return null;
+    }
+    const slot = acquirePrewarmSlot(prewarmSlotDir(configuration.happyHomeDir));
+    if (!slot) {
+      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.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.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.debug(`[loop] File event received: ${ev.name} (${ev.size} bytes, ref: ${ev.ref})`);
@@ -529,112 +655,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.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 = resolveRemoteClaudePermissionMode(
-        currentPermissionMode,
-        message.meta.permissionMode,
-        sandboxEnabled
-      );
-      publishPermissionMode(messagePermissionMode);
-      const ignoredDefaultDowngrade = (previousPermissionMode === "bypassPermissions" || previousPermissionMode === "yolo") && message.meta.permissionMode === "default" && currentPermissionMode === previousPermissionMode;
-      if (ignoredDefaultDowngrade) {
-        logger.debug(`[loop] Ignoring permission mode downgrade from ${previousPermissionMode} to default`);
-      } else {
-        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 = withAssistantDenylist(message.meta.disallowedTools || void 0, isAssistantVariant);
-      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"}`);
-    }
-    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.debug(`[loop] Effort reset to default`);
-      } else if (typeof incoming === "string" && VALID_EFFORTS.has(incoming)) {
-        messageEffort = incoming;
-        currentEffort = messageEffort;
-        logger.debug(`[loop] Effort updated from user message: ${messageEffort}`);
-      } else {
-        logger.debug(`[loop] Ignoring invalid effort from user message: ${String(incoming)}`);
-      }
-    } else {
-      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.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.debug(`[loop] Ignoring invalid effort from user message: ${resolved.ignoredEffort}`);
+    }
+    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.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.debug("[start] /compact command pushed to queue:", {
         ...contentLogMetadata(message.content.text),
@@ -645,16 +701,7 @@ async function runClaude(credentials, options = {}) {
     }
     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,
-        effort: messageEffort
-      };
+      const enhancedMode2 = resolvedMode;
       messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2, attachmentsForThisMessage, message.localKey);
       logger.debug("[start] /clear command pushed to queue:", {
         ...contentLogMetadata(message.content.text),
@@ -701,16 +748,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,
@@ -742,6 +780,7 @@ async function runClaude(credentials, options = {}) {
     }
     logger.debug(`[START] Received termination signal, cleaning up (archive=${intent === "archive"})...`);
     promptQueueDrain.close();
+    cleanupPrewarm();
     try {
       if (session) {
         currentSession?.cleanup();
@@ -807,7 +846,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,
@@ -832,6 +875,7 @@ async function runClaude(credentials, options = {}) {
     jsRuntime: options.jsRuntime
   });
   currentSession?.cleanup();
+  cleanupPrewarm();
   session.sendSessionDeath();
   logger.debug("Waiting for socket to flush...");
   await session.flush();