very-happy-cli 0.2.159 → 0.2.161

package/dist/runClaude-BX6ixjtW.cjs

@@ -0,0 +1,894 @@
+'use strict';
+
+var os = require('node:os');
+var sessionLock = require('./sessionLock-7ePAYDOg.cjs');
+var node_crypto = require('node:crypto');
+var api = require('./api-B2vLMS-z.cjs');
+var logger = require('./logger-Bc8-u1w0.cjs');
+var _package = require('./package-Cl5BEP5x.cjs');
+var persistence = require('./persistence-CBNMzSa8.cjs');
+var createSessionMetadata = require('./createSessionMetadata-BRLB9CNO.cjs');
+var index = require('./index-DA7yINuk.cjs');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var controlClient = require('./controlClient-fEHE85bH.cjs');
+var machineMetadata = require('./machineMetadata-BibDMFVx.cjs');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var path = require('node:path');
+var permissionMode = require('./permissionMode-CrV-XuMs.cjs');
+var authRelay = require('./authRelay-BdYkC1Po.cjs');
+var promises = require('node:fs/promises');
+var defaultPermissionMode = require('./defaultPermissionMode-CxmTXUQR.cjs');
+var attachmentContent = require('./attachmentContent-DMMZzevR.cjs');
+var startupPlan = require('./startupPlan-BLMbfQIH.cjs');
+require('node:fs');
+require('axios');
+require('node:events');
+require('socket.io-client');
+require('./attachmentLimits-CzVrqgLR.cjs');
+require('zod');
+require('./limits-C-a7gr04.cjs');
+require('./time-CNRE4ChD.cjs');
+require('./lidState-KHHu1015.cjs');
+require('os');
+require('child_process');
+require('./registerCommonHandlers-BjSV2Skz.cjs');
+require('util');
+require('fs/promises');
+require('crypto');
+require('path');
+require('cross-spawn');
+require('@paralleldrive/cuid2');
+require('./sync-CVk4QERO.cjs');
+require('./backgroundTaskActivity-CBvUdj39.cjs');
+require('./contentLogMetadata-ZSFk_NjQ.cjs');
+require('chalk');
+require('node:util');
+require('./detectCLI-DR9ZaN6B.cjs');
+require('fs');
+require('./localHappyAgentAuth-BXiHPXdC.cjs');
+require('tweetnacl');
+require('url');
+
+const DEFAULT_CLAUDE_MODEL = void 0;
+const DEFAULT_CLAUDE_EFFORT = void 0;
+const importRunClaudeDeps = () => Promise.resolve().then(function () { return require('./runClaudeDeps-Bp20MScE.cjs'); });
+async function runClaude(credentials, options = {}) {
+  logger.logger.debug(`[CLAUDE] ===== CLAUDE MODE STARTING =====`);
+  logger.logger.debug(`[CLAUDE] This is the Claude agent, NOT Gemini`);
+  options = { ...options, claudeEnvVars: { ...options.claudeEnvVars, HAPPY_MANAGED: "1" } };
+  const prewarmSpawnEnv = {};
+  for (const key of ["HAPPY_CLAUDE_AUTH_STATUS", "HAPPY_FIRST_MESSAGE_FROM_CLI"]) {
+    prewarmSpawnEnv[key] = process.env[key];
+    delete process.env[key];
+  }
+  const workingDirectory = process.cwd();
+  const isAssistantVariant = process.env.HAPPY_SESSION_VARIANT === "assistant";
+  if (isAssistantVariant) {
+    try {
+      const { bootstrapAssistantHome } = await Promise.resolve().then(function () { return require('./bootstrap-CkgIq8N3.cjs'); });
+      await bootstrapAssistantHome();
+    } catch (error) {
+      logger.logger.debug("[START] Assistant home bootstrap failed:", error);
+    }
+  }
+  logger.logger.debug(`[START] Happy process started pid=${process.pid} node=${process.version} cwd=${workingDirectory}`);
+  logger.logger.debug(`[START] Options: startedBy=${options.startedBy}, startingMode=${options.startingMode}`);
+  if (options.startedBy === "daemon" && options.startingMode === "local") {
+    throw new Error("Daemon-spawned sessions cannot use local/interactive mode. Use --happy-starting-mode remote or spawn sessions directly from terminal.");
+  }
+  let depsLoadPromise = null;
+  const loadDeps = () => {
+    if (!depsLoadPromise) {
+      depsLoadPromise = importRunClaudeDeps();
+      depsLoadPromise.catch(() => {
+      });
+    }
+    return depsLoadPromise;
+  };
+  const reconnectRequested = Boolean(
+    process.env.HAPPY_RECONNECT_SESSION_ID && process.env.HAPPY_RECONNECT_ENCRYPTION_KEY && process.env.HAPPY_RECONNECT_ENCRYPTION_VARIANT
+  );
+  const startupPlan$1 = startupPlan.planClaudeStartup({ startedBy: options.startedBy, reconnect: reconnectRequested });
+  api.connectionState.setBackend("Claude");
+  const api$1 = await api.ApiClient.create(credentials);
+  let state = {};
+  const settings = await persistence.readSettings();
+  let machineId = settings?.machineId;
+  const sandboxConfig = options.noSandbox ? void 0 : settings?.sandboxConfig;
+  const sandboxEnabled = Boolean(sandboxConfig?.enabled);
+  const initialPermissionMode = permissionMode.applySandboxPermissionPolicy(
+    permissionMode.resolveInitialClaudePermissionMode(options.permissionMode ?? defaultPermissionMode.DEFAULT_CLAUDE_PERMISSION_MODE, options.claudeArgs),
+    sandboxEnabled
+  );
+  const dangerouslySkipPermissions = initialPermissionMode === "bypassPermissions" || initialPermissionMode === "yolo" || sandboxEnabled || Boolean(options.claudeArgs?.includes("--dangerously-skip-permissions"));
+  if (!machineId) {
+    console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/Mereithhh/very-happy/issues`);
+    process.exit(1);
+  }
+  logger.logger.debug(`Using machineId: ${machineId}`);
+  const sessionTag = node_crypto.randomUUID();
+  if (startupPlan$1.registerMachine) {
+    await api$1.getOrCreateMachine({
+      machineId,
+      metadata: machineMetadata.getInitialMachineMetadata()
+    });
+  }
+  const forkedFromSessionId = process.env.HAPPY_FORKED_FROM_SESSION_ID;
+  const forkedFromMessageId = process.env.HAPPY_FORKED_FROM_MESSAGE_ID;
+  const importedFromClaudeSessionId = process.env.HAPPY_IMPORTED_FROM_CLAUDE_SESSION_ID;
+  const importTitle = process.env.HAPPY_IMPORT_TITLE;
+  const originTags = createSessionMetadata.spawnOriginTags(process.env, "claude");
+  let metadata = {
+    path: workingDirectory,
+    host: os.hostname(),
+    version: _package.packageJson.version,
+    os: os.platform(),
+    machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.configuration.happyHomeDir,
+    happyLibDir: projectPath.projectPath(),
+    happyToolsDir: path.resolve(projectPath.projectPath(), "tools", "unpacked"),
+    startedFromDaemon: options.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: options.startedBy || "terminal",
+    // Initialize lifecycle state
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: "claude",
+    ...process.env.VH_TEAM_OPERATION_ID ? { teamOperationId: process.env.VH_TEAM_OPERATION_ID } : {},
+    // Advertise composer support before the first SDK response. Otherwise
+    // a brand-new session cannot pick a PDF until after sending once.
+    attachmentKinds: [...attachmentContent.CLAUDE_ATTACHMENT_KINDS],
+    queueCancellation: true,
+    capabilities: ["claude-steer-v1", "claude-live-permission-v1", "claude-live-permission-v2", "claude-btw-v1", "claude-runtime-controls-v1", "claude-opus-5-5-v1", index.PROMPT_QUEUE_CAPABILITY],
+    // Effective mode this process enforces. Kept current by
+    // publishPermissionMode below; the web renders it instead of guessing.
+    permissionMode: permissionMode.mapToClaudeMode(initialPermissionMode ?? "default"),
+    sandbox: sandboxConfig?.enabled ? sandboxConfig : null,
+    dangerouslySkipPermissions,
+    ...forkedFromSessionId ? { parentSessionId: forkedFromSessionId } : {},
+    ...forkedFromMessageId ? { forkedFromMessageId } : {},
+    ...importedFromClaudeSessionId ? { importedFromClaudeSessionId } : {},
+    ...importTitle ? { summary: { text: importTitle, updatedAt: Date.now() } } : {},
+    ...isAssistantVariant ? { variant: "assistant" } : {},
+    // B-091/B-303: dispatched sessions (daemon spawn RPC exports
+    // HAPPY_SPAWNED_BY, B-069) are born tagged with their spawn origin so
+    // every list shows where the work came from. NOT on the meta-agent
+    // itself — that one is the variant above and never joins the lists at
+    // all. (Shared helper: the other flavors get the same tag via
+    // createSessionMetadata.)
+    ...originTags ? { tags: originTags } : {}
+  };
+  const reconnectSessionId = process.env.HAPPY_RECONNECT_SESSION_ID;
+  const reconnectKeyBase64 = process.env.HAPPY_RECONNECT_ENCRYPTION_KEY;
+  const reconnectVariant = process.env.HAPPY_RECONNECT_ENCRYPTION_VARIANT;
+  const reconnectSeq = process.env.HAPPY_RECONNECT_SEQ;
+  const reconnectMetadataVersion = process.env.HAPPY_RECONNECT_METADATA_VERSION;
+  const reconnectAgentStateVersion = process.env.HAPPY_RECONNECT_AGENT_STATE_VERSION;
+  let response;
+  if (reconnectSessionId && reconnectKeyBase64 && reconnectVariant) {
+    logger.logger.debug(`[START] Reconnecting to existing session ${reconnectSessionId}`);
+    response = {
+      id: reconnectSessionId,
+      seq: parseInt(reconnectSeq || "0", 10),
+      encryptionKey: authRelay.decodeBase64(reconnectKeyBase64),
+      encryptionVariant: reconnectVariant,
+      metadata,
+      metadataVersion: parseInt(reconnectMetadataVersion || "0", 10),
+      agentState: state,
+      agentStateVersion: parseInt(reconnectAgentStateVersion || "0", 10)
+    };
+  } else {
+    response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+  }
+  if (!response) {
+    let offlineSessionId = null;
+    const { claudeLocal } = await Promise.resolve().then(function () { return require('./claudeLocal-BDuGFnjJ.cjs'); });
+    const { createSessionScanner: createSessionScanner2 } = await loadDeps();
+    const reconnection = api.startOfflineReconnection({
+      serverUrl: configuration.configuration.serverUrl,
+      onReconnected: async () => {
+        const resp = await api$1.getOrCreateSession({ tag: node_crypto.randomUUID(), metadata, state });
+        if (!resp) throw new Error("Server unavailable");
+        const session2 = api$1.sessionSyncClient(resp);
+        const scanner = await createSessionScanner2({
+          sessionId: null,
+          workingDirectory,
+          onMessage: (msg) => session2.sendClaudeSessionMessage(msg)
+        });
+        if (offlineSessionId) scanner.onNewSession(offlineSessionId);
+        return { session: session2, scanner };
+      },
+      onNotify: console.log,
+      onCleanup: () => {
+      }
+    });
+    try {
+      await claudeLocal({
+        path: workingDirectory,
+        sessionId: null,
+        onSessionFound: (id) => {
+          offlineSessionId = id;
+        },
+        onThinkingChange: () => {
+        },
+        abort: new AbortController().signal,
+        claudeEnvVars: options.claudeEnvVars,
+        claudeArgs: options.claudeArgs,
+        mcpServers: {},
+        allowedTools: [],
+        sandboxConfig
+      });
+    } finally {
+      reconnection.cancel();
+    }
+    process.exit(0);
+  }
+  logger.logger.debug(`Session created: ${response.id}`);
+  await sessionLock.claimSessionOrExit(response.id, { takeover: !!reconnectSessionId, flavor: "claude" });
+  if (reconnectSessionId && !await api$1.reactivateSession(response.id)) {
+    throw new Error(`Failed to reactivate archived session ${response.id}`);
+  }
+  let reconnectSeeded = false;
+  if (reconnectSessionId) {
+    const snapshot = await api$1.getSession(response.id, response.encryptionKey, response.encryptionVariant);
+    if (snapshot.ok) {
+      response = sessionLock.applyServerSnapshot(response, snapshot.session);
+      reconnectSeeded = true;
+      logger.logger.debug(`[START] Reconnect seeded from server: seq=${snapshot.session.seq} metadataVersion=${snapshot.session.metadataVersion}`);
+    } else {
+      response = sessionLock.withoutServerSnapshot(response);
+      logger.logger.debug(`[START] Reconnect without server snapshot (${snapshot.reason}); skipping existing messages`);
+    }
+  }
+  const earlySession = startupPlan$1.sessionClientBeforeWebhook ? api$1.sessionSyncClient(response) : null;
+  try {
+    logger.logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await controlClient.notifyDaemonSessionStarted(response.id, metadata, {
+      encryptionKey: authRelay.encodeBase64(response.encryptionKey),
+      encryptionVariant: response.encryptionVariant,
+      seq: response.seq,
+      metadataVersion: response.metadataVersion,
+      agentStateVersion: response.agentStateVersion
+    });
+    if (result.error) {
+      logger.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+    } else {
+      logger.logger.debug(`[START] Reported session ${response.id} to daemon`);
+    }
+  } catch (error) {
+    logger.logger.debug("[START] Failed to report to daemon (may not be running):", error);
+  }
+  loadDeps();
+  if (!startupPlan$1.registerMachine) {
+    void Promise.resolve().then(() => api$1.getOrCreateMachine({ machineId, metadata: machineMetadata.getInitialMachineMetadata() })).catch((error) => logger.logger.debug("[START] Background machine registration failed:", error));
+  }
+  let deps;
+  try {
+    deps = await loadDeps();
+  } catch (error) {
+    logger.logger.warn(`[START] Failed to load the Claude runner modules for session ${response.id}; marking it offline and exiting: ${error instanceof Error ? error.message : String(error)}`);
+    try {
+      await earlySession?.close();
+    } catch {
+    }
+    try {
+      await api$1.deactivateSession(response.id);
+    } catch {
+    }
+    process.exit(1);
+  }
+  const {
+    loop,
+    MessageQueue2,
+    claudeModeHash,
+    parseSpecialCommand,
+    getEnvironmentInfo,
+    startHappyServer,
+    startHookServer,
+    EditReportThrottle,
+    extractClaudeEditPaths,
+    reportSessionEditToDaemon,
+    generateHookSettingsFile,
+    cleanupHookSettingsFile,
+    registerKillSessionHandler,
+    SessionExitGate,
+    exitIntentFromArchiveFlag,
+    settleSessionOnExit,
+    registerSideQuestionHandler,
+    writeSideQuestionSettingsFile,
+    claudeCheckSession,
+    createSessionScanner,
+    getProjectPath,
+    RawJSONLinesSchema,
+    TitleGenerator,
+    BoardAnalyzer,
+    FileRateLimiter,
+    createSelfReportState,
+    withAssistantDenylist,
+    contentLogMetadata,
+    resolveMessageMode,
+    claudePrewarmEligibility,
+    claudePrewarmSessionEligibility,
+    prewarmCacheFile,
+    readPrewarmCache,
+    writePrewarmCache,
+    prewarmPredictionMeta,
+    evaluatePrewarmPrediction,
+    acquirePrewarmSlot,
+    prewarmSlotDir,
+    PrewarmHookGate,
+    createClaudePrewarmLease,
+    disposeAllClaudePrewarms,
+    formatPrewarmLine
+  } = deps;
+  logger.logger.debugLargeJson("[START] Happy process started", getEnvironmentInfo());
+  const session = earlySession ?? api$1.sessionSyncClient(response, reconnectSeeded ? { initialSeq: response.seq } : void 0);
+  if (reconnectSessionId) {
+    session.suppressNextArchiveSignal();
+    if (!reconnectSeeded) session.skipExistingMessages();
+    void session.cancelUndeliveredQueuedInputs();
+    session.updateMetadata((meta) => ({
+      ...sessionLock.mergeReconnectMetadata(meta, metadata, Date.now()),
+      queueCancellation: true,
+      // B-262 batch 2 (B5): a reconnected process re-publishes the mode
+      // IT enforces; the server copy may still carry the previous
+      // process's value.
+      permissionMode: permissionMode.mapToClaudeMode(initialPermissionMode ?? "default")
+    }));
+  }
+  const forkClaudeSessionId = process.env.HAPPY_FORK_CLAUDE_SESSION_ID;
+  if (!reconnectSessionId && forkClaudeSessionId) {
+    const jsonlPath = path.join(getProjectPath(workingDirectory), `${forkClaudeSessionId}.jsonl`);
+    try {
+      const file = await promises.readFile(jsonlPath, "utf-8");
+      const lines = file.split("\n");
+      let backfilled = 0;
+      for (const line of lines) {
+        if (line.trim().length === 0) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const result = RawJSONLinesSchema.safeParse(parsed);
+        if (!result.success) continue;
+        session.sendClaudeSessionMessage(result.data);
+        backfilled += 1;
+      }
+      logger.logger.debug(`[FORK BACKFILL] Replayed ${backfilled} historical messages from ${jsonlPath}`);
+      session.updateMetadata((meta) => ({ ...meta, claudeSessionId: forkClaudeSessionId }));
+    } catch (error) {
+      logger.logger.debug(`[FORK BACKFILL] Failed to read ${jsonlPath}:`, error);
+    }
+  }
+  const recentAppPromptsMaxAgeMs = 5 * 60 * 1e3;
+  const recentAppPrompts = [];
+  const promptDedupeKey = (text) => attachmentContent.stripAttachmentManifest(text).trim();
+  const recordAppPrompt = (text) => {
+    const now = Date.now();
+    recentAppPrompts.push({ text: promptDedupeKey(text), addedAt: now });
+    const cutoff = now - recentAppPromptsMaxAgeMs;
+    while (recentAppPrompts.length > 0 && recentAppPrompts[0].addedAt < cutoff) {
+      recentAppPrompts.shift();
+    }
+  };
+  const consumeAppPrompt = (text) => {
+    const cutoff = Date.now() - recentAppPromptsMaxAgeMs;
+    const key = promptDedupeKey(text);
+    for (let i = 0; i < recentAppPrompts.length; i++) {
+      const entry = recentAppPrompts[i];
+      if (entry.addedAt < cutoff) continue;
+      if (entry.text === key) {
+        recentAppPrompts.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  };
+  let currentRunMode = options.startingMode ?? "local";
+  const titleGenerator = new TitleGenerator(session);
+  const boardSelfReport = createSelfReportState();
+  const boardAnalyzer = new BoardAnalyzer(session, {
+    enabled: settings?.boardLlm === true,
+    selfReportState: boardSelfReport,
+    fetchTasks: async () => {
+      const item = await api$1.kvGet("vh.board-tasks.v1");
+      if (!item) return null;
+      try {
+        const parsed = JSON.parse(Buffer.from(item.value, "base64").toString("utf8"));
+        if (!Array.isArray(parsed.tasks)) return null;
+        return parsed.tasks.filter((t) => typeof t?.id === "string" && typeof t?.title === "string" && t.status === "open").map((t) => ({ id: t.id, title: t.title }));
+      } catch {
+        return null;
+      }
+    },
+    rateLimiter: new FileRateLimiter(path.resolve(configuration.configuration.happyHomeDir, "board-analyzer-rate.json"))
+  });
+  session.on("claude-session-message", (body) => boardAnalyzer.noteClaudeMessage(body));
+  session.on("turn-ended", () => boardAnalyzer.onTurnEnd());
+  const editThrottle = new EditReportThrottle();
+  session.on("claude-session-message", (body) => {
+    try {
+      for (const edit of editThrottle.take(extractClaudeEditPaths(body))) {
+        reportSessionEditToDaemon({ sessionId: response.id, path: edit.path, tool: edit.tool, cwd: workingDirectory, ...edit.at !== void 0 ? { at: edit.at } : {} });
+      }
+    } catch (error) {
+      logger.logger.debug("[START] edit report failed:", error);
+    }
+  });
+  options = { ...options, claudeEnvVars: { ...options.claudeEnvVars, VH_PEER_SESSION_ID: response.id } };
+  const initialScannerSessionId = forkClaudeSessionId ?? (metadata.claudeSessionId ?? null);
+  const remoteScanner = await createSessionScanner({
+    sessionId: initialScannerSessionId,
+    workingDirectory,
+    onMessage: (raw) => {
+      if (currentRunMode !== "remote") return;
+      if (raw.type !== "user") return;
+      if (raw.isSidechain) return;
+      const content = raw.message?.content;
+      if (typeof content !== "string") return;
+      if (content.trim().length === 0) return;
+      if (consumeAppPrompt(content)) return;
+      titleGenerator.maybeGenerate(content);
+      boardAnalyzer.noteUserMessage(content);
+      session.sendClaudeSessionMessage(raw);
+    }
+  });
+  const happyServer = await startHappyServer(session, { assistant: isAssistantVariant, selfReportState: boardSelfReport });
+  logger.logger.debug(`[START] Happy MCP server started at ${happyServer.url}`);
+  let currentSession = null;
+  const prewarmHookGate = new PrewarmHookGate();
+  let scannerAnnouncedSessionId = null;
+  const announceSessionToScanner = (sessionId) => {
+    if (sessionId === scannerAnnouncedSessionId) return;
+    scannerAnnouncedSessionId = sessionId;
+    void Promise.resolve(remoteScanner.onNewSession(sessionId, { treatExistingAsProcessed: true })).catch((error) => logger.logger.debug("[START] remote scanner onNewSession failed:", error));
+  };
+  const hookServer = await startHookServer({
+    onSessionHook: (sessionId, data, hookMeta) => {
+      if (!prewarmHookGate.accepts(hookMeta?.source)) {
+        logger.logger.debug(`[START] Session hook from an unadopted warm Claude process ignored (${hookMeta?.source})`);
+        return;
+      }
+      logger.logger.debug(`[START] Session hook received: ${sessionId}`, contentLogMetadata(data));
+      announceSessionToScanner(sessionId);
+      if (currentSession) {
+        const previousSessionId = currentSession.sessionId;
+        if (previousSessionId !== sessionId) {
+          logger.logger.debug(`[START] Claude session ID changed: ${previousSessionId} -> ${sessionId}`);
+          currentSession.onSessionFound(sessionId);
+        }
+      }
+    }
+  });
+  logger.logger.debug(`[START] Hook server started on port ${hookServer.port}`);
+  const hookSettingsPath = generateHookSettingsFile(hookServer.port);
+  logger.logger.debug(`[START] Generated hook settings file: ${hookSettingsPath}`);
+  const logPath = logger.logger.logFilePath;
+  logger.logger.infoDeveloper(`Session: ${response.id}`);
+  logger.logger.infoDeveloper(`Logs: ${logPath}`);
+  session.updateAgentState((currentState) => ({
+    ...currentState,
+    controlledByUser: options.startingMode !== "remote"
+  }));
+  const messageQueue = new MessageQueue2(claudeModeHash);
+  const promptQueueDrain = session.attachPromptQueueDrain({
+    isIdle: () => messageQueue.size() === 0 && messageQueue.isWaiting()
+  });
+  messageQueue.setOnWait(() => promptQueueDrain.onIdle());
+  messageQueue.setOnDiscard((entries) => {
+    const byReason = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (!entry.sourceId) continue;
+      const list = byReason.get(entry.reason) ?? [];
+      list.push(entry.sourceId);
+      byReason.set(entry.reason, list);
+    }
+    for (const [reason, keys] of byReason) session.sendQueueCancelReason(keys, reason);
+  });
+  session.rpcHandlerManager.registerHandler("cancelQueuedMessage", async (params) => ({
+    removed: messageQueue.cancelPending(
+      typeof params?.localKey === "string" ? params.localKey : void 0,
+      typeof params?.text === "string" ? params.text : void 0
+    )
+  }));
+  let currentPermissionMode = initialPermissionMode;
+  let publishedPermissionMode = permissionMode.mapToClaudeMode(initialPermissionMode ?? "default");
+  const publishPermissionMode = (mode) => {
+    currentPermissionMode = mode;
+    const published = permissionMode.mapToClaudeMode(mode ?? "default");
+    if (published === publishedPermissionMode) return;
+    publishedPermissionMode = published;
+    session.updateMetadata((meta) => ({ ...meta, permissionMode: published }));
+  };
+  const publishEffectivePermissionMode = (effective) => {
+    const decision = permissionMode.reconcilePublishedPermissionMode({
+      intent: permissionMode.mapToClaudeMode(currentPermissionMode ?? "default"),
+      published: publishedPermissionMode,
+      effective
+    });
+    if (!decision) return;
+    if (decision.mismatch) {
+      logger.logger.warn(`[loop] Claude Code enforces permission mode '${effective}' but this process asked for '${permissionMode.mapToClaudeMode(currentPermissionMode ?? "default")}' \u2014 check ~/.claude settings (permissions.deny/ask/defaultMode/disableBypassPermissionsMode). Publishing the effective mode.`);
+    }
+    if (decision.publish !== publishedPermissionMode) {
+      publishedPermissionMode = decision.publish;
+      session.updateMetadata((meta) => ({ ...meta, permissionMode: decision.publish }));
+    }
+  };
+  let lastExplicitModeSwitchAt = 0;
+  let currentModel = options.model ?? DEFAULT_CLAUDE_MODEL;
+  let currentFallbackModel = void 0;
+  let currentCustomSystemPrompt = void 0;
+  let currentAppendSystemPrompt = void 0;
+  let currentAllowedTools = void 0;
+  let currentDisallowedTools = withAssistantDenylist(void 0, isAssistantVariant);
+  let currentEffort = DEFAULT_CLAUDE_EFFORT;
+  registerSideQuestionHandler(session.rpcHandlerManager, {
+    getClaudeSessionId: () => {
+      const id = currentSession?.sessionId ?? null;
+      return id && claudeCheckSession(id, workingDirectory) ? id : null;
+    },
+    getModel: () => currentModel,
+    cwd: workingDirectory,
+    getEnv: () => options.claudeEnvVars,
+    settingsPath: writeSideQuestionSettingsFile(configuration.configuration.happyHomeDir),
+    // B-482: in remote mode the launcher parks the live Query's /btw entry
+    // on the session while the Query is alive; local mode never sets it.
+    getLiveQuery: () => currentSession?.getSideQuestionLive() ?? null
+  });
+  const resetCurrentModeDefaults = () => {
+    currentModel = options.model ?? DEFAULT_CLAUDE_MODEL;
+    currentFallbackModel = void 0;
+    currentCustomSystemPrompt = void 0;
+    currentAppendSystemPrompt = void 0;
+    currentAllowedTools = void 0;
+    currentDisallowedTools = withAssistantDenylist(void 0, isAssistantVariant);
+    currentEffort = DEFAULT_CLAUDE_EFFORT;
+    logger.logger.debug("[loop] Reset current mode defaults after abort");
+  };
+  const currentModeState = () => ({
+    permissionMode: currentPermissionMode,
+    model: currentModel,
+    fallbackModel: currentFallbackModel,
+    customSystemPrompt: currentCustomSystemPrompt,
+    appendSystemPrompt: currentAppendSystemPrompt,
+    allowedTools: currentAllowedTools,
+    disallowedTools: currentDisallowedTools,
+    effort: currentEffort
+  });
+  const prewarmCachePath = prewarmCacheFile(configuration.configuration.happyHomeDir);
+  let prewarmCache = readPrewarmCache(prewarmCachePath);
+  const prewarmSessionInput = {
+    env: { ...process.env, ...prewarmSpawnEnv },
+    startedBy: options.startedBy,
+    startingMode: options.startingMode,
+    claudeArgs: options.claudeArgs,
+    setting: settings?.claudePrewarm
+  };
+  const prewarmCtx = () => ({ sandboxEnabled, isAssistantVariant, staleModeSnapshot: false });
+  const predictFirstMessageMode = () => prewarmCache ? resolveMessageMode(currentModeState(), prewarmPredictionMeta(prewarmCache), prewarmCtx()).mode : null;
+  let firstMessageScored = false;
+  const scoreFirstMessage = (meta, predicted, actual) => {
+    if (firstMessageScored) return;
+    firstMessageScored = true;
+    if (meta?.sentFrom !== "web") return;
+    if (!claudePrewarmSessionEligibility({ ...prewarmSessionInput, env: { ...process.env, ...prewarmSpawnEnv } }).eligible) return;
+    const { outcome, next } = evaluatePrewarmPrediction({ predicted, actual, meta, previous: prewarmCache });
+    logger.logger.debug(`[CLAUDE PREWARM] prediction ${outcome}${next ? ` consecutiveMisses=${next.consecutiveMisses}` : ""}`);
+    if (next && writePrewarmCache(prewarmCachePath, next)) prewarmCache = next;
+  };
+  let userMessageSeen = false;
+  const prewarmTagFiles = /* @__PURE__ */ new Set();
+  const createPrewarm = () => {
+    const eligibility = claudePrewarmEligibility({
+      ...prewarmSessionInput,
+      env: { ...process.env, ...prewarmSpawnEnv },
+      cache: prewarmCache
+    });
+    if (!eligibility.eligible) {
+      logger.logger.debug(formatPrewarmLine("skipped", eligibility.reason));
+      return null;
+    }
+    if (userMessageSeen) {
+      logger.logger.debug(formatPrewarmLine("skipped", "message-already-received"));
+      return null;
+    }
+    const slot = acquirePrewarmSlot(prewarmSlotDir(configuration.configuration.happyHomeDir));
+    if (!slot) {
+      logger.logger.debug(formatPrewarmLine("skipped", "concurrency-limit"));
+      return null;
+    }
+    const predicted = predictFirstMessageMode();
+    if (!predicted) {
+      slot.release();
+      return null;
+    }
+    const tag = prewarmHookGate.newTag();
+    let tagHookSettingsPath;
+    try {
+      tagHookSettingsPath = generateHookSettingsFile(hookServer.port, tag);
+    } catch (error) {
+      slot.release();
+      logger.logger.debug(formatPrewarmLine("skipped", "hook-settings"));
+      return null;
+    }
+    prewarmTagFiles.add(tagHookSettingsPath);
+    return createClaudePrewarmLease({
+      mode: predicted,
+      hookSettingsPath: tagHookSettingsPath,
+      tag,
+      gate: prewarmHookGate,
+      slot,
+      // Only removed on discard: an adopted process keeps reading its
+      // settings file (later SessionStart events, e.g. /compact); it goes
+      // with the other hook files at exit.
+      cleanupHookSettings: () => {
+        cleanupHookSettingsFile(tagHookSettingsPath);
+        prewarmTagFiles.delete(tagHookSettingsPath);
+      },
+      log: (line) => logger.logger.debug(line)
+    });
+  };
+  const cleanupPrewarm = () => {
+    disposeAllClaudePrewarms("shutdown");
+    for (const file of prewarmTagFiles) cleanupHookSettingsFile(file);
+    prewarmTagFiles.clear();
+  };
+  session.onFileEvent((fileEvent) => {
+    const ev = fileEvent.content.data.ev;
+    logger.logger.debug(`[loop] File event received: ${ev.name} (${ev.size} bytes, ref: ${ev.ref})`);
+    const downloadPromise = (async () => {
+      try {
+        const decrypted = await session.downloadAndDecryptAttachment(ev.ref);
+        if (!decrypted) {
+          logger.logger.debug(`[loop] Failed to decrypt attachment: ${ev.name}`);
+          return null;
+        }
+        logger.logger.debug(`[loop] Attachment decrypted: ${ev.name} (${decrypted.length} bytes)`);
+        return { data: decrypted, mimeType: ev.mimeType ?? "image/jpeg", name: ev.name };
+      } catch (error) {
+        logger.logger.debug(`[loop] Failed to download attachment: ${ev.name}`, { error });
+        return null;
+      }
+    })();
+    session.trackAttachmentDownload(downloadPromise);
+  });
+  session.onUserMessage(async (message) => {
+    userMessageSeen = true;
+    if (message?.content?.text) {
+      titleGenerator.maybeGenerate(message.content.text);
+      boardAnalyzer.noteUserMessage(message.content.text);
+    }
+    const attachmentsForThisMessage = await session.drainAttachmentsForUserMessage();
+    const messageCreatedAt = message.createdAt;
+    const staleModeSnapshot = message.meta?.permissionMode !== void 0 && typeof messageCreatedAt === "number" && messageCreatedAt < lastExplicitModeSwitchAt;
+    if (staleModeSnapshot) {
+      logger.logger.debug(`[loop] Ignoring stale meta.permissionMode=${message.meta?.permissionMode} (message ${messageCreatedAt} predates explicit switch ${lastExplicitModeSwitchAt}); keeping ${currentPermissionMode}`);
+    }
+    const previousPermissionMode = currentPermissionMode;
+    const predictedFirstMode = firstMessageScored ? null : predictFirstMessageMode();
+    const resolved = resolveMessageMode(currentModeState(), message.meta, { sandboxEnabled, isAssistantVariant, staleModeSnapshot });
+    if ("publishPermissionMode" in resolved) {
+      publishPermissionMode(resolved.publishPermissionMode);
+      const ignoredDefaultDowngrade = (previousPermissionMode === "bypassPermissions" || previousPermissionMode === "yolo") && message.meta?.permissionMode === "default" && currentPermissionMode === previousPermissionMode;
+      logger.logger.debug(ignoredDefaultDowngrade ? `[loop] Ignoring permission mode downgrade from ${previousPermissionMode} to default` : `[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
+    }
+    currentModel = resolved.next.model;
+    currentFallbackModel = resolved.next.fallbackModel;
+    currentCustomSystemPrompt = resolved.next.customSystemPrompt;
+    currentAppendSystemPrompt = resolved.next.appendSystemPrompt;
+    currentAllowedTools = resolved.next.allowedTools;
+    currentDisallowedTools = resolved.next.disallowedTools;
+    currentEffort = resolved.next.effort;
+    if (resolved.ignoredEffort !== void 0) {
+      logger.logger.debug(`[loop] Ignoring invalid effort from user message: ${resolved.ignoredEffort}`);
+    }
+    logger.logger.debug(`[loop] Message mode: permission=${resolved.mode.permissionMode} model=${resolved.mode.model || "default"} effort=${resolved.mode.effort ?? "default"} appendSystemPrompt=${resolved.mode.appendSystemPrompt ? "set" : "none"} customSystemPrompt=${resolved.mode.customSystemPrompt ? "set" : "none"}`);
+    scoreFirstMessage(message.meta, predictedFirstMode, resolved.mode);
+    const resolvedMode = resolved.mode;
+    const specialCommand = parseSpecialCommand(message.content.text);
+    if (specialCommand.type === "compact") {
+      logger.logger.debug("[start] Detected /compact command");
+      const enhancedMode2 = resolvedMode;
+      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2, attachmentsForThisMessage, message.localKey);
+      logger.logger.debug("[start] /compact command pushed to queue:", {
+        ...contentLogMetadata(message.content.text),
+        attachmentCount: attachmentsForThisMessage?.length ?? 0,
+        hasMetadata: Boolean(message.meta)
+      });
+      return;
+    }
+    if (specialCommand.type === "clear") {
+      logger.logger.debug("[start] Detected /clear command");
+      const enhancedMode2 = resolvedMode;
+      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2, attachmentsForThisMessage, message.localKey);
+      logger.logger.debug("[start] /clear command pushed to queue:", {
+        ...contentLogMetadata(message.content.text),
+        attachmentCount: attachmentsForThisMessage?.length ?? 0,
+        hasMetadata: Boolean(message.meta)
+      });
+      return;
+    }
+    if (specialCommand.type === "mcp" || specialCommand.type === "skills") {
+      if (currentRunMode === "local") {
+        logger.logger.debug(`[start] /${specialCommand.type} in local mode \u2014 passing through to Claude Code`);
+      } else {
+        logger.logger.debug(`[start] Detected /${specialCommand.type} command in remote mode`);
+        const metadata2 = session.getMetadata();
+        let responseText;
+        if (specialCommand.type === "mcp") {
+          const servers = metadata2?.mcpServers;
+          if (servers && servers.length > 0) {
+            responseText = "**MCP Servers**\n\n" + servers.map((s) => `- **${s.name}** \u2014 ${s.status}`).join("\n");
+          } else {
+            responseText = "No MCP servers configured. Session may still be initializing \u2014 try again after sending a message.";
+          }
+        } else {
+          const skills = metadata2?.skills ?? metadata2?.slashCommands;
+          if (skills && skills.length > 0) {
+            responseText = "**Available Skills**\n\n" + skills.map((s) => `- /${s}`).join("\n");
+          } else {
+            responseText = "No skills available. Session may still be initializing \u2014 try again after sending a message.";
+          }
+        }
+        session.sendClaudeSessionMessage({
+          type: "assistant",
+          uuid: node_crypto.randomUUID(),
+          parentUuid: null,
+          isSidechain: false,
+          sessionId: session.sessionId || "unknown",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          message: {
+            role: "assistant",
+            model: "system",
+            content: [{ type: "text", text: responseText }]
+          }
+        });
+        return;
+      }
+    }
+    const enhancedMode = resolvedMode;
+    if (message.meta?.delivery === "steer" && currentRunMode === "remote") {
+      const accepted = await currentSession?.trySteer({
+        message: message.content.text,
+        mode: enhancedMode,
+        attachments: attachmentsForThisMessage
+      }) === true;
+      if (accepted) {
+        logger.logger.debug("User message steered into current turn:", {
+          ...contentLogMetadata(message.content.text),
+          attachmentCount: attachmentsForThisMessage?.length ?? 0
+        });
+        return;
+      }
+      logger.logger.debug("[start] Steer arrived without a compatible live turn; falling back to queue");
+    }
+    messageQueue.push(message.content.text, enhancedMode, attachmentsForThisMessage, message.localKey);
+    logger.logger.debug("User message pushed to queue:", {
+      ...contentLogMetadata(message.content.text),
+      attachmentCount: attachmentsForThisMessage?.length ?? 0,
+      hasMetadata: Boolean(message.meta)
+    });
+  });
+  const exitGate = new SessionExitGate();
+  const cleanup = async (opts = { archive: true }) => {
+    const intent = exitGate.claim(exitIntentFromArchiveFlag(opts.archive));
+    if (intent === null) {
+      logger.logger.debug(`[START] Termination (archive=${opts.archive ?? true}) ignored: cleanup already running as ${exitGate.current}`);
+      return;
+    }
+    logger.logger.debug(`[START] Received termination signal, cleaning up (archive=${intent === "archive"})...`);
+    promptQueueDrain.close();
+    cleanupPrewarm();
+    try {
+      if (session) {
+        currentSession?.cleanup();
+        await settleSessionOnExit(session.sessionId, intent, {
+          updateMetadata: (handler) => session.updateMetadata(handler),
+          sendSessionDeath: () => session.sendSessionDeath(),
+          archiveSession: (id) => api$1.archiveSession(id),
+          deactivateSession: (id) => api$1.deactivateSession(id),
+          log: (message, ...args) => logger.logger.debug(message, ...args)
+        });
+        await session.flush();
+        await session.close();
+      }
+      happyServer.stop();
+      hookServer.stop();
+      cleanupHookSettingsFile(hookSettingsPath);
+      await remoteScanner.cleanup();
+      logger.logger.debug("[START] Cleanup complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      logger.logger.debug("[START] Error during cleanup:", error);
+      process.exit(1);
+    }
+  };
+  process.on("SIGTERM", () => {
+    void cleanup({ archive: false });
+  });
+  process.on("SIGINT", () => {
+    void cleanup({ archive: false });
+  });
+  process.on("uncaughtException", (error) => {
+    logger.logger.debug("[START] Uncaught exception:", error);
+    if (currentSession?.isAborting()) {
+      logger.logger.debug("[START] Uncaught exception during abort teardown \u2014 swallowing, not archiving");
+      return;
+    }
+    void cleanup({ archive: true });
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger.logger.debug("[START] Unhandled rejection:", reason);
+    if (currentSession?.isAborting()) {
+      logger.logger.debug("[START] Unhandled rejection during abort teardown \u2014 swallowing, not archiving");
+      return;
+    }
+    void cleanup({ archive: true });
+  });
+  registerKillSessionHandler(session.rpcHandlerManager, () => cleanup({ archive: true }), session);
+  const exitCode = await loop({
+    path: workingDirectory,
+    model: options.model,
+    permissionMode: initialPermissionMode,
+    startingMode: options.startingMode,
+    messageQueue,
+    api: api$1,
+    allowedTools: happyServer.toolNames.map((toolName) => `mcp__happy__${toolName}`),
+    onModeChange: (newMode) => {
+      currentRunMode = newMode;
+      session.sendSessionEvent({ type: "switch", mode: newMode });
+      session.updateAgentState((currentState) => ({
+        ...currentState,
+        controlledByUser: newMode === "local"
+      }));
+    },
+    onSessionReady: (sessionInstance) => {
+      currentSession = sessionInstance;
+      sessionInstance.addSessionFoundCallback?.(announceSessionToScanner);
+    },
+    // B-515: lease for a warm Claude process, taken once by the first
+    // remote launch (null when not eligible).
+    claudePrewarm: createPrewarm,
+    // B-355: remember exactly what the SDK is about to write to the Claude
+    // transcript, so the JSONL scanner below recognises it as ours.
+    onPromptFinalized: recordAppPrompt,
+    onAbort: resetCurrentModeDefaults,
+    onPermissionModeChange: (mode) => {
+      lastExplicitModeSwitchAt = Date.now();
+      publishPermissionMode(mode);
+      logger.logger.debug(`[loop] Permission mode updated from session RPC / approval to: ${mode}`);
+    },
+    onEffectivePermissionMode: (mode) => publishEffectivePermissionMode(mode),
+    mcpServers: {
+      "happy": {
+        type: "http",
+        url: happyServer.url
+      }
+    },
+    session,
+    claudeEnvVars: options.claudeEnvVars,
+    claudeArgs: options.claudeArgs,
+    sandboxConfig,
+    hookSettingsPath,
+    jsRuntime: options.jsRuntime
+  });
+  currentSession?.cleanup();
+  cleanupPrewarm();
+  session.sendSessionDeath();
+  logger.logger.debug("Waiting for socket to flush...");
+  await session.flush();
+  logger.logger.debug("Closing session...");
+  await session.close();
+  happyServer.stop();
+  logger.logger.debug("Stopped Happy MCP server");
+  hookServer.stop();
+  cleanupHookSettingsFile(hookSettingsPath);
+  logger.logger.debug("Stopped Hook server and cleaned up settings file");
+  process.exit(exitCode);
+}
+
+exports.runClaude = runClaude;