very-happy-cli 0.2.160 → 0.2.162

package/dist/{runClaudeDeps-DOt79DjU.mjs → runClaudeDeps-QaEx8y5r.mjs}

@@ -1,48 +1,50 @@
-import { l as logger } from './logger-6HYUEXNk.mjs';
-import { k as notifyDaemonSessionEvent, m as notifyDaemonClaudeAuthFailed } from './controlClient-BGbDcgWS.mjs';
-export { g as reportSessionEditToDaemon } from './controlClient-BGbDcgWS.mjs';
+import { l as logger } from './logger-CGE4C8ho.mjs';
+import { k as notifyDaemonSessionEvent, m as notifyDaemonClaudeAuthFailed } from './controlClient-CYzHrh3e.mjs';
+export { g as reportSessionEditToDaemon } from './controlClient-CYzHrh3e.mjs';
 import { s as sameBackgroundTasks, c as createBackgroundTaskTracker } from './backgroundTaskActivity-8PdPxrvy.mjs';
 import { randomInt, randomUUID, createHash } from 'node:crypto';
 import { M as MessageBuffer } from './messageBuffer-BWlGgR3A.mjs';
 import { query } from './index-B6UGRQ7h.mjs';
 import { AbortError } from '@anthropic-ai/claude-agent-sdk';
-import { m as mapToClaudeMode, p as parseClaudePermissionMode } from './permissionMode-Cr5JCbB7.mjs';
-import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-DX521JJz.mjs';
+import { m as mapToClaudeMode, p as parseClaudePermissionMode, c as resolveRemoteClaudePermissionMode } from './permissionMode-CH4FoZfU.mjs';
+import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-DsQoUgQw.mjs';
 import { join, resolve, dirname } from 'node:path';
 import { p as parseSpecialCommand } from './specialCommands-BSqhYg5X.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import { A as AsyncLock } from './attachmentLimits-yba1uHFO.mjs';
+import { A as AsyncLock } from './attachmentLimits-D5pgmASK.mjs';
 import 'tweetnacl';
-import { c as configuration, e as ensurePrivateDirectory } from './configuration-RfeNjFmd.mjs';
-import './index-qdS1friN.mjs';
-import './registerCommonHandlers-Ccvsz7Ou.mjs';
+import { c as configuration, e as ensurePrivateDirectory } from './configuration-A5gW_0GE.mjs';
+import './index-BBg9j0XK.mjs';
+import './registerCommonHandlers-Ckv5boQI.mjs';
 import 'os';
 import 'child_process';
 import '@paralleldrive/cuid2';
-import './persistence-HGW_ZVs9.mjs';
+import './persistence-Cw8aLoyL.mjs';
 import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 export { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import { g as getProjectPath } from './path-D2wdaNSk.mjs';
 import { access } from 'fs/promises';
-import { d as delay } from './time-D0XyHOid.mjs';
-import { F as Future } from './sessionScanner-CX3onqXh.mjs';
-export { c as createSessionScanner } from './sessionScanner-CX3onqXh.mjs';
+import { d as delay } from './time-CVvxdEDh.mjs';
+import { mkdirSync, writeFileSync, readFileSync, unlinkSync, renameSync, statSync, existsSync } from 'node:fs';
+import { h as hashObject, i as isSelfReportFresh } from './deterministicJson-DiR7EOMO.mjs';
+export { c as createSelfReportState, s as startHappyServer } from './deterministicJson-DiR7EOMO.mjs';
+import { F as Future } from './sessionScanner-Cdukzo70.mjs';
+export { c as createSessionScanner } from './sessionScanner-Cdukzo70.mjs';
 import { execSync } from 'node:child_process';
-import { S as StreamRelay } from './streamRelay-FPVbHpbM.mjs';
-import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-_kxRznNf.mjs';
-export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-GYvHdipX.mjs';
-import { h as hashObject, i as isSelfReportFresh } from './deterministicJson-CzkFJWw1.mjs';
-export { c as createSelfReportState, s as startHappyServer } from './deterministicJson-CzkFJWw1.mjs';
-export { g as getEnvironmentInfo } from './doctor-DOvByjbk.mjs';
+import { S as StreamRelay } from './streamRelay-BLgU9X3R.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-s1xPha4Q.mjs';
+import { readFile, writeFile, rename, unlink } from 'node:fs/promises';
+import { F as ForkSourceMissingError } from './claudeSessionFork-_DUrXaqd.mjs';
+export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-Cll4-o8Y.mjs';
+export { g as getEnvironmentInfo } from './doctor-FuCvKdRa.mjs';
 import { createServer } from 'node:http';
 export { E as EditReportThrottle, b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
-import { existsSync, unlinkSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
-import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-CQ8CoGhg.mjs';
-export { T as TitleGenerator } from './titleGenerator-CQ8CoGhg.mjs';
+import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-B4AW3dLr.mjs';
+export { T as TitleGenerator } from './titleGenerator-B4AW3dLr.mjs';
 import { B as BOARD_ANALYZER_PROMPT_PREFIX } from './oneShotPrompts-DT4p6RNd.mjs';
 import 'node:util';
 import './smallFastModel-BLNgMrwR.mjs';
@@ -50,34 +52,34 @@ import './trimIdent-BAjmv_TG.mjs';
 import 'node:os';
 import './agentGuidance-CQuNlNx8.mjs';
 import 'zod';
-import './package-BhaKlnxz.mjs';
-import 'node:fs/promises';
+import './package-DQsvY1XN.mjs';
 import 'util';
 import 'crypto';
 import 'path';
 import 'cross-spawn';
 import './authRelay-DSAvg1uv.mjs';
-import './sync-C8gyQFMc.mjs';
-import './startFileWatcher-DErVWZE4.mjs';
-import './client-CeGKqqcJ.mjs';
-import './context-H0Bcb9S_.mjs';
-import './sessionOps-SuHW8Dfe.mjs';
+import './client-Dk7x-s-O.mjs';
+import './context-BXnxalWW.mjs';
+import './sessionOps-CdwVPSZz.mjs';
 import './resources-BdFBQi8r.mjs';
-import './tools-DkluDcG4.mjs';
-import './tools-BZtHF_qQ.mjs';
-import './client-ClR0K8zX.mjs';
-import './peerTools-BTqw97Gb.mjs';
+import './tools-_kFe4m_l.mjs';
+import './tools-BA1qkiV1.mjs';
+import './client-DwqHDsLb.mjs';
+import './peerTools-D19hhSQF.mjs';
 import './ids-DU6sLx4C.mjs';
-import './remoteSessionClient-CYnXRynE.mjs';
+import './remoteSessionClient-BMjsbuBh.mjs';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import './limits-DIo7rEBR.mjs';
-import './assistantTools-D6tuc6o4.mjs';
+import './assistantTools-mEz6uNqL.mjs';
 import './terminals-Dlg0x3nY.mjs';
 import './terminalTitleSuggest-CeKsX_V6.mjs';
 import './tmuxSocket-B8Yx20sT.mjs';
-import './bootstrap-hxXPCFMx.mjs';
+import './bootstrap-BKmsYSwh.mjs';
 import './previewPath-CXN4Vag0.mjs';
+import './sync-BpLasLu2.mjs';
+import './startFileWatcher-COD5UKNs.mjs';
+import 'node:readline';
 import './doctor-BPkYWSuq.mjs';
 import 'ps-list';
 import './doctorReadiness-C208SMN9.mjs';
@@ -145,6 +147,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.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 */
@@ -165,6 +181,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,
@@ -699,6 +716,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 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 join(happyHomeDir, "claude-prewarm.json");
+}
+function readPrewarmCache(file) {
+  try {
+    const raw = JSON.parse(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`;
+    writeFileSync(tmp, JSON.stringify({ ...cache, updatedAt: Date.now() }), { mode: 384 });
+    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 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 {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  } catch {
+    return null;
+  }
+  for (let i = 0; i < max; i++) {
+    const path = join(dir, `slot-${i}.lock`);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        writeFileSync(path, String(pid), { flag: "wx", mode: 384 });
+        let released = false;
+        return {
+          path,
+          release: () => {
+            if (released) return;
+            released = true;
+            try {
+              if (readFileSync(path, "utf8").trim() === String(pid)) unlinkSync(path);
+            } catch {
+            }
+          }
+        };
+      } catch (error) {
+        if (error?.code !== "EEXIST") return null;
+        if (!slotIsStale(path, { isAlive, now, staleMs }) || attempt > 0) break;
+        try {
+          unlinkSync(path);
+        } catch {
+        }
+      }
+    }
+  }
+  return null;
+}
+function slotIsStale(path, opts) {
+  try {
+    const owner = Number(readFileSync(path, "utf8").trim());
+    if (!Number.isInteger(owner) || owner <= 0 || !opts.isAlive(owner)) return true;
+    return opts.now - statSync(path).mtimeMs > opts.staleMs;
+  } catch {
+    return !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 = mapToClaudeMode(input.predicted.permissionMode);
+  const wantedPermission = 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 && !claudeCheckSession(opts.sessionId, opts.path)) {
@@ -729,13 +1025,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.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: 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 : void 0,
+      appendSystemPrompt: creationMode.appendSystemPrompt ? creationMode.appendSystemPrompt + "\n\n" + 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 = 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.debug(formatPrewarmLine("started", { tag: lease.tag }));
+    } catch (error) {
+      opts.signal?.removeEventListener("abort", onOuterAbort);
+      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 = parseSpecialCommand(initialText);
   if (specialCommand.type === "clear") {
+    discardWarm("clear");
     if (opts.onCompletionEvent) {
       opts.onCompletionEvent("Context was reset");
     }
@@ -753,90 +1189,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: 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 : void 0,
-    appendSystemPrompt: initial.mode.appendSystemPrompt ? initial.mode.appendSystemPrompt + "\n\n" + 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.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.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 = 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 = 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.debug("[claudeRemote] Model capability discovery unavailable");
     }
+    timingMarks.handshakeAt = Date.now();
   }
+  const prewarmTiming = adopted ? "adopted" : void 0;
   if (opts.onQueryReady) {
     opts.onQueryReady({
       canControl: () => callbackDepth === 0,
@@ -888,6 +1329,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") {
@@ -937,6 +1383,15 @@ async function claudeRemote(opts) {
       if (message.type === "result") {
         updateThinking(false);
         logger.debug("[claudeRemote] Result received");
+        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.warn(`[claudeRemote] ${denials.length} tool call(s) auto-denied by Claude Code policy: ${denials.map((d) => d.tool_name ?? "?").join(", ")}`);
@@ -976,10 +1431,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(() => {
@@ -2357,6 +2814,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 = join(projectDir, `${claudeSessionId}.jsonl`);
+  let raw;
+  try {
+    raw = await readFile(source, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new ForkSourceMissingError(source);
+    throw error;
+  }
+  const kept = rewindTranscriptLines(raw.split("\n"), action, target);
+  if (kept === null) return null;
+  const newId = randomUUID();
+  const destination = join(projectDir, `${newId}.jsonl`);
+  const temporary = `${destination}.tmp-${process.pid}`;
+  try {
+    await writeFile(temporary, kept.join("\n") + "\n", { encoding: "utf-8", flag: "wx" });
+    await rename(temporary, destination);
+  } catch (error) {
+    await 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 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.debug("[claudeRemoteLauncher] Starting remote launcher");
@@ -2451,6 +3048,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: () => 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(
@@ -2636,10 +3258,13 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
       permissionHandler.setOnModeChanged((nextMode) => {
         commitPermissionMode(nextMode);
       });
+      let launchPrewarm = null;
       try {
         const attachmentDirectory = chatAttachmentDirectory(configuration.happyHomeDir, session.client.sessionId);
         await ensurePrivateDirectory(attachmentDirectory);
+        launchPrewarm = session.takeClaudePrewarm();
         const remoteResult = await claudeRemote({
+          prewarm: launchPrewarm ?? void 0,
           sessionId: session.sessionId,
           path: session.path,
           additionalDirectories: [attachmentDirectory],
@@ -2671,7 +3296,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
                 }) : [];
                 modeGate.park({
                   message: parkedStaged.length > 0 ? appendStagedAttachmentsToPrompt(msg.message, parkedStaged) : msg.message,
-                  mode: msg.mode
+                  mode: msg.mode,
+                  uuid: promptUuidFor(msg.sourceIds)
                 });
                 return null;
               }
@@ -2688,13 +3314,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;
@@ -2795,7 +3425,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" });
         }
@@ -2812,6 +3442,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
           continue;
         }
       } finally {
+        launchPrewarm?.discard("launch-ended");
         runtimeControls.setQuery(null);
         backgroundTasks.reset();
         session.setBackgroundTasks([]);
@@ -2837,6 +3468,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
         streamRelay.endTurn();
         streamRelay.dispose();
         abortController = null;
+        silentRelaunch = false;
         abortFuture?.resolve(void 0);
         abortFuture = null;
         logger.debug("[remote]: launch done");
@@ -2885,7 +3517,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";
@@ -2893,7 +3526,7 @@ async function loop(opts) {
     logger.debug(`[loop] Iteration with mode: ${mode}`);
     switch (mode) {
       case "local": {
-        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-D4T7MTqd.mjs');
+        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-BFfGT4eY.mjs');
         const result = await claudeLocalLauncher(session);
         switch (result.type) {
           case "switch":
@@ -2921,18 +3554,18 @@ async function loop(opts) {
   }
 }
 
-function claudeModeHash(mode) {
-  return 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"),
@@ -2954,7 +3587,8 @@ async function startHookServer(options) {
   const { onSessionHook } = options;
   return new Promise((resolve, reject) => {
     const server = 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.debug("[hookServer] Request timeout");
@@ -2978,7 +3612,7 @@ async function startHookServer(options) {
           const sessionId = data?.session_id || data?.sessionId;
           if (sessionId && data) {
             logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
-            onSessionHook(sessionId, data);
+            onSessionHook(sessionId, data, hookMeta);
           } else {
             logger.debug("[hookServer] Session hook received but no session_id found in data");
           }
@@ -3017,13 +3651,16 @@ async function startHookServer(options) {
   });
 }
 
-function generateHookSettingsFile(port) {
+function generateHookSettingsFile(port, source) {
   const hooksDir = join(configuration.happyHomeDir, "tmp", "hooks");
   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 = join(hooksDir, filename);
   const forwarderScript = resolve(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: [
@@ -3621,4 +4258,49 @@ function withAssistantDenylist(current, isAssistant) {
   return [...merged];
 }
 
-export { BoardAnalyzer, FileRateLimiter, SessionExitGate, claudeCheckSession, claudeModeHash, cleanupHookSettingsFile, contentLogMetadata, exitIntentFromArchiveFlag, generateHookSettingsFile, getProjectPath, loop, parseSpecialCommand, registerSideQuestionHandler, settleSessionOnExit, startHookServer, withAssistantDenylist, writeSideQuestionSettingsFile };
+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 = current.permissionMode;
+  if (!ctx.staleModeSnapshot && meta?.permissionMode) {
+    permissionMode = resolveRemoteClaudePermissionMode(current.permissionMode, meta.permissionMode, ctx.sandboxEnabled);
+    next.permissionMode = permissionMode;
+    result.publishPermissionMode = permissionMode;
+  }
+  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 || "default",
+      model: next.model,
+      fallbackModel: next.fallbackModel,
+      customSystemPrompt: next.customSystemPrompt,
+      appendSystemPrompt: next.appendSystemPrompt,
+      allowedTools: next.allowedTools,
+      disallowedTools: next.disallowedTools,
+      effort: next.effort
+    }
+  };
+}
+
+export { BoardAnalyzer, FileRateLimiter, PrewarmHookGate, SessionExitGate, acquirePrewarmSlot, claudeCheckSession, claudeModeHash, claudePrewarmEligibility, claudePrewarmSessionEligibility, cleanupHookSettingsFile, contentLogMetadata, createClaudePrewarmLease, disposeAllClaudePrewarms, evaluatePrewarmPrediction, exitIntentFromArchiveFlag, formatPrewarmLine, generateHookSettingsFile, getProjectPath, loop, parseSpecialCommand, prewarmCacheFile, prewarmPredictionMeta, prewarmSlotDir, readPrewarmCache, registerSideQuestionHandler, resolveMessageMode, settleSessionOnExit, startHookServer, withAssistantDenylist, writePrewarmCache, writeSideQuestionSettingsFile };