very-happy-cli 0.2.160 → 0.2.162

package/dist/{runClaudeDeps-DOzEBMls.cjs → runClaudeDeps-DW-8lnHv.cjs}

@@ -1,46 +1,48 @@
 'use strict';
 
-var logger = require('./logger-CS0mw3fa.cjs');
-var controlClient = require('./controlClient-Bcwv3D21.cjs');
+var logger = require('./logger-7ucWm9wp.cjs');
+var controlClient = require('./controlClient-BXktrQ4z.cjs');
 var backgroundTaskActivity = require('./backgroundTaskActivity-CBvUdj39.cjs');
 var node_crypto = require('node:crypto');
 var messageBuffer = require('./messageBuffer-fJMH6uY8.cjs');
 var index = require('./index-D3kI0hDR.cjs');
 var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
 var permissionMode = require('./permissionMode-CrV-XuMs.cjs');
-var systemPrompt = require('./systemPrompt-BwTPWfMu.cjs');
+var systemPrompt = require('./systemPrompt-CyEz_IfR.cjs');
 var path$1 = require('node:path');
 var specialCommands = require('./specialCommands-DSsTeRej.cjs');
 require('axios');
 require('node:events');
 require('socket.io-client');
-var attachmentLimits = require('./attachmentLimits-CzVrqgLR.cjs');
+var attachmentLimits = require('./attachmentLimits-DzlBPyJP.cjs');
 require('tweetnacl');
-var configuration = require('./configuration-BSYpcPwE.cjs');
-require('./index-DA7yINuk.cjs');
-require('./registerCommonHandlers-DskirN-_.cjs');
+var configuration = require('./configuration-UsI0sxEv.cjs');
+require('./index-DJ-oV52i.cjs');
+require('./registerCommonHandlers-CMROPdJz.cjs');
 require('os');
 require('child_process');
 require('@paralleldrive/cuid2');
-require('./persistence-yKTH3-5X.cjs');
+require('./persistence-i0nQMLlk.cjs');
 var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
 var types = require('./types-CRS-srZK.cjs');
 var path = require('./path-B7zW-WwE.cjs');
 var fs = require('fs/promises');
-var time = require('./time-DCuTyook.cjs');
-var sessionScanner = require('./sessionScanner-BOrGjMXL.cjs');
+var time = require('./time-CLwVAz6s.cjs');
+var node_fs = require('node:fs');
+var deterministicJson = require('./deterministicJson-eha_oMZ2.cjs');
+var sessionScanner = require('./sessionScanner-aLEv7mD3.cjs');
 var node_child_process = require('node:child_process');
-var streamRelay = require('./streamRelay-BiKw59Cc.cjs');
-var attachmentContent = require('./attachmentContent-DpiTJZb4.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-DZeLXWcB.cjs');
-var deterministicJson = require('./deterministicJson-C5CYTVpm.cjs');
-var doctor = require('./doctor-D2YJ-Yn2.cjs');
+var streamRelay = require('./streamRelay-DnObXZZj.cjs');
+var attachmentContent = require('./attachmentContent-GHOk6Muq.cjs');
+var promises = require('node:fs/promises');
+var claudeSessionFork = require('./claudeSessionFork-D9-mANmu.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-CA9-oelM.cjs');
+var doctor = require('./doctor-DunLBgVi.cjs');
 var node_http = require('node:http');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
-var node_fs = require('node:fs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
-var titleGenerator = require('./titleGenerator-ChzMJsyg.cjs');
+var titleGenerator = require('./titleGenerator-FDpdizn7.cjs');
 var oneShotPrompts = require('./oneShotPrompts-CL0dip9C.cjs');
 require('node:util');
 require('./smallFastModel-D_uxGMo3.cjs');
@@ -48,34 +50,34 @@ require('./trimIdent-4gvk9Wk6.cjs');
 require('node:os');
 require('./agentGuidance-B5NATuFa.cjs');
 require('zod');
-require('./package-BwMrPwqH.cjs');
-require('node:fs/promises');
+require('./package-D1A-8ZJy.cjs');
 require('util');
 require('crypto');
 require('path');
 require('cross-spawn');
 require('./authRelay-BdYkC1Po.cjs');
-require('./sync-DccIKZ5_.cjs');
-require('./startFileWatcher-B4VsLgjD.cjs');
-require('./client-3Ac-O4pw.cjs');
-require('./context-DsDr6E2t.cjs');
-require('./sessionOps-Dn8z85h_.cjs');
+require('./client-DiBTHWNU.cjs');
+require('./context-0FjjA4vJ.cjs');
+require('./sessionOps-GsELm2PZ.cjs');
 require('./resources-JDPugcDq.cjs');
-require('./tools-Be3AoAwu.cjs');
-require('./tools-DQj0AeLk.cjs');
-require('./client-BPNbmtvO.cjs');
-require('./peerTools-BvKtHXj8.cjs');
+require('./tools-O5beDK-s.cjs');
+require('./tools-CGxq3I52.cjs');
+require('./client-CVQJWqjx.cjs');
+require('./peerTools-DLwNaEEV.cjs');
 require('./ids-B6ZC0HGt.cjs');
-require('./remoteSessionClient-B0LraSB9.cjs');
+require('./remoteSessionClient-DX9jHLeW.cjs');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 require('./limits-C-a7gr04.cjs');
-require('./assistantTools-BTqPnlFl.cjs');
+require('./assistantTools-CwESq24n.cjs');
 require('./terminals-B_bfC9c2.cjs');
 require('./terminalTitleSuggest-DhvRFX3H.cjs');
 require('./tmuxSocket-D-Xt6Vn-.cjs');
-require('./bootstrap-B5G1TijC.cjs');
+require('./bootstrap-DvZjEa9_.cjs');
 require('./previewPath-B0rBdhy1.cjs');
+require('./sync-Dj92ZJ8Y.cjs');
+require('./startFileWatcher-C2HC2_Dg.cjs');
+require('node:readline');
 require('./doctor-u46qYYKX.cjs');
 require('ps-list');
 require('./doctorReadiness-BCZGcN0a.cjs');
@@ -143,6 +145,20 @@ class Session {
   steerHandler = null;
   /** B-482: the live remote Query's in-process side-question entry; null between Queries and in local mode. */
   sideQuestionLive = null;
+  /** B-515: consumed by the first remote launch; later launches never prewarm. */
+  claudePrewarm = null;
+  /** Hand the prewarm lease to the first remote launch — once per process. */
+  takeClaudePrewarm = () => {
+    const factory = this.claudePrewarm;
+    this.claudePrewarm = null;
+    if (!factory || this.sessionId) return null;
+    try {
+      return factory();
+    } catch (error) {
+      logger.logger.debug("[Session] Claude prewarm setup failed:", error);
+      return null;
+    }
+  };
   /** Callbacks to be notified when session ID is found/changed */
   sessionFoundCallbacks = [];
   /** Keep alive interval reference for cleanup */
@@ -163,6 +179,7 @@ class Session {
     this._onAbort = opts.onAbort;
     this.hookSettingsPath = opts.hookSettingsPath;
     this.jsRuntime = opts.jsRuntime ?? "node";
+    this.claudePrewarm = opts.claudePrewarm ?? null;
     try {
       this.notificationProducer = opts.api.notificationProducer(
         opts.client.sessionId,
@@ -697,6 +714,285 @@ function modelSwitchFailureNotice(model, error) {
   return `\u26A0\uFE0F Could not switch to model "${name}" \u2014 continuing with the previous model. ${detail}`;
 }
 
+const SDK_TIMING_FIELDS = ["ttft_ms", "time_to_request_ms", "time_to_request_from_spawn_ms"];
+function delta(from, to) {
+  if (typeof from !== "number" || typeof to !== "number" || to < from) return "-";
+  return `${Math.round(to - from)}ms`;
+}
+function sdkField(result, key) {
+  if (!result || typeof result !== "object") return "-";
+  const value = result[key];
+  return typeof value === "number" && Number.isFinite(value) ? `${Math.round(value)}` : "-";
+}
+function formatClaudeTimingLine(input) {
+  const m = input.marks;
+  const sdk = SDK_TIMING_FIELDS.map((key) => `${key}=${sdkField(input.result, key)}`).join(",");
+  return [
+    "[CLAUDE TIMING]",
+    `turn=${input.turn}`,
+    `firstTurnOfProcess=${input.firstTurnOfProcess}`,
+    `pushed\u2192spawn=${delta(m.pushedAt, m.spawnAt)}`,
+    `spawn\u2192handshake=${delta(m.spawnAt, m.handshakeAt)}`,
+    `handshake\u2192init=${delta(m.handshakeAt, m.initAt)}`,
+    `init\u2192firstAssistant=${delta(m.initAt, m.firstAssistantAt)}`,
+    `pushed\u2192firstAssistant=${delta(m.pushedAt, m.firstAssistantAt)}`,
+    `sdk{${sdk}}`,
+    ...input.prewarm ? [`prewarm=${input.prewarm}`] : []
+  ].join(" ");
+}
+
+function claudeModeHash(mode) {
+  return deterministicJson.hashObject({
+    isPlan: mode.permissionMode === "plan",
+    fallbackModel: mode.fallbackModel,
+    customSystemPrompt: mode.customSystemPrompt,
+    appendSystemPrompt: mode.appendSystemPrompt,
+    allowedTools: mode.allowedTools,
+    disallowedTools: mode.disallowedTools,
+    effort: mode.effort
+  });
+}
+
+const CLAUDE_PREWARM_IDLE_MS = 15 * 60 * 1e3;
+const CLAUDE_PREWARM_MAX_CONCURRENT = 2;
+const CLAUDE_PREWARM_ADOPT_TIMEOUT_MS = 5e3;
+const PREWARM_HOOK_SOURCE_PREFIX = "prewarm-";
+const BAD_AUTH_STATUSES = /* @__PURE__ */ new Set(["not-logged-in", "error", "claude-missing"]);
+const RESUME_ARGS = /* @__PURE__ */ new Set(["--resume", "-r", "--continue", "-c", "--fork-session", "--session-id"]);
+const CLAUDE_PREWARM_MAX_CONSECUTIVE_MISSES = 5;
+function claudePrewarmSessionEligibility(input) {
+  const { env } = input;
+  const no = (reason) => ({ eligible: false, reason });
+  if (env.HAPPY_CLAUDE_PREWARM === "0") return no("env-off");
+  if (input.setting === "off") return no("setting-off");
+  if (input.startedBy !== "daemon") return no("not-daemon");
+  if (input.startingMode !== "remote") return no("not-remote");
+  if (env.HAPPY_RECONNECT_SESSION_ID) return no("reconnect");
+  if (env.HAPPY_FORK_CLAUDE_SESSION_ID || env.HAPPY_FORKED_FROM_SESSION_ID) return no("fork");
+  if (env.HAPPY_IMPORTED_FROM_CLAUDE_SESSION_ID) return no("import");
+  if (env.HAPPY_SESSION_VARIANT === "assistant") return no("assistant");
+  if (env.VH_TEAM_OPERATION_ID) return no("teams");
+  if (env.VH_AUTOMATION_RUN_ID) return no("automation");
+  if (env.HAPPY_SPAWNED_BY) return no("spawned-by");
+  if (env.HAPPY_FIRST_MESSAGE_FROM_CLI === "1") return no("cli-first-message");
+  if (input.claudeArgs?.some((arg) => RESUME_ARGS.has(arg))) return no("resume-args");
+  if (env.HAPPY_CLAUDE_AUTH_STATUS && BAD_AUTH_STATUSES.has(env.HAPPY_CLAUDE_AUTH_STATUS)) return no("claude-auth");
+  return { eligible: true };
+}
+function claudePrewarmEligibility(input) {
+  const session = claudePrewarmSessionEligibility(input);
+  if (!session.eligible) return session;
+  if (!input.cache?.appendSystemPrompt) return { eligible: false, reason: "no-cached-system-prompt" };
+  if (input.cache.consecutiveMisses >= CLAUDE_PREWARM_MAX_CONSECUTIVE_MISSES) return { eligible: false, reason: "recent-misses" };
+  return { eligible: true };
+}
+function prewarmCacheFile(happyHomeDir) {
+  return path$1.join(happyHomeDir, "claude-prewarm.json");
+}
+function readPrewarmCache(file) {
+  try {
+    const raw = JSON.parse(node_fs.readFileSync(file, "utf8"));
+    if (typeof raw?.appendSystemPrompt !== "string" || raw.appendSystemPrompt.length === 0) return null;
+    const misses = typeof raw.consecutiveMisses === "number" && Number.isFinite(raw.consecutiveMisses) && raw.consecutiveMisses > 0 ? Math.floor(raw.consecutiveMisses) : 0;
+    return {
+      appendSystemPrompt: raw.appendSystemPrompt,
+      ...typeof raw.effort === "string" || raw.effort === null ? { effort: raw.effort } : {},
+      consecutiveMisses: misses
+    };
+  } catch {
+    return null;
+  }
+}
+function writePrewarmCache(file, cache) {
+  try {
+    const tmp = `${file}.${process.pid}.tmp`;
+    node_fs.writeFileSync(tmp, JSON.stringify({ ...cache, updatedAt: Date.now() }), { mode: 384 });
+    node_fs.renameSync(tmp, file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function prewarmPredictionMeta(cache) {
+  return {
+    appendSystemPrompt: cache.appendSystemPrompt,
+    ...cache.effort !== void 0 ? { effort: cache.effort } : {}
+  };
+}
+function evaluatePrewarmPrediction(input) {
+  const outcome = input.predicted === null ? "no-prediction" : claudeModeHash(input.predicted) === claudeModeHash(input.actual) ? "hit" : "miss";
+  const append = input.meta?.appendSystemPrompt;
+  const misses = outcome === "miss" ? (input.previous?.consecutiveMisses ?? 0) + 1 : 0;
+  if (typeof append !== "string" || append.length === 0) {
+    return { outcome, next: input.previous ? { ...input.previous, consecutiveMisses: misses } : null };
+  }
+  const hasEffort = !!input.meta && Object.prototype.hasOwnProperty.call(input.meta, "effort");
+  return {
+    outcome,
+    next: {
+      appendSystemPrompt: append,
+      ...hasEffort ? { effort: input.meta.effort ?? null } : {},
+      consecutiveMisses: misses
+    }
+  };
+}
+function prewarmSlotDir(happyHomeDir) {
+  return path$1.join(happyHomeDir, "tmp", "claude-prewarm");
+}
+function acquirePrewarmSlot(dir, opts = {}) {
+  const max = opts.max ?? CLAUDE_PREWARM_MAX_CONCURRENT;
+  const pid = opts.pid ?? process.pid;
+  const isAlive = opts.isAlive ?? pidAlive;
+  const now = opts.now ?? Date.now();
+  const staleMs = opts.staleMs ?? CLAUDE_PREWARM_IDLE_MS + 6e4;
+  try {
+    node_fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  } catch {
+    return null;
+  }
+  for (let i = 0; i < max; i++) {
+    const path = path$1.join(dir, `slot-${i}.lock`);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        node_fs.writeFileSync(path, String(pid), { flag: "wx", mode: 384 });
+        let released = false;
+        return {
+          path,
+          release: () => {
+            if (released) return;
+            released = true;
+            try {
+              if (node_fs.readFileSync(path, "utf8").trim() === String(pid)) node_fs.unlinkSync(path);
+            } catch {
+            }
+          }
+        };
+      } catch (error) {
+        if (error?.code !== "EEXIST") return null;
+        if (!slotIsStale(path, { isAlive, now, staleMs }) || attempt > 0) break;
+        try {
+          node_fs.unlinkSync(path);
+        } catch {
+        }
+      }
+    }
+  }
+  return null;
+}
+function slotIsStale(path, opts) {
+  try {
+    const owner = Number(node_fs.readFileSync(path, "utf8").trim());
+    if (!Number.isInteger(owner) || owner <= 0 || !opts.isAlive(owner)) return true;
+    return opts.now - node_fs.statSync(path).mtimeMs > opts.staleMs;
+  } catch {
+    return !node_fs.existsSync(path);
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+class PrewarmHookGate {
+  next = 0;
+  adopted = /* @__PURE__ */ new Set();
+  newTag() {
+    return `${PREWARM_HOOK_SOURCE_PREFIX}${process.pid}-${this.next++}`;
+  }
+  adopt(tag) {
+    this.adopted.add(tag);
+  }
+  /** Untagged hooks (the ordinary per-process settings file) always pass. */
+  accepts(source) {
+    if (!source || !source.startsWith(PREWARM_HOOK_SOURCE_PREFIX)) return true;
+    return this.adopted.has(source);
+  }
+}
+function decideWarmAdoption(input) {
+  if (input.specialCommand === "clear") return { adopt: false, reason: "clear" };
+  if (input.specialCommand === "compact") return { adopt: false, reason: "compact" };
+  if (claudeModeHash(input.predicted) !== claudeModeHash(input.actual)) return { adopt: false, reason: "mode-mismatch" };
+  const warmPermission = permissionMode.mapToClaudeMode(input.predicted.permissionMode);
+  const wantedPermission = permissionMode.mapToClaudeMode(input.actual.permissionMode);
+  return {
+    adopt: true,
+    ...warmPermission !== wantedPermission ? { setPermissionMode: wantedPermission } : {},
+    switchModel: needsModelSwitch(input.predicted.model, input.actual.model)
+  };
+}
+function formatPrewarmLine(event, detail) {
+  if (event === "discarded" || event === "skipped") {
+    return `[CLAUDE PREWARM] ${event}(${typeof detail === "string" ? detail : "unknown"})`;
+  }
+  const fields = detail && typeof detail === "object" ? Object.entries(detail).filter(([, v]) => v !== void 0).map(([k, v]) => ` ${k}=${v}`).join("") : "";
+  return `[CLAUDE PREWARM] ${event}${fields}`;
+}
+const liveLeases = /* @__PURE__ */ new Set();
+let exitHookInstalled = false;
+function disposeAllClaudePrewarms(reason) {
+  for (const lease of [...liveLeases]) lease.discard(reason);
+}
+function createClaudePrewarmLease(input) {
+  let state = "warm";
+  let teardown = null;
+  const lease = {
+    mode: input.mode,
+    hookSettingsPath: input.hookSettingsPath,
+    tag: input.tag,
+    idleMs: input.idleMs ?? CLAUDE_PREWARM_IDLE_MS,
+    adoptTimeoutMs: input.adoptTimeoutMs ?? CLAUDE_PREWARM_ADOPT_TIMEOUT_MS,
+    adopt: () => {
+      if (state !== "warm") return;
+      state = "adopted";
+      teardown = null;
+      input.gate.adopt(input.tag);
+      input.slot.release();
+      liveLeases.delete(lease);
+    },
+    discard: (reason) => {
+      if (state !== "warm") return;
+      state = "closed";
+      const t = teardown;
+      teardown = null;
+      liveLeases.delete(lease);
+      try {
+        t?.(reason);
+      } catch {
+      }
+      input.slot.release();
+      input.cleanupHookSettings();
+      input.log(formatPrewarmLine("discarded", reason));
+    },
+    setTeardown: (next) => {
+      if (state === "warm") teardown = next;
+    }
+  };
+  liveLeases.add(lease);
+  if (!exitHookInstalled) {
+    exitHookInstalled = true;
+    process.once("exit", () => disposeAllClaudePrewarms("exit"));
+  }
+  return lease;
+}
+
+function withTimeout(promise, ms) {
+  promise.catch(() => {
+  });
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`timed out after ${ms}ms`)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+const PROMPT_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function promptUuid(uuid) {
+  return uuid && PROMPT_UUID_RE.test(uuid) ? { uuid } : {};
+}
 async function claudeRemote(opts) {
   let startFrom = opts.sessionId;
   if (opts.sessionId && !systemPrompt.claudeCheckSession(opts.sessionId, opts.path)) {
@@ -727,13 +1023,153 @@ async function claudeRemote(opts) {
       process.env[key] = value;
     });
   }
-  const initial = await opts.nextMessage();
+  let thinking = false;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  let callbackDepth = 0;
+  const guardCallback = (callback) => (async (...args) => {
+    callbackDepth++;
+    try {
+      return await callback(...args);
+    } finally {
+      setImmediate(() => {
+        callbackDepth--;
+      });
+    }
+  });
+  let mode = opts.prewarm?.mode ?? { permissionMode: "default" };
+  const buildSdkOptions = (creationMode, io) => {
+    const sdkOptions = {
+      cwd: opts.path,
+      resume: startFrom ?? void 0,
+      mcpServers: opts.mcpServers,
+      permissionMode: permissionMode.mapToClaudeMode(creationMode.permissionMode),
+      // This is only the SDK safety opt-in; permissionMode/canUseTool still
+      // enforce the selected policy. It must be enabled at Query creation so
+      // a later explicit live switch to bypassPermissions can succeed.
+      allowDangerouslySkipPermissions: true,
+      model: creationMode.model,
+      fallbackModel: creationMode.fallbackModel,
+      customSystemPrompt: creationMode.customSystemPrompt ? creationMode.customSystemPrompt + "\n\n" + systemPrompt.systemPrompt : void 0,
+      appendSystemPrompt: creationMode.appendSystemPrompt ? creationMode.appendSystemPrompt + "\n\n" + systemPrompt.systemPrompt : systemPrompt.systemPrompt,
+      allowedTools: creationMode.allowedTools ? creationMode.allowedTools.concat(opts.allowedTools) : opts.allowedTools,
+      additionalDirectories: opts.additionalDirectories,
+      disallowedTools: creationMode.disallowedTools,
+      effort: creationMode.effort,
+      canCallTool: (toolName, input, options) => opts.canCallTool(toolName, input, mode, options),
+      onElicitation: opts.onElicitation,
+      onUserDialog: opts.onUserDialog,
+      supportedDialogKinds: opts.onUserDialog ? ["refusal_fallback_prompt"] : void 0,
+      abort: io.abort,
+      settingsPath: io.settingsPath,
+      // B-309: token-level partials. Without this the SDK emits nothing
+      // between "turn started" and "entire assistant message", which is
+      // exactly why the web used to show a spinner where the terminal shows
+      // the model thinking out loud. The partials do NOT enter the
+      // transcript; they are split off below and relayed on a side channel.
+      // Only pay for them when someone is listening.
+      includePartialMessages: opts.onStreamFrame ? true : void 0
+    };
+    if (sdkOptions.canCallTool) sdkOptions.canCallTool = guardCallback(sdkOptions.canCallTool);
+    if (sdkOptions.onElicitation) sdkOptions.onElicitation = guardCallback(sdkOptions.onElicitation);
+    if (sdkOptions.onUserDialog) sdkOptions.onUserDialog = guardCallback(sdkOptions.onUserDialog);
+    return sdkOptions;
+  };
+  const discoverModels = async (q) => {
+    if (typeof q.supportedModels !== "function") return void 0;
+    return (await q.supportedModels()).map((model) => ({
+      code: model.value,
+      value: model.displayName,
+      description: model.description,
+      resolvedModel: model.resolvedModel,
+      ...model.supportsEffort === false ? { reasoningEfforts: [] } : model.supportedEffortLevels ? { reasoningEfforts: model.supportedEffortLevels } : {}
+    }));
+  };
+  let warm = null;
+  if (opts.prewarm && startFrom) {
+    opts.prewarm.discard("resume");
+  } else if (opts.prewarm && opts.signal?.aborted) {
+    opts.prewarm.discard("aborted");
+  } else if (opts.prewarm) {
+    const lease = opts.prewarm;
+    const abort = new AbortController();
+    const onOuterAbort = () => abort.abort();
+    opts.signal?.addEventListener("abort", onOuterAbort, { once: true });
+    const messages2 = new PushableAsyncIterable();
+    const startedAt = Date.now();
+    try {
+      const response2 = index.query({
+        prompt: messages2,
+        options: buildSdkOptions(lease.mode, { settingsPath: lease.hookSettingsPath, abort: abort.signal })
+      });
+      const handshake = discoverModels(response2).then(
+        (models2) => ({ ok: true, models: models2, at: Date.now() }),
+        () => ({ ok: false, at: Date.now() })
+      );
+      const w = { response: response2, messages: messages2, lease, startedAt, handshake };
+      lease.setTeardown(() => {
+        if (w.idleTimer) clearTimeout(w.idleTimer);
+        try {
+          w.offExit?.();
+        } catch {
+        }
+        opts.signal?.removeEventListener("abort", onOuterAbort);
+        if (warm === w) warm = null;
+        messages2.end();
+        abort.abort();
+      });
+      w.idleTimer = setTimeout(() => lease.discard("idle"), lease.idleMs);
+      w.idleTimer.unref?.();
+      void handshake.then((result) => {
+        if (!result.ok) {
+          lease.discard("handshake-failed");
+          return;
+        }
+        if (warm !== w) return;
+        try {
+          const transport = response2.transport;
+          const off = transport?.onExit?.(() => {
+            if (warm === w) lease.discard("exited");
+          });
+          if (typeof off === "function") w.offExit = off;
+        } catch {
+        }
+      });
+      warm = w;
+      logger.logger.debug(formatPrewarmLine("started", { tag: lease.tag }));
+    } catch (error) {
+      opts.signal?.removeEventListener("abort", onOuterAbort);
+      logger.logger.debug(`[claudeRemote] prewarm query() threw: ${error instanceof Error ? error.message : String(error)}`);
+      lease.discard("spawn-failed");
+    }
+  }
+  const discardWarm = (reason) => {
+    warm?.lease.discard(reason);
+  };
+  let initial;
+  try {
+    initial = await opts.nextMessage();
+  } catch (error) {
+    discardWarm("error");
+    throw error;
+  }
   if (!initial) {
+    discardWarm("exit");
     return;
   }
+  let timingTurn = 1;
+  let timingMarks = { pushedAt: initial.enqueuedAt ?? Date.now() };
   const initialText = typeof initial.message === "string" ? initial.message : initial.message.find((b) => b.type === "text")?.text ?? "";
   const specialCommand = specialCommands.parseSpecialCommand(initialText);
   if (specialCommand.type === "clear") {
+    discardWarm("clear");
     if (opts.onCompletionEvent) {
       opts.onCompletionEvent("Context was reset");
     }
@@ -751,90 +1187,95 @@ async function claudeRemote(opts) {
       opts.onCompletionEvent("Compaction started");
     }
   }
-  let mode = initial.mode;
-  const sdkOptions = {
-    cwd: opts.path,
-    resume: startFrom ?? void 0,
-    mcpServers: opts.mcpServers,
-    permissionMode: permissionMode.mapToClaudeMode(initial.mode.permissionMode),
-    // This is only the SDK safety opt-in; permissionMode/canUseTool still
-    // enforce the selected policy. It must be enabled at Query creation so
-    // a later explicit live switch to bypassPermissions can succeed.
-    allowDangerouslySkipPermissions: true,
-    model: initial.mode.model,
-    fallbackModel: initial.mode.fallbackModel,
-    customSystemPrompt: initial.mode.customSystemPrompt ? initial.mode.customSystemPrompt + "\n\n" + systemPrompt.systemPrompt : void 0,
-    appendSystemPrompt: initial.mode.appendSystemPrompt ? initial.mode.appendSystemPrompt + "\n\n" + systemPrompt.systemPrompt : systemPrompt.systemPrompt,
-    allowedTools: initial.mode.allowedTools ? initial.mode.allowedTools.concat(opts.allowedTools) : opts.allowedTools,
-    additionalDirectories: opts.additionalDirectories,
-    disallowedTools: initial.mode.disallowedTools,
-    effort: initial.mode.effort,
-    canCallTool: (toolName, input, options) => opts.canCallTool(toolName, input, mode, options),
-    onElicitation: opts.onElicitation,
-    onUserDialog: opts.onUserDialog,
-    supportedDialogKinds: opts.onUserDialog ? ["refusal_fallback_prompt"] : void 0,
-    abort: opts.signal,
-    settingsPath: opts.hookSettingsPath,
-    // B-309: token-level partials. Without this the SDK emits nothing
-    // between "turn started" and "entire assistant message", which is
-    // exactly why the web used to show a spinner where the terminal shows
-    // the model thinking out loud. The partials do NOT enter the
-    // transcript; they are split off below and relayed on a side channel.
-    // Only pay for them when someone is listening.
-    includePartialMessages: opts.onStreamFrame ? true : void 0
-  };
-  let thinking = false;
-  const updateThinking = (newThinking) => {
-    if (thinking !== newThinking) {
-      thinking = newThinking;
-      logger.logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
-      if (opts.onThinkingChange) {
-        opts.onThinkingChange(thinking);
+  let adopted = null;
+  if (warm) {
+    const w = warm;
+    const adoptStart = Date.now();
+    const decision = decideWarmAdoption({ predicted: w.lease.mode, actual: initial.mode, specialCommand: specialCommand.type });
+    let reason = decision.adopt ? null : decision.reason;
+    const hs = reason ? null : await w.handshake;
+    if (!reason) {
+      if (warm !== w) {
+        reason = "closed";
+      } else if (!hs?.ok) {
+        reason = "handshake-failed";
+      } else if (decision.adopt) {
+        try {
+          if (decision.setPermissionMode) {
+            await withTimeout(w.response.setPermissionMode(decision.setPermissionMode), w.lease.adoptTimeoutMs);
+          } else {
+            await withTimeout(w.response.mcpServerStatus(), w.lease.adoptTimeoutMs);
+          }
+        } catch {
+          reason = decision.setPermissionMode ? "set-permission-failed" : "not-alive";
+        }
+        if (!reason && decision.switchModel) {
+          try {
+            await withTimeout(w.response.setModel(modelTarget(initial.mode.model)), w.lease.adoptTimeoutMs);
+          } catch {
+            reason = "set-model-failed";
+          }
+        }
+        if (!reason && warm !== w) reason = "closed";
       }
     }
-  };
-  let messages = new PushableAsyncIterable();
-  messages.push({
+    if (reason || !hs?.ok) {
+      w.lease.discard(reason ?? "handshake-failed");
+      warm = null;
+    } else {
+      if (w.idleTimer) clearTimeout(w.idleTimer);
+      try {
+        w.offExit?.();
+      } catch {
+      }
+      warm = null;
+      w.lease.adopt();
+      adopted = { response: w.response, messages: w.messages, models: hs.models };
+      logger.logger.debug(formatPrewarmLine("adopted", {
+        warmForMs: adoptStart - w.startedAt,
+        handshakeWaitMs: Math.max(0, hs.at - adoptStart),
+        adoptMs: Date.now() - adoptStart,
+        setPermissionMode: decision.adopt ? decision.setPermissionMode : void 0,
+        setModel: decision.adopt && decision.switchModel ? true : void 0
+      }));
+    }
+  }
+  mode = initial.mode;
+  const initialUserMessage = {
     type: "user",
     parent_tool_use_id: null,
     origin: { kind: "human" },
+    ...promptUuid(initial.uuid),
     message: {
       role: "user",
       content: initial.message
     }
-  });
-  let callbackDepth = 0;
-  const guardCallback = (callback) => (async (...args) => {
-    callbackDepth++;
-    try {
-      return await callback(...args);
-    } finally {
-      setImmediate(() => {
-        callbackDepth--;
-      });
-    }
-  });
-  if (sdkOptions.canCallTool) sdkOptions.canCallTool = guardCallback(sdkOptions.canCallTool);
-  if (sdkOptions.onElicitation) sdkOptions.onElicitation = guardCallback(sdkOptions.onElicitation);
-  if (sdkOptions.onUserDialog) sdkOptions.onUserDialog = guardCallback(sdkOptions.onUserDialog);
-  const response = index.query({
-    prompt: messages,
-    options: sdkOptions
-  });
+  };
+  let messages;
+  let response;
   let models;
-  if (typeof response.supportedModels === "function") {
+  if (adopted) {
+    messages = adopted.messages;
+    response = adopted.response;
+    models = adopted.models;
+    timingMarks.handshakeAt = Date.now();
+    messages.push(initialUserMessage);
+  } else {
+    messages = new PushableAsyncIterable();
+    messages.push(initialUserMessage);
+    timingMarks.spawnAt = Date.now();
+    response = index.query({
+      prompt: messages,
+      options: buildSdkOptions(initial.mode, { settingsPath: opts.hookSettingsPath, abort: opts.signal })
+    });
     try {
-      models = (await response.supportedModels()).map((model) => ({
-        code: model.value,
-        value: model.displayName,
-        description: model.description,
-        resolvedModel: model.resolvedModel,
-        ...model.supportsEffort === false ? { reasoningEfforts: [] } : model.supportedEffortLevels ? { reasoningEfforts: model.supportedEffortLevels } : {}
-      }));
+      models = await discoverModels(response);
     } catch (error) {
       logger.logger.debug("[claudeRemote] Model capability discovery unavailable");
     }
+    timingMarks.handshakeAt = Date.now();
   }
+  const prewarmTiming = adopted ? "adopted" : void 0;
   if (opts.onQueryReady) {
     opts.onQueryReady({
       canControl: () => callbackDepth === 0,
@@ -886,6 +1327,11 @@ async function claudeRemote(opts) {
       if (message.type === "assistant" && message.error) {
         lastAssistantError = message.error;
       }
+      if (message.type === "assistant" && timingMarks.firstAssistantAt === void 0) {
+        timingMarks.firstAssistantAt = Date.now();
+      } else if (message.type === "system" && message.subtype === "init" && timingMarks.initAt === void 0) {
+        timingMarks.initAt = Date.now();
+      }
       if (opts.onStreamFrame && message.type === "system") {
         const subtype = message.subtype;
         if (subtype === "thinking_tokens") {
@@ -935,6 +1381,15 @@ async function claudeRemote(opts) {
       if (message.type === "result") {
         updateThinking(false);
         logger.logger.debug("[claudeRemote] Result received");
+        logger.logger.debug(formatClaudeTimingLine({
+          turn: timingTurn,
+          firstTurnOfProcess: timingTurn === 1,
+          marks: timingMarks,
+          result: message,
+          prewarm: timingTurn === 1 ? prewarmTiming : void 0
+        }));
+        timingTurn++;
+        timingMarks = {};
         const denials = message.permission_denials;
         if (denials && denials.length > 0) {
           logger.logger.warn(`[claudeRemote] ${denials.length} tool call(s) auto-denied by Claude Code policy: ${denials.map((d) => d.tool_name ?? "?").join(", ")}`);
@@ -974,10 +1429,12 @@ async function claudeRemote(opts) {
           }
           mode = next.mode;
           updateThinking(true);
+          timingMarks = { pushedAt: next.enqueuedAt ?? Date.now() };
           messages.push({
             type: "user",
             parent_tool_use_id: null,
             origin: { kind: "human" },
+            ...promptUuid(next.uuid),
             message: { role: "user", content: next.message }
           });
         }).catch(() => {
@@ -2355,6 +2812,146 @@ class LaunchModeGate {
   }
 }
 
+class ConversationRewindError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ConversationRewindError";
+  }
+}
+function transcriptPromptText(parsed) {
+  if (parsed?.type !== "user" || parsed.isSidechain || parsed.isMeta || parsed.isSynthetic) return null;
+  const content = parsed.message?.content;
+  if (typeof content === "string") return content.trim() ? content : null;
+  if (!Array.isArray(content) || content.some((block) => block?.type === "tool_result")) return null;
+  const text = content.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+  if (!text.trim()) return content.length > 0 ? "" : null;
+  return text;
+}
+function isConversationEntry(parsed) {
+  return !parsed?.isSidechain && !parsed?.isMeta && !parsed?.isSynthetic && (parsed?.type === "user" || parsed?.type === "assistant");
+}
+function resolveRewindTarget(entries, target) {
+  for (const uuid of target.uuids) {
+    const index = entries.findIndex((entry) => entry.parsed?.uuid === uuid && transcriptPromptText(entry.parsed) !== null);
+    if (index >= 0) return index;
+  }
+  const wanted = target.text?.trim();
+  if (!wanted) throw new ConversationRewindError("not-found", "This message is not in the agent conversation");
+  const matches = [];
+  entries.forEach((entry, index) => {
+    if (transcriptPromptText(entry.parsed)?.trim() === wanted) matches.push(index);
+  });
+  if (matches.length === 1) return matches[0];
+  if (matches.length === 0) throw new ConversationRewindError("not-found", "This message is not in the agent conversation");
+  throw new ConversationRewindError("ambiguous", "Several earlier messages have the same text; cannot tell which one to change");
+}
+function rewindTranscriptLines(lines, action, target) {
+  const entries = [];
+  for (const line of lines) {
+    if (!line) continue;
+    let parsed = null;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+    }
+    entries.push({ line, parsed });
+  }
+  const cut = resolveRewindTarget(entries, target);
+  let end = entries.length;
+  for (let i = cut + 1; i < entries.length; i++) {
+    if (transcriptPromptText(entries[i].parsed) !== null) {
+      end = i;
+      break;
+    }
+  }
+  const before = entries.slice(0, cut);
+  const after = action === "delete" ? entries.slice(end) : [];
+  if (![...before, ...after].some((entry) => isConversationEntry(entry.parsed))) return null;
+  if (before.some((entry) => isConversationEntry(entry.parsed)) && !before.some((entry) => transcriptPromptText(entry.parsed) !== null)) {
+    throw new ConversationRewindError("unsafe", "Cannot safely rewind: earlier history has no user prompt");
+  }
+  if (after.length === 0) return before.map((entry) => entry.line);
+  const dropped = /* @__PURE__ */ new Set();
+  for (const entry of entries.slice(cut, end)) {
+    if (typeof entry.parsed?.uuid === "string") dropped.add(entry.parsed.uuid);
+  }
+  const reparentTo = typeof entries[cut].parsed?.parentUuid === "string" ? entries[cut].parsed.parentUuid : null;
+  const relinked = after.map((entry) => {
+    const parsed = entry.parsed;
+    if (!parsed || typeof parsed !== "object") return entry.line;
+    let next = parsed;
+    for (const key of ["parentUuid", "logicalParentUuid"]) {
+      if (typeof parsed[key] === "string" && dropped.has(parsed[key])) {
+        next = next === parsed ? { ...parsed } : next;
+        next[key] = reparentTo;
+      }
+    }
+    return next === parsed ? entry.line : JSON.stringify(next);
+  });
+  return [...before.map((entry) => entry.line), ...relinked];
+}
+async function rewindClaudeTranscript(projectDir, claudeSessionId, action, target) {
+  const source = path$1.join(projectDir, `${claudeSessionId}.jsonl`);
+  let raw;
+  try {
+    raw = await promises.readFile(source, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new claudeSessionFork.ForkSourceMissingError(source);
+    throw error;
+  }
+  const kept = rewindTranscriptLines(raw.split("\n"), action, target);
+  if (kept === null) return null;
+  const newId = node_crypto.randomUUID();
+  const destination = path$1.join(projectDir, `${newId}.jsonl`);
+  const temporary = `${destination}.tmp-${process.pid}`;
+  try {
+    await promises.writeFile(temporary, kept.join("\n") + "\n", { encoding: "utf-8", flag: "wx" });
+    await promises.rename(temporary, destination);
+  } catch (error) {
+    await promises.unlink(temporary).catch(() => void 0);
+    throw error;
+  }
+  return newId;
+}
+
+const STOP_WAIT_MS = 8e3;
+function createConversationRewind(deps) {
+  let inFlight = false;
+  const rewrite = deps.rewrite ?? rewindClaudeTranscript;
+  return async (input) => {
+    const request = input && typeof input === "object" ? input : {};
+    const action = request.action;
+    const sourceId = typeof request.sourceId === "string" && request.sourceId.length > 0 && request.sourceId.length <= 200 ? request.sourceId : void 0;
+    const text = typeof request.text === "string" && request.text.length <= 2e5 ? request.text : void 0;
+    if (action !== "edit" && action !== "delete" || !sourceId && !text?.trim()) {
+      return { ok: false, code: "invalid", error: "Invalid rewind request" };
+    }
+    if (inFlight) return { ok: false, code: "busy", error: "Another edit is still being applied" };
+    inFlight = true;
+    try {
+      if (deps.isThinking()) {
+        await deps.stopTurn();
+        if (!await deps.waitIdle(STOP_WAIT_MS)) {
+          return { ok: false, code: "running", error: "The agent did not stop; try again after it finishes" };
+        }
+      }
+      const current = deps.claudeSessionId();
+      if (!current) return { ok: false, code: "no-conversation", error: "The agent has no conversation to change yet" };
+      const uuids = sourceId ? [sourceId, ...deps.aliases(sourceId)] : [];
+      const next = await rewrite(deps.projectDir(), current, action, { uuids, text });
+      await deps.switchConversation(next);
+      return { ok: true, action, freshConversation: next === null };
+    } catch (error) {
+      if (error instanceof ConversationRewindError) return { ok: false, code: error.code, error: error.message };
+      if (error instanceof claudeSessionFork.ForkSourceMissingError) return { ok: false, code: "no-conversation", error: "The agent conversation file is missing on this machine" };
+      throw error;
+    } finally {
+      inFlight = false;
+    }
+  };
+}
+
 const ABORT_INTERRUPT_GRACE_MS = 4e3;
 async function claudeRemoteLauncher(session, onPermissionModeChange, onEffectivePermissionMode, onPromptFinalized) {
   logger.logger.debug("[claudeRemoteLauncher] Starting remote launcher");
@@ -2449,6 +3046,31 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
     await turnSteering.steer();
   });
   session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+  const promptAliases = /* @__PURE__ */ new Map();
+  const promptUuidFor = (sourceIds) => {
+    const [first, ...rest] = sourceIds ?? [];
+    if (first) for (const id of rest) promptAliases.set(id, first);
+    if (promptAliases.size > 2e3) promptAliases.delete(promptAliases.keys().next().value);
+    return first;
+  };
+  let silentRelaunch = false;
+  session.client.rpcHandlerManager.registerHandler("conversation-rewind", createConversationRewind({
+    claudeSessionId: () => session.sessionId,
+    projectDir: () => path.getProjectPath(session.path),
+    isThinking: () => session.thinking,
+    stopTurn: doAbort,
+    waitIdle: waitForThinkingToStop,
+    aliases: (sourceId) => {
+      const alias = promptAliases.get(sourceId);
+      return alias ? [alias] : [];
+    },
+    switchConversation: async (claudeSessionId) => {
+      if (claudeSessionId) session.onSessionFound(claudeSessionId);
+      else session.clearSessionId();
+      silentRelaunch = true;
+      await abort();
+    }
+  }));
   let livePermissionModeHandler = null;
   let idlePermissionModeHandler = null;
   session.client.rpcHandlerManager.registerHandler(
@@ -2634,10 +3256,13 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
       permissionHandler.setOnModeChanged((nextMode) => {
         commitPermissionMode(nextMode);
       });
+      let launchPrewarm = null;
       try {
         const attachmentDirectory = attachmentContent.chatAttachmentDirectory(configuration.configuration.happyHomeDir, session.client.sessionId);
         await configuration.ensurePrivateDirectory(attachmentDirectory);
+        launchPrewarm = session.takeClaudePrewarm();
         const remoteResult = await claudeRemote({
+          prewarm: launchPrewarm ?? void 0,
           sessionId: session.sessionId,
           path: session.path,
           additionalDirectories: [attachmentDirectory],
@@ -2669,7 +3294,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
                 }) : [];
                 modeGate.park({
                   message: parkedStaged.length > 0 ? attachmentContent.appendStagedAttachmentsToPrompt(msg.message, parkedStaged) : msg.message,
-                  mode: msg.mode
+                  mode: msg.mode,
+                  uuid: promptUuidFor(msg.sourceIds)
                 });
                 return null;
               }
@@ -2686,13 +3312,17 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
                 onPromptFinalized?.(withAttachments);
                 return {
                   message: withAttachments,
-                  mode: msg.mode
+                  mode: msg.mode,
+                  enqueuedAt: msg.enqueuedAt,
+                  uuid: promptUuidFor(msg.sourceIds)
                 };
               }
               onPromptFinalized?.(msg.message);
               return {
                 message: msg.message,
-                mode: msg.mode
+                mode: msg.mode,
+                enqueuedAt: msg.enqueuedAt,
+                uuid: promptUuidFor(msg.sourceIds)
               };
             }
             return null;
@@ -2793,7 +3423,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
           signal: abortController.signal
         });
         session.consumeOneTimeFlags();
-        if (!exitReason && abortController.signal.aborted) {
+        if (!exitReason && abortController.signal.aborted && !silentRelaunch) {
           session.client.closeClaudeSessionTurn("cancelled");
           session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
         }
@@ -2810,6 +3440,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
           continue;
         }
       } finally {
+        launchPrewarm?.discard("launch-ended");
         runtimeControls.setQuery(null);
         backgroundTasks.reset();
         session.setBackgroundTasks([]);
@@ -2835,6 +3466,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
         streamRelay$1.endTurn();
         streamRelay$1.dispose();
         abortController = null;
+        silentRelaunch = false;
         abortFuture?.resolve(void 0);
         abortFuture = null;
         logger.logger.debug("[remote]: launch done");
@@ -2883,7 +3515,8 @@ async function loop(opts) {
     onModeChange: opts.onModeChange,
     onAbort: opts.onAbort,
     hookSettingsPath: opts.hookSettingsPath,
-    jsRuntime: opts.jsRuntime
+    jsRuntime: opts.jsRuntime,
+    claudePrewarm: opts.claudePrewarm
   });
   opts.onSessionReady?.(session);
   let mode = opts.startingMode ?? "local";
@@ -2891,7 +3524,7 @@ async function loop(opts) {
     logger.logger.debug(`[loop] Iteration with mode: ${mode}`);
     switch (mode) {
       case "local": {
-        const { claudeLocalLauncher } = await Promise.resolve().then(function () { return require('./claudeLocalLauncher-DyEbVzUN.cjs'); });
+        const { claudeLocalLauncher } = await Promise.resolve().then(function () { return require('./claudeLocalLauncher-DWFWuLhY.cjs'); });
         const result = await claudeLocalLauncher(session);
         switch (result.type) {
           case "switch":
@@ -2919,18 +3552,18 @@ async function loop(opts) {
   }
 }
 
-function claudeModeHash(mode) {
-  return deterministicJson.hashObject({
-    isPlan: mode.permissionMode === "plan",
-    fallbackModel: mode.fallbackModel,
-    customSystemPrompt: mode.customSystemPrompt,
-    appendSystemPrompt: mode.appendSystemPrompt,
-    allowedTools: mode.allowedTools,
-    disallowedTools: mode.disallowedTools,
-    effort: mode.effort
-  });
+function parseSessionHookTarget(url) {
+  if (!url) return null;
+  let parsed;
+  try {
+    parsed = new URL(url, "http://127.0.0.1");
+  } catch {
+    return null;
+  }
+  if (parsed.pathname !== "/hook/session-start") return null;
+  const source = parsed.searchParams.get("source");
+  return source && /^[A-Za-z0-9_.-]{1,64}$/.test(source) ? { source } : {};
 }
-
 function hookRequestLogMetadata(body, data) {
   return {
     bodyBytes: Buffer.byteLength(body, "utf8"),
@@ -2952,7 +3585,8 @@ async function startHookServer(options) {
   const { onSessionHook } = options;
   return new Promise((resolve, reject) => {
     const server = node_http.createServer(async (req, res) => {
-      if (req.method === "POST" && req.url === "/hook/session-start") {
+      const hookMeta = req.method === "POST" ? parseSessionHookTarget(req.url) : null;
+      if (hookMeta) {
         const timeout = setTimeout(() => {
           if (!res.headersSent) {
             logger.logger.debug("[hookServer] Request timeout");
@@ -2976,7 +3610,7 @@ async function startHookServer(options) {
           const sessionId = data?.session_id || data?.sessionId;
           if (sessionId && data) {
             logger.logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
-            onSessionHook(sessionId, data);
+            onSessionHook(sessionId, data, hookMeta);
           } else {
             logger.logger.debug("[hookServer] Session hook received but no session_id found in data");
           }
@@ -3015,13 +3649,16 @@ async function startHookServer(options) {
   });
 }
 
-function generateHookSettingsFile(port) {
+function generateHookSettingsFile(port, source) {
   const hooksDir = path$1.join(configuration.configuration.happyHomeDir, "tmp", "hooks");
   node_fs.mkdirSync(hooksDir, { recursive: true });
-  const filename = `session-hook-${process.pid}.json`;
+  const filename = source ? `session-hook-${process.pid}-${source}.json` : `session-hook-${process.pid}.json`;
   const filepath = path$1.join(hooksDir, filename);
   const forwarderScript = path$1.resolve(projectPath.projectPath(), "scripts", "session_hook_forwarder.cjs");
-  const hookCommand = `node "${forwarderScript}" ${port}`;
+  if (source !== void 0 && !/^[A-Za-z0-9_.-]{1,64}$/.test(source)) {
+    throw new Error("invalid hook source tag");
+  }
+  const hookCommand = source ? `node "${forwarderScript}" ${port} ${source}` : `node "${forwarderScript}" ${port}`;
   const settings = {
     hooks: {
       SessionStart: [
@@ -3619,31 +4256,90 @@ function withAssistantDenylist(current, isAssistant) {
   return [...merged];
 }
 
+const VALID_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
+const has = (meta, key) => !!meta && Object.prototype.hasOwnProperty.call(meta, key);
+function resolveMessageMode(current, meta, ctx) {
+  const next = { ...current };
+  const result = {};
+  let permissionMode$1 = current.permissionMode;
+  if (!ctx.staleModeSnapshot && meta?.permissionMode) {
+    permissionMode$1 = permissionMode.resolveRemoteClaudePermissionMode(current.permissionMode, meta.permissionMode, ctx.sandboxEnabled);
+    next.permissionMode = permissionMode$1;
+    result.publishPermissionMode = permissionMode$1;
+  }
+  if (has(meta, "model")) next.model = meta.model || void 0;
+  if (has(meta, "customSystemPrompt")) next.customSystemPrompt = meta.customSystemPrompt || void 0;
+  if (has(meta, "fallbackModel")) next.fallbackModel = meta.fallbackModel || void 0;
+  if (has(meta, "appendSystemPrompt")) next.appendSystemPrompt = meta.appendSystemPrompt || void 0;
+  if (has(meta, "allowedTools")) next.allowedTools = meta.allowedTools || void 0;
+  if (has(meta, "disallowedTools")) {
+    next.disallowedTools = withAssistantDenylist(meta.disallowedTools || void 0, ctx.isAssistantVariant);
+  }
+  if (has(meta, "effort")) {
+    const incoming = meta.effort;
+    if (incoming === null || incoming === void 0) {
+      next.effort = void 0;
+    } else if (typeof incoming === "string" && VALID_EFFORTS.has(incoming)) {
+      next.effort = incoming;
+    } else {
+      result.ignoredEffort = String(incoming);
+    }
+  }
+  return {
+    ...result,
+    next,
+    mode: {
+      permissionMode: permissionMode$1 || "default",
+      model: next.model,
+      fallbackModel: next.fallbackModel,
+      customSystemPrompt: next.customSystemPrompt,
+      appendSystemPrompt: next.appendSystemPrompt,
+      allowedTools: next.allowedTools,
+      disallowedTools: next.disallowedTools,
+      effort: next.effort
+    }
+  };
+}
+
 exports.reportSessionEditToDaemon = controlClient.reportSessionEditToDaemon;
 exports.claudeCheckSession = systemPrompt.claudeCheckSession;
 exports.parseSpecialCommand = specialCommands.parseSpecialCommand;
 exports.contentLogMetadata = contentLogMetadata.contentLogMetadata;
 exports.RawJSONLinesSchema = types.RawJSONLinesSchema;
 exports.getProjectPath = path.getProjectPath;
+exports.createSelfReportState = deterministicJson.createSelfReportState;
+exports.startHappyServer = deterministicJson.startHappyServer;
 exports.createSessionScanner = sessionScanner.createSessionScanner;
 exports.MessageQueue2 = registerKillSessionHandler.MessageQueue2;
 exports.registerKillSessionHandler = registerKillSessionHandler.registerKillSessionHandler;
-exports.createSelfReportState = deterministicJson.createSelfReportState;
-exports.startHappyServer = deterministicJson.startHappyServer;
 exports.getEnvironmentInfo = doctor.getEnvironmentInfo;
 exports.EditReportThrottle = editPaths.EditReportThrottle;
 exports.extractClaudeEditPaths = editPaths.extractClaudeEditPaths;
 exports.TitleGenerator = titleGenerator.TitleGenerator;
 exports.BoardAnalyzer = BoardAnalyzer;
 exports.FileRateLimiter = FileRateLimiter;
+exports.PrewarmHookGate = PrewarmHookGate;
 exports.SessionExitGate = SessionExitGate;
+exports.acquirePrewarmSlot = acquirePrewarmSlot;
 exports.claudeModeHash = claudeModeHash;
+exports.claudePrewarmEligibility = claudePrewarmEligibility;
+exports.claudePrewarmSessionEligibility = claudePrewarmSessionEligibility;
 exports.cleanupHookSettingsFile = cleanupHookSettingsFile;
+exports.createClaudePrewarmLease = createClaudePrewarmLease;
+exports.disposeAllClaudePrewarms = disposeAllClaudePrewarms;
+exports.evaluatePrewarmPrediction = evaluatePrewarmPrediction;
 exports.exitIntentFromArchiveFlag = exitIntentFromArchiveFlag;
+exports.formatPrewarmLine = formatPrewarmLine;
 exports.generateHookSettingsFile = generateHookSettingsFile;
 exports.loop = loop;
+exports.prewarmCacheFile = prewarmCacheFile;
+exports.prewarmPredictionMeta = prewarmPredictionMeta;
+exports.prewarmSlotDir = prewarmSlotDir;
+exports.readPrewarmCache = readPrewarmCache;
 exports.registerSideQuestionHandler = registerSideQuestionHandler;
+exports.resolveMessageMode = resolveMessageMode;
 exports.settleSessionOnExit = settleSessionOnExit;
 exports.startHookServer = startHookServer;
 exports.withAssistantDenylist = withAssistantDenylist;
+exports.writePrewarmCache = writePrewarmCache;
 exports.writeSideQuestionSettingsFile = writeSideQuestionSettingsFile;