@cryptiklemur/lattice 1.46.6 → 1.47.0

package/server/src/project/sdk-bridge.ts

@@ -4,7 +4,7 @@ import type { SDKMessage, SDKPartialAssistantMessage, SDKResultMessage, SDKUserM
 import type { CanUseTool, PermissionMode, PermissionResult, PermissionUpdate } from "@anthropic-ai/claude-agent-sdk";
 type MessageParam = SDKUserMessage["message"];
 import type { Attachment } from "@lattice/shared";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, readdirSync, readlinkSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { sendTo, broadcast } from "../ws/broadcast";
@@ -15,6 +15,21 @@ import { guessContextWindow, getSessionTitle, renameSession, listSessions, inval
 import { getLatticeHome, loadConfig } from "../config";
 import { log } from "../logger";
 import { getDailySpend, invalidateDailySpendCache } from "../analytics/engine";
+import { getWarmupModels } from "./warmup";
+import { execSync } from "node:child_process";
+
+var claudeExePath: string | null = null;
+
+function getClaudeExecutablePath(): string {
+  if (claudeExePath) return claudeExePath;
+  try {
+    claudeExePath = execSync("which claude", { encoding: "utf-8" }).trim();
+    log.chat("Using system claude: %s", claudeExePath);
+  } catch {
+    claudeExePath = "claude";
+  }
+  return claudeExePath;
+}
 
 interface PendingPermission {
   resolve: (result: PermissionResult) => void;
@@ -28,6 +43,15 @@ interface PendingPermission {
 }
 
 var pendingPermissions = new Map<string, PendingPermission>();
+
+interface PendingElicitation {
+  resolve: (result: { action: "accept" | "decline"; content?: Record<string, unknown> }) => void;
+  clientId: string;
+  sessionId: string;
+}
+
+var pendingElicitations = new Map<string, PendingElicitation>();
+
 var autoApprovedTools = new Map<string, Set<string>>();
 var sessionPermissionOverrides = new Map<string, PermissionMode>();
 
@@ -49,87 +73,15 @@ export interface ModelEntry {
   displayName: string;
 }
 
-var KNOWN_MODELS: ModelEntry[] = [
-  { value: "default", displayName: "Default" },
-  { value: "opus", displayName: "Opus" },
-  { value: "sonnet", displayName: "Sonnet" },
-  { value: "haiku", displayName: "Haiku" },
-];
-
 export function getAvailableModels(): ModelEntry[] {
-  return KNOWN_MODELS.slice();
+  return getWarmupModels();
 }
 
 var activeStreams = new Map<string, Query>();
 var pendingStreams = new Set<string>();
-var streamMetadata = new Map<string, { projectSlug: string; clientId: string; startedAt: number }>();
+var streamMetadata = new Map<string, { projectSlug: string; clientId: string; startedAt: number; abortController?: AbortController }>();
 var interruptedSessions = new Set<string>();
 
-// Track external lock state so we only broadcast on changes
-var externalLockState = new Map<string, boolean>();
-var watchedSessions = new Set<string>();
-var remoteSessionWatchers = new Map<string, Set<string>>();
-
-/**
- * Start polling a session's lock file for external CLI usage.
- * Called when a client activates a session.
- */
-export function watchSessionLock(sessionId: string): void {
-  watchedSessions.add(sessionId);
-}
-
-/**
- * Stop polling a session's lock file.
- */
-export function unwatchSessionLock(sessionId: string): void {
-  watchedSessions.delete(sessionId);
-  externalLockState.delete(sessionId);
-}
-
-export function addRemoteSessionWatcher(sessionId: string, nodeId: string): void {
-  var watchers = remoteSessionWatchers.get(sessionId);
-  if (!watchers) {
-    watchers = new Set();
-    remoteSessionWatchers.set(sessionId, watchers);
-  }
-  watchers.add(nodeId);
-}
-
-export function getBusyOwner(sessionId: string): "cli" | "lattice" | undefined {
-  if (activeStreams.has(sessionId)) return "lattice";
-  if (isSessionLockedByExternal(sessionId)) return "cli";
-  return undefined;
-}
-
-// Poll every 3 seconds for external lock changes
-setInterval(function () {
-  for (var sessionId of watchedSessions) {
-    var busy = isSessionBusy(sessionId);
-    var prev = externalLockState.get(sessionId) ?? false;
-
-    if (busy !== prev) {
-      externalLockState.set(sessionId, busy);
-      var owner = busy ? getBusyOwner(sessionId) : undefined;
-      broadcast({ type: "session:busy", sessionId, busy: busy, busyOwner: owner });
-
-      var watchers = remoteSessionWatchers.get(sessionId);
-      if (watchers) {
-        var { getPeerConnection } = require("../mesh/connector") as typeof import("../mesh/connector");
-        for (var nodeId of watchers) {
-          var peerWs = getPeerConnection(nodeId);
-          if (peerWs) {
-            peerWs.send(JSON.stringify({
-              type: "mesh:proxy_response",
-              projectSlug: "",
-              requestId: "busy-" + sessionId,
-              payload: { type: "session:busy", sessionId, busy: busy, busyOwner: owner },
-            }));
-          }
-        }
-      }
-    }
-  }
-}, 3000);
 
 function getStreamStatePath(): string {
   return join(getLatticeHome(), "active-streams.json");
@@ -191,6 +143,30 @@ export function cleanupClientPermissions(clientId: string): void {
   }
 }
 
+export function getPendingElicitation(requestId: string): PendingElicitation | undefined {
+  return pendingElicitations.get(requestId);
+}
+
+export function resolveElicitation(requestId: string, result: { action: "accept" | "decline"; content?: Record<string, unknown> }): void {
+  var pending = pendingElicitations.get(requestId);
+  if (!pending) return;
+  pendingElicitations.delete(requestId);
+  pending.resolve(result);
+}
+
+export function cleanupClientElicitations(clientId: string): void {
+  var toRemove: string[] = [];
+  pendingElicitations.forEach(function (entry, requestId) {
+    if (entry.clientId === clientId) {
+      toRemove.push(requestId);
+      entry.resolve({ action: "decline" });
+    }
+  });
+  for (var i = 0; i < toRemove.length; i++) {
+    pendingElicitations.delete(toRemove[i]);
+  }
+}
+
 export function addAutoApprovedTool(sessionId: string, toolName: string): void {
   var tools = autoApprovedTools.get(sessionId);
   if (!tools) {
@@ -212,99 +188,14 @@ export function getActiveStreamCount(): number {
   return activeStreams.size;
 }
 
-export function getActiveSessionCountForProject(projectPath: string): number {
-  var count = 0;
-  var hash = projectPath.replace(/\//g, "-");
-  var dir = join(homedir(), ".claude", "projects", hash);
-
-  for (var [sessionId] of activeStreams) {
-    if (existsSync(join(dir, sessionId + ".jsonl"))) count++;
-  }
-
-  if (cliActiveProjects.has(projectPath)) count++;
-
+export function getActiveStreamCountForProject(projectSlug: string): number {
+  let count = 0;
+  streamMetadata.forEach(function (meta) {
+    if (meta.projectSlug === projectSlug) count++;
+  });
   return count;
 }
 
-/**
- * Check if a session is controlled by an external process (not Lattice).
- * Lattice's own active streams are handled by isProcessing on the client,
- * so this ONLY returns true for external CLI instances.
- */
-export function isSessionBusy(sessionId: string): boolean {
-  if (activeStreams.has(sessionId)) return true;
-  return isSessionLockedByExternal(sessionId);
-}
-
-/**
- * Check if a PID is the Lattice daemon or one of its child processes.
- * The SDK spawns child processes (e.g. claude-agent-sdk/cli.js) that hold
- * lock files — those are NOT external.
- */
-var cliActiveProjects = new Set<string>();
-
-function refreshCliDetection(): void {
-  var newActive = new Set<string>();
-  var cliPids = getClaudeCliPidsAsync();
-  for (var i = 0; i < cliPids.length; i++) {
-    newActive.add(cliPids[i].cwd);
-  }
-  cliActiveProjects = newActive;
-}
-
-function getClaudeCliPidsAsync(): Array<{ pid: number; cwd: string; cmdline: string[] }> {
-  var results: Array<{ pid: number; cwd: string; cmdline: string[] }> = [];
-  try {
-    var procEntries = readdirSync("/proc").filter(function (e) { return /^\d+$/.test(e); });
-    for (var i = 0; i < procEntries.length; i++) {
-      var pid = parseInt(procEntries[i], 10);
-      if (pid === process.pid) continue;
-      try {
-        var cmdline = readFileSync("/proc/" + pid + "/cmdline", "utf-8").split("\0");
-        var exe = cmdline[0] || "";
-        if (!exe.endsWith("/claude") && exe !== "claude") continue;
-        var cwd = readlinkSync("/proc/" + pid + "/cwd");
-        results.push({ pid, cwd, cmdline });
-      } catch {}
-    }
-  } catch {}
-  return results;
-}
-
-setInterval(refreshCliDetection, 10000);
-
-function getProjectPathForSession(sessionId: string): string | null {
-  var config = loadConfig();
-  for (var i = 0; i < config.projects.length; i++) {
-    var hash = config.projects[i].path.replace(/\//g, "-");
-    var jsonlPath = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
-    if (existsSync(jsonlPath)) return config.projects[i].path;
-  }
-  return null;
-}
-
-
-function isSessionLockedByExternal(sessionId: string): boolean {
-  if (activeStreams.has(sessionId)) return false;
-  var projectPath = getProjectPathForSession(sessionId);
-  if (!projectPath) return false;
-  return cliActiveProjects.has(projectPath);
-}
-
-export function stopExternalSession(sessionId: string): boolean {
-  var projectPath = getProjectPathForSession(sessionId);
-  if (!projectPath) return false;
-  var pids = getClaudeCliPidsAsync();
-  for (var i = 0; i < pids.length; i++) {
-    if (pids[i].cwd === projectPath) {
-      try {
-        process.kill(pids[i].pid, "SIGINT");
-        return true;
-      } catch {}
-    }
-  }
-  return false;
-}
 
 export function getSessionStreamClientId(sessionId: string): string | undefined {
   var meta = streamMetadata.get(sessionId);
@@ -481,18 +372,55 @@ export function startChatStream(options: ChatStreamOptions): void {
     } catch {}
   }
 
+  var abortController = new AbortController();
+
   var queryOptions: Parameters<typeof query>[0]["options"] = {
     cwd,
     permissionMode: effectiveMode,
     promptSuggestions: true,
+    settingSources: ["user", "project", "local"],
+    includePartialMessages: true,
+    enableFileCheckpointing: true,
+    agentProgressSummaries: true,
+    abortController,
+    pathToClaudeCodeExecutable: getClaudeExecutablePath(),
     additionalDirectories: savedAdditionalDirs.length > 0 ? savedAdditionalDirs : undefined,
     mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers as Record<string, any> : undefined,
+    stderr: function (data: string) {
+      if (data.includes("error") || data.includes("Error") || data.includes("credit") || data.includes("Credit") || data.includes("billing") || data.includes("auth")) {
+        log.chat("SDK stderr: %s", data.trim());
+      }
+    },
   };
 
   (queryOptions as any).toolConfig = {
     askUserQuestion: { previewFormat: "html" },
   };
 
+  queryOptions.onElicitation = function (request: any, opts: any) {
+    return new Promise(function (resolve) {
+      var requestId = crypto.randomUUID();
+      pendingElicitations.set(requestId, { resolve, clientId, sessionId });
+      sendTo(clientId, {
+        type: "chat:elicitation_request",
+        requestId,
+        serverName: request.serverName || "MCP Server",
+        message: request.message || "",
+        mode: request.mode || "form",
+        url: request.url || null,
+        requestedSchema: request.requestedSchema || null,
+      });
+      if (opts && opts.signal) {
+        opts.signal.addEventListener("abort", function () {
+          if (pendingElicitations.has(requestId)) {
+            pendingElicitations.delete(requestId);
+            resolve({ action: "decline" });
+          }
+        }, { once: true });
+      }
+    });
+  } as any;
+
   queryOptions.canUseTool = function (toolName, input, options) {
     var approved = autoApprovedTools.get(sessionId);
     if (approved && approved.has(toolName)) {
@@ -713,7 +641,7 @@ export function startChatStream(options: ChatStreamOptions): void {
   var stream = query({ prompt: queryPrompt, options: queryOptions });
   pendingStreams.delete(sessionId);
   activeStreams.set(sessionId, stream);
-  streamMetadata.set(sessionId, { projectSlug, clientId, startedAt: Date.now() });
+  streamMetadata.set(sessionId, { projectSlug, clientId, startedAt: Date.now(), abortController });
   persistStreamState();
   broadcast({ type: "session:busy", sessionId, busy: true }, clientId);
 
@@ -743,6 +671,15 @@ export function startChatStream(options: ChatStreamOptions): void {
       });
       toCleanup.forEach(function (reqId) { pendingPermissions.delete(reqId); });
 
+      var elicitToCleanup: string[] = [];
+      pendingElicitations.forEach(function (entry, reqId) {
+        if (entry.sessionId === sessionId) {
+          elicitToCleanup.push(reqId);
+          entry.resolve({ action: "decline" });
+        }
+      });
+      elicitToCleanup.forEach(function (reqId) { pendingElicitations.delete(reqId); });
+
       autoApprovedTools.delete(sessionId);
       sessionPermissionOverrides.delete(sessionId);
 
@@ -906,6 +843,22 @@ export function startChatStream(options: ChatStreamOptions): void {
       return;
     }
 
+    if (msg.type === "rate_limit_event") {
+      var rlMsg = msg as { type: string; rate_limit_info: { status: string; utilization?: number; resetsAt?: number; rateLimitType?: string; overageStatus?: string; overageResetsAt?: number; isUsingOverage?: boolean } };
+      var rli = rlMsg.rate_limit_info;
+      sendTo(clientId, {
+        type: "chat:rate_limit",
+        status: rli.status,
+        utilization: rli.utilization,
+        resetsAt: rli.resetsAt,
+        rateLimitType: rli.rateLimitType,
+        overageStatus: rli.overageStatus,
+        overageResetsAt: rli.overageResetsAt,
+        isUsingOverage: rli.isUsingOverage,
+      } as any);
+      return;
+    }
+
     if (msg.type === "prompt_suggestion") {
       var suggestion = (msg as { type: string; suggestion: string }).suggestion;
       if (suggestion) {

package/server/src/project/session.ts

@@ -465,8 +465,30 @@ export async function getSessionTitle(projectSlug: string, sessionId: string): P
   return "Untitled";
 }
 
-var historyCache = new Map<string, { messages: HistoryMessage[]; time: number }>();
-var HISTORY_CACHE_TTL = 60000;
+var historyCache = new Map<string, { messages: HistoryMessage[]; title: string | null }>();
+var historyCacheOrder: string[] = [];
+var MAX_HISTORY_CACHE = 50;
+
+function touchCache(sessionId: string): void {
+  var idx = historyCacheOrder.indexOf(sessionId);
+  if (idx >= 0) historyCacheOrder.splice(idx, 1);
+  historyCacheOrder.push(sessionId);
+}
+
+function evictOldest(): void {
+  while (historyCacheOrder.length > MAX_HISTORY_CACHE) {
+    var oldest = historyCacheOrder.shift();
+    if (oldest) historyCache.delete(oldest);
+  }
+}
+
+export function appendToHistoryCache(sessionId: string, message: HistoryMessage): void {
+  var cached = historyCache.get(sessionId);
+  if (!cached) return;
+  cached.messages.push(message);
+  touchCache(sessionId);
+}
+
 var INITIAL_MESSAGE_COUNT = 100;
 var TAIL_READ_BYTES = 2 * 1024 * 1024;
 
@@ -512,7 +534,8 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
   try {
     var t0 = Date.now();
     var cached = historyCache.get(sessionId);
-    if (cached && Date.now() - cached.time < HISTORY_CACHE_TTL) {
+    if (cached) {
+      touchCache(sessionId);
       var tail = cached.messages.length > INITIAL_MESSAGE_COUNT
         ? cached.messages.slice(cached.messages.length - INITIAL_MESSAGE_COUNT)
         : cached.messages;
@@ -530,7 +553,9 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
       log.session("loadSessionHistory %s: %dms (tail read, %d msgs, partial=%s)", sessionId.slice(0, 8), Date.now() - t0, tailMessages.length, hasMore);
 
       if (!hasMore) {
-        historyCache.set(sessionId, { messages: tailMessages, time: Date.now() });
+        historyCache.set(sessionId, { messages: tailMessages, title: null });
+        touchCache(sessionId);
+        evictOldest();
       }
 
       var initialSlice = tailMessages.length > INITIAL_MESSAGE_COUNT
@@ -544,7 +569,9 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
     var options = projectPath ? { dir: projectPath } : undefined;
     var rawMessages = await getSessionMessages(sessionId, options);
     var allMessages = convertSessionMessages(rawMessages);
-    historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
+    historyCache.set(sessionId, { messages: allMessages, title: null });
+    touchCache(sessionId);
+    evictOldest();
     log.session("loadSessionHistory %s: %dms (full SDK, %d msgs)", sessionId.slice(0, 8), Date.now() - t0, allMessages.length);
     var tailSlice = allMessages.length > INITIAL_MESSAGE_COUNT
       ? allMessages.slice(allMessages.length - INITIAL_MESSAGE_COUNT)
@@ -564,8 +591,10 @@ export async function getSessionHistoryPage(sessionId: string, beforeIndex: numb
     try {
       var rawMessages = await getSessionMessages(sessionId, options);
       var allMessages = convertSessionMessages(rawMessages);
-      historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
-      cached = { messages: allMessages, time: Date.now() };
+      historyCache.set(sessionId, { messages: allMessages, title: null });
+      touchCache(sessionId);
+      evictOldest();
+      cached = historyCache.get(sessionId)!;
       log.session("getSessionHistoryPage: full load for %s, %d messages", sessionId.slice(0, 8), allMessages.length);
     } catch {
       return { messages: [], hasMore: false };

package/server/src/project/warmup.ts

@@ -0,0 +1,232 @@
+import type { AccountInfo } from "@anthropic-ai/claude-agent-sdk";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { broadcast } from "../ws/broadcast";
+import { log } from "../logger";
+import { loadConfig } from "../config";
+import { listSessions, loadSessionHistory } from "./session";
+import { execSync } from "node:child_process";
+
+var claudeExePath: string | null = null;
+
+function getClaudeExecutablePath(): string {
+  if (claudeExePath) return claudeExePath;
+  try {
+    claudeExePath = execSync("which claude", { encoding: "utf-8" }).trim();
+  } catch {
+    claudeExePath = "claude";
+  }
+  return claudeExePath;
+}
+
+export interface ModelEntry {
+  value: string;
+  displayName: string;
+}
+
+var KNOWN_MODELS: ModelEntry[] = [
+  { value: "default", displayName: "Default" },
+  { value: "opus", displayName: "Opus" },
+  { value: "sonnet", displayName: "Sonnet" },
+  { value: "haiku", displayName: "Haiku" },
+];
+
+var warmupModels: ModelEntry[] = [];
+var warmupSlashCommands: string[] = [];
+var warmupAccountInfo: AccountInfo | null = null;
+var warmupComplete = false;
+
+function ensureKnownModels(sdkModels: ModelEntry[]): ModelEntry[] {
+  var seen = new Set<string>();
+  for (var i = 0; i < sdkModels.length; i++) {
+    seen.add(sdkModels[i].value);
+  }
+  var result = sdkModels.slice();
+  for (var j = 0; j < KNOWN_MODELS.length; j++) {
+    if (!seen.has(KNOWN_MODELS[j].value)) {
+      result.push(KNOWN_MODELS[j]);
+    }
+  }
+  return result;
+}
+
+export async function runWarmup(cwd: string): Promise<void> {
+  log.server("SDK warmup starting (cwd: %s)...", cwd);
+  try {
+    var ac = new AbortController();
+    var ended = false;
+
+    var mq = {
+      [Symbol.asyncIterator]: function () {
+        return {
+          next: function () {
+            if (ended) return Promise.resolve({ value: undefined as any, done: true });
+            ended = true;
+            return Promise.resolve({
+              value: {
+                type: "user" as const,
+                message: { role: "user" as const, content: [{ type: "text" as const, text: "hi" }] },
+                parent_tool_use_id: null,
+                session_id: "warmup",
+              },
+              done: false,
+            });
+          },
+        };
+      },
+    };
+
+    var stream = query({
+      prompt: mq as any,
+      options: {
+        cwd,
+        settingSources: ["user", "project", "local"],
+        abortController: ac,
+        permissionMode: "plan",
+        pathToClaudeCodeExecutable: getClaudeExecutablePath(),
+        stderr: function (data: string) {
+          log.server("Warmup stderr: %s", data.trim());
+        },
+      },
+    });
+
+    var gotInit = false;
+    for await (var msg of stream) {
+      if (msg.type === "system") {
+        var sysMsg = msg as any;
+        if (sysMsg.subtype === "init") {
+          gotInit = true;
+          if (sysMsg.slash_commands) {
+            warmupSlashCommands = sysMsg.slash_commands;
+          }
+
+          try {
+            var models = await stream.supportedModels();
+            warmupModels = ensureKnownModels((models || []) as ModelEntry[]);
+          } catch {
+            warmupModels = KNOWN_MODELS.slice();
+          }
+
+          try {
+            warmupAccountInfo = await stream.accountInfo();
+          } catch {}
+        }
+      }
+
+      if (msg.type === "rate_limit_event") {
+        var rlMsg = msg as { type: string; rate_limit_info: { status: string; utilization?: number; resetsAt?: number; rateLimitType?: string; overageStatus?: string; overageResetsAt?: number; isUsingOverage?: boolean } };
+        var rli = rlMsg.rate_limit_info;
+        broadcast({
+          type: "chat:rate_limit",
+          status: rli.status,
+          utilization: rli.utilization,
+          resetsAt: rli.resetsAt,
+          rateLimitType: rli.rateLimitType,
+          overageStatus: rli.overageStatus,
+          overageResetsAt: rli.overageResetsAt,
+          isUsingOverage: rli.isUsingOverage,
+        } as any);
+      }
+
+      if (msg.type === "result" && gotInit) {
+        ac.abort();
+        break;
+      }
+    }
+
+    warmupComplete = true;
+    log.server("SDK warmup complete: %d models, %d commands, auth=%s",
+      warmupModels.length, warmupSlashCommands.length,
+      warmupAccountInfo?.apiKeySource || "unknown");
+    if (warmupAccountInfo) {
+      log.server("Account: email=%s org=%s subscription=%s provider=%s source=%s",
+        warmupAccountInfo.email || "none",
+        warmupAccountInfo.organization || "none",
+        warmupAccountInfo.subscriptionType || "none",
+        warmupAccountInfo.apiProvider || "none",
+        warmupAccountInfo.apiKeySource || "none");
+    }
+
+    broadcast({
+      type: "warmup:models",
+      models: warmupModels,
+    } as any);
+
+    if (warmupAccountInfo) {
+      broadcast({
+        type: "warmup:account",
+        email: warmupAccountInfo.email,
+        organization: warmupAccountInfo.organization,
+        subscriptionType: warmupAccountInfo.subscriptionType,
+        apiKeySource: warmupAccountInfo.apiKeySource,
+        apiProvider: warmupAccountInfo.apiProvider,
+      } as any);
+    }
+
+    void warmupProjectData();
+  } catch (err) {
+    if (err && (err as any).name !== "AbortError" && !(err instanceof Error && err.message.includes("aborted"))) {
+      log.server("SDK warmup failed: %O", err);
+    }
+    warmupModels = KNOWN_MODELS.slice();
+    warmupComplete = true;
+    void warmupProjectData();
+  }
+}
+
+async function warmupProjectData(): Promise<void> {
+  var t0 = Date.now();
+  var config = loadConfig();
+  var projects = config.projects;
+  if (projects.length === 0) return;
+
+  log.server("Data warmup: pre-caching %d project(s)...", projects.length);
+
+  var totalSessions = 0;
+  var recentSessionIds: Array<{ projectSlug: string; sessionId: string }> = [];
+
+  for (var i = 0; i < projects.length; i++) {
+    try {
+      var result = await listSessions(projects[i].slug, { limit: 40 });
+      totalSessions += result.sessions.length;
+      broadcast({
+        type: "session:list",
+        projectSlug: projects[i].slug,
+        sessions: result.sessions,
+        totalCount: result.totalCount,
+      } as any);
+      if (result.sessions.length > 0) {
+        recentSessionIds.push({
+          projectSlug: projects[i].slug,
+          sessionId: result.sessions[0].id,
+        });
+      }
+    } catch {}
+  }
+
+  log.server("Data warmup: cached %d sessions across %d projects (%dms)", totalSessions, projects.length, Date.now() - t0);
+
+  for (var j = 0; j < recentSessionIds.length; j++) {
+    try {
+      await loadSessionHistory(recentSessionIds[j].projectSlug, recentSessionIds[j].sessionId);
+    } catch {}
+  }
+  if (recentSessionIds.length > 0) {
+    log.server("Data warmup: pre-cached history for %d recent sessions (%dms)", recentSessionIds.length, Date.now() - t0);
+  }
+}
+
+export function getWarmupModels(): ModelEntry[] {
+  return warmupModels.length > 0 ? warmupModels : KNOWN_MODELS.slice();
+}
+
+export function getWarmupSlashCommands(): string[] {
+  return warmupSlashCommands;
+}
+
+export function getWarmupAccountInfo(): AccountInfo | null {
+  return warmupAccountInfo;
+}
+
+export function isWarmupComplete(): boolean {
+  return warmupComplete;
+}