@cookielab.io/klovi 3.3.0 → 3.4.0

package/dist/server.js

@@ -223,13 +223,23 @@ class PluginRegistry {
   getAllPlugins() {
     return [...this.plugins.values()].map((entry) => entry.plugin);
   }
-  discoverAllProjects() {
+  discoverPluginStates(includeSessions) {
     return Effect2.gen(this, function* () {
-      const allProjects = [];
-      for (const { plugin, configLayer } of this.plugins.values()) {
-        const projects = yield* plugin.discoverProjects.pipe(Effect2.provide(configLayer), Effect2.catchAll(() => Effect2.succeed([])));
-        allProjects.push(...projects);
+      const states = [];
+      for (const entry of this.plugins.values()) {
+        const discoveredIndex = includeSessions && entry.plugin.discoverIndex ? yield* entry.plugin.discoverIndex.pipe(Effect2.provide(entry.configLayer), Effect2.catchAll(() => Effect2.succeed(undefined))) : undefined;
+        const projects = discoveredIndex?.projects ?? (yield* entry.plugin.discoverProjects.pipe(Effect2.provide(entry.configLayer), Effect2.catchAll(() => Effect2.succeed([]))));
+        states.push({
+          entry,
+          projects,
+          ...discoveredIndex ? { sessionsByNativeId: discoveredIndex.sessionsByNativeId } : {}
+        });
       }
+      return states;
+    });
+  }
+  mergeProjects(allProjects) {
+    return Effect2.gen(function* () {
       yield* resolveT3CodePaths(allProjects);
       const projectsByPath = new Map;
       for (const project of allProjects) {
@@ -259,6 +269,50 @@ class PluginRegistry {
       return merged;
     });
   }
+  encodeSessions(pluginId, sessions) {
+    return sessions.map((session) => ({
+      ...session,
+      sessionId: this.sessionIdEncoder(pluginId, session.sessionId),
+      pluginId
+    }));
+  }
+  loadSourceSessions(state, source) {
+    const discoveredSessions = state.sessionsByNativeId?.get(source.nativeId);
+    if (discoveredSessions) {
+      return Effect2.succeed(this.encodeSessions(source.pluginId, discoveredSessions));
+    }
+    return state.entry.plugin.listSessions(source.nativeId).pipe(Effect2.provide(state.entry.configLayer), Effect2.catchAll(() => Effect2.succeed([])), Effect2.map((sessions) => this.encodeSessions(source.pluginId, sessions)));
+  }
+  discoverAllProjects() {
+    return Effect2.gen(this, function* () {
+      const states = yield* this.discoverPluginStates(false);
+      return yield* this.mergeProjects(states.flatMap((state) => state.projects));
+    });
+  }
+  discoverAllProjectsWithSessions() {
+    return Effect2.gen(this, function* () {
+      const states = yield* this.discoverPluginStates(true);
+      const mergedProjects = yield* this.mergeProjects(states.flatMap((state) => state.projects));
+      const statesByPluginId = new Map(states.map((state) => [state.entry.plugin.id, state]));
+      const sessionsByEncodedPath = new Map;
+      for (const project of mergedProjects) {
+        const allSessions = [];
+        for (const source of project.sources) {
+          const state = statesByPluginId.get(source.pluginId);
+          if (!state) {
+            continue;
+          }
+          allSessions.push(...yield* this.loadSourceSessions(state, source));
+        }
+        sortByIsoDesc(allSessions, (session) => session.timestamp);
+        sessionsByEncodedPath.set(project.encodedPath, allSessions);
+      }
+      return {
+        projects: mergedProjects,
+        sessionsByEncodedPath
+      };
+    });
+  }
   listAllSessions(project) {
     return Effect2.gen(this, function* () {
       const allSessions = [];
@@ -267,12 +321,7 @@ class PluginRegistry {
         if (!entry) {
           continue;
         }
-        const sessions = yield* entry.plugin.listSessions(source.nativeId).pipe(Effect2.provide(entry.configLayer), Effect2.catchAll(() => Effect2.succeed([])));
-        allSessions.push(...sessions.map((session) => ({
-          ...session,
-          sessionId: this.sessionIdEncoder(source.pluginId, session.sessionId),
-          pluginId: source.pluginId
-        })));
+        allSessions.push(...yield* entry.plugin.listSessions(source.nativeId).pipe(Effect2.provide(entry.configLayer), Effect2.catchAll(() => Effect2.succeed([])), Effect2.map((sessions) => this.encodeSessions(source.pluginId, sessions))));
       }
       sortByIsoDesc(allSessions, (session) => session.timestamp);
       return allSessions;
@@ -880,7 +929,7 @@ var init_platform_node = __esm(() => {
 import { execFile } from "node:child_process";
 
 // ../../packages/server/src/effect/bootstrap.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { HttpServer } from "@effect/platform";
 import { Cause, Effect as Effect32, Fiber, Layer as Layer8 } from "effect";
 
@@ -2773,6 +2822,15 @@ function extractFirstUserTextFromHeaders(db, composerId, headers) {
   }
   return "";
 }
+function resolveComposerFallbackMessage(composer) {
+  if (isNonEmptyString(composer.name)) {
+    return composer.name.trim();
+  }
+  if (isNonEmptyString(composer.subtitle)) {
+    return composer.subtitle.trim();
+  }
+  return "Cursor session";
+}
 function resolveComposerFirstMessage(globalDb, composer, composerId) {
   if (globalDb) {
     const rawComposerData = queryKeyValueRow(globalDb, `composerData:${composerId}`);
@@ -2786,13 +2844,7 @@ function resolveComposerFirstMessage(globalDb, composer, composerId) {
       return truncate(fromHeaders, SESSION_PREVIEW_MAX_LENGTH);
     }
   }
-  if (isNonEmptyString(composer.name)) {
-    return composer.name.trim();
-  }
-  if (isNonEmptyString(composer.subtitle)) {
-    return composer.subtitle.trim();
-  }
-  return "Cursor session";
+  return resolveComposerFallbackMessage(composer);
 }
 function resolveComposerSessionType(unifiedMode) {
   if (unifiedMode === "plan") {
@@ -2803,7 +2855,13 @@ function resolveComposerSessionType(unifiedMode) {
   }
   return;
 }
-function createComposerSummary(projectPath, workspaceDbPath, composer, globalDb) {
+function createComposerSummary({
+  projectPath,
+  workspaceDbPath,
+  composer,
+  globalDb,
+  options = { resolveFirstMessage: true }
+}) {
   if (!isNonEmptyString(composer.composerId)) {
     return null;
   }
@@ -2813,7 +2871,7 @@ function createComposerSummary(projectPath, workspaceDbPath, composer, globalDb)
   }
   const { composerId } = composer;
   const unifiedMode = composer.unifiedMode ?? composer.forceMode ?? "chat";
-  const firstMessage = resolveComposerFirstMessage(globalDb, composer, composerId);
+  const firstMessage = options.resolveFirstMessage ? resolveComposerFirstMessage(globalDb, composer, composerId) : resolveComposerFallbackMessage(composer);
   return {
     kind: "composer",
     rawSessionId: `composer:${composerId}`,
@@ -2840,6 +2898,31 @@ function parseProjectPathFromWorkspaceJson(content) {
   }
   return fileUrlToPath(parsed.folder);
 }
+function discoverWorkspaceDescriptors(targetProjectPath) {
+  return Effect21.gen(function* () {
+    const workspaceStorageDir = yield* getCursorWorkspaceStorageDirEffect();
+    const workspaceEntries = yield* readDirEntriesSafe2(workspaceStorageDir);
+    const workspaceDescriptors = [];
+    for (const entry of workspaceEntries) {
+      if (!entry.isDirectory) {
+        continue;
+      }
+      const workspaceDir = join12(workspaceStorageDir, entry.name);
+      const workspaceJsonPath = join12(workspaceDir, "workspace.json");
+      const workspaceDbPath = join12(workspaceDir, "state.vscdb");
+      const exists = yield* fileExists3(workspaceJsonPath);
+      if (!exists) {
+        continue;
+      }
+      const projectPath = yield* readFileText3(workspaceJsonPath).pipe(Effect21.map(parseProjectPathFromWorkspaceJson), Effect21.catchAll(() => Effect21.succeed(null)));
+      if (!projectPath || targetProjectPath && projectPath !== targetProjectPath) {
+        continue;
+      }
+      workspaceDescriptors.push({ projectPath, workspaceDbPath });
+    }
+    return workspaceDescriptors;
+  });
+}
 function findProjectSessions(sessionsByProject, projectPath) {
   const existing = sessionsByProject.get(projectPath);
   if (existing) {
@@ -2852,6 +2935,46 @@ function findProjectSessions(sessionsByProject, projectPath) {
 function pushSession(sessionsByProject, session) {
   findProjectSessions(sessionsByProject, session.projectPath).push(session);
 }
+function pushSessions(sessionsByProject, sessions) {
+  for (const session of sessions) {
+    pushSession(sessionsByProject, session);
+  }
+}
+function collectComposerSessions({
+  workspaceDescriptors,
+  globalDb,
+  sessionsByProject,
+  composersById,
+  options
+}) {
+  return Effect21.gen(function* () {
+    for (const descriptor of workspaceDescriptors) {
+      const workspaceDb = yield* openCursorDbIfExists(descriptor.workspaceDbPath);
+      if (!workspaceDb) {
+        continue;
+      }
+      try {
+        const composers = readWorkspaceComposerEntries(workspaceDb);
+        for (const composer of composers) {
+          const summary = createComposerSummary({
+            projectPath: descriptor.projectPath,
+            workspaceDbPath: descriptor.workspaceDbPath,
+            composer,
+            globalDb,
+            options
+          });
+          if (!summary) {
+            continue;
+          }
+          composersById.set(summary.composerId, summary);
+          pushSession(sessionsByProject, summary);
+        }
+      } finally {
+        workspaceDb.close();
+      }
+    }
+  });
+}
 function readFirstTranscriptUserMessage(text) {
   let firstMessage = "";
   iterateJsonl3(text, ({ parsed }) => {
@@ -2895,45 +3018,50 @@ function listTranscriptFiles(agentTranscriptsDir) {
     return files;
   });
 }
-function discoverBackgroundAgents(workspaceProjectPaths) {
+function createBackgroundAgentSummary(projectPath, transcript, firstMessage) {
+  return {
+    kind: "agent",
+    rawSessionId: `agent:${transcript.agentId}`,
+    projectPath,
+    agentId: transcript.agentId,
+    filePath: transcript.filePath,
+    timestamp: transcript.mtimeIso,
+    timestampMs: new Date(transcript.mtimeIso).getTime(),
+    firstMessage,
+    slug: transcript.agentId,
+    model: "unknown",
+    gitBranch: "",
+    sessionType: "implementation"
+  };
+}
+function discoverBackgroundAgentsForProject(projectPath, options = { readPreviewText: true }) {
   return Effect21.gen(function* () {
     const config = yield* PluginConfig;
-    const projectsDir = join12(config.dataDir, "projects");
-    const entries = yield* readDirEntriesSafe2(projectsDir);
-    const encodedProjectPaths = new Map(workspaceProjectPaths.map((projectPath) => [encodeCursorProjectPath(projectPath), projectPath]));
+    const agentTranscriptsDir = join12(config.dataDir, "projects", encodeCursorProjectPath(projectPath), "agent-transcripts");
     const agentsById = new Map;
-    for (const entry of entries) {
-      if (!entry.isDirectory) {
-        continue;
-      }
-      const projectPath = encodedProjectPaths.get(entry.name);
-      if (!projectPath) {
-        continue;
-      }
-      const agentTranscriptsDir = join12(projectsDir, entry.name, "agent-transcripts");
-      const transcriptDirExists = yield* fileExists3(agentTranscriptsDir);
-      if (!transcriptDirExists) {
-        continue;
-      }
-      const transcripts = yield* listTranscriptFiles(agentTranscriptsDir);
-      for (const transcript of transcripts) {
+    const transcriptDirExists = yield* fileExists3(agentTranscriptsDir);
+    if (!transcriptDirExists) {
+      return agentsById;
+    }
+    const transcripts = yield* listTranscriptFiles(agentTranscriptsDir);
+    for (const transcript of transcripts) {
+      let firstMessage = "Cursor background agent";
+      if (options.readPreviewText) {
         const text = yield* readFileText3(transcript.filePath).pipe(Effect21.catchAll(() => Effect21.succeed("")));
-        const firstMessage = readFirstTranscriptUserMessage(text) || "Cursor background agent";
-        const timestampMs = new Date(transcript.mtimeIso).getTime();
-        agentsById.set(transcript.agentId, {
-          kind: "agent",
-          rawSessionId: `agent:${transcript.agentId}`,
-          projectPath,
-          agentId: transcript.agentId,
-          filePath: transcript.filePath,
-          timestamp: transcript.mtimeIso,
-          timestampMs,
-          firstMessage,
-          slug: transcript.agentId,
-          model: "unknown",
-          gitBranch: "",
-          sessionType: "implementation"
-        });
+        firstMessage = readFirstTranscriptUserMessage(text) || firstMessage;
+      }
+      agentsById.set(transcript.agentId, createBackgroundAgentSummary(projectPath, transcript, firstMessage));
+    }
+    return agentsById;
+  });
+}
+function discoverBackgroundAgents(projectPaths, options = { readPreviewText: true }) {
+  return Effect21.gen(function* () {
+    const agentsById = new Map;
+    for (const projectPath of new Set(projectPaths)) {
+      const projectAgents = yield* discoverBackgroundAgentsForProject(projectPath, options);
+      for (const agent of projectAgents.values()) {
+        agentsById.set(agent.agentId, agent);
       }
     }
     return agentsById;
@@ -2970,7 +3098,7 @@ function createPlanSummary(entry, projectPath, filePath, displayName) {
     sessionType: "plan"
   };
 }
-function discoverMappedPlans(globalDb, composersById, agentsById) {
+function discoverMappedPlans(globalDb, composersById, agentsById, options = { loadDisplayName: true }) {
   return Effect21.gen(function* () {
     const plansById = new Map;
     if (!globalDb) {
@@ -2992,8 +3120,8 @@ function discoverMappedPlans(globalDb, composersById, agentsById) {
       if (!exists) {
         continue;
       }
-      const displayName = yield* readPlanDisplayName(filePath).pipe(Effect21.catchAll(() => Effect21.succeed("")));
-      const summary = createPlanSummary(entry, projectPath, filePath, displayName || entry.name?.trim() || "");
+      const displayName = options.loadDisplayName ? yield* readPlanDisplayName(filePath).pipe(Effect21.catchAll(() => Effect21.succeed(""))) : "";
+      const summary = createPlanSummary(entry, projectPath, filePath, displayName || entry.name?.trim() || "Cursor plan");
       if (!summary) {
         continue;
       }
@@ -3024,63 +3152,57 @@ function buildProjects(sessionsByProject) {
   sortByIsoDesc(projects, (project) => project.lastActivity);
   return projects;
 }
+function buildCursorProjectIndex(nativeId) {
+  return Effect21.gen(function* () {
+    const globalDb = yield* openCursorGlobalDb();
+    const sessionsByProject = new Map;
+    const composersById = new Map;
+    try {
+      const workspaceDescriptors = yield* discoverWorkspaceDescriptors(nativeId);
+      yield* collectComposerSessions({
+        workspaceDescriptors,
+        globalDb,
+        sessionsByProject,
+        composersById,
+        options: { resolveFirstMessage: true }
+      });
+      const agentsById = yield* discoverBackgroundAgents([nativeId], { readPreviewText: true });
+      pushSessions(sessionsByProject, agentsById.values());
+      const plansById = yield* discoverMappedPlans(globalDb, composersById, agentsById, { loadDisplayName: true });
+      pushSessions(sessionsByProject, plansById.values());
+      return {
+        projects: buildProjects(sessionsByProject),
+        sessionsByProject,
+        composersById,
+        agentsById,
+        plansById
+      };
+    } finally {
+      globalDb?.close();
+    }
+  });
+}
 function buildCursorIndex() {
   return Effect21.gen(function* () {
-    const workspaceStorageDir = yield* getCursorWorkspaceStorageDirEffect();
-    const workspaceEntries = yield* readDirEntriesSafe2(workspaceStorageDir);
     const globalDb = yield* openCursorGlobalDb();
     const sessionsByProject = new Map;
     const composersById = new Map;
     try {
-      const workspaceDescriptors = [];
-      for (const entry of workspaceEntries) {
-        if (!entry.isDirectory) {
-          continue;
-        }
-        const workspaceDir = join12(workspaceStorageDir, entry.name);
-        const workspaceJsonPath = join12(workspaceDir, "workspace.json");
-        const workspaceDbPath = join12(workspaceDir, "state.vscdb");
-        const exists = yield* fileExists3(workspaceJsonPath);
-        if (!exists) {
-          continue;
-        }
-        const projectPath = yield* readFileText3(workspaceJsonPath).pipe(Effect21.map(parseProjectPathFromWorkspaceJson), Effect21.catchAll(() => Effect21.succeed(null)));
-        if (!projectPath) {
-          continue;
-        }
-        workspaceDescriptors.push({ projectPath, workspaceDbPath });
-      }
+      const workspaceDescriptors = yield* discoverWorkspaceDescriptors();
       const workspaceProjectPaths = [...new Set(workspaceDescriptors.map((descriptor) => descriptor.projectPath))];
-      for (const descriptor of workspaceDescriptors) {
-        const workspaceDb = yield* openCursorDbIfExists(descriptor.workspaceDbPath);
-        if (!workspaceDb) {
-          continue;
-        }
-        try {
-          const composers = readWorkspaceComposerEntries(workspaceDb);
-          for (const composer of composers) {
-            const summary = createComposerSummary(descriptor.projectPath, descriptor.workspaceDbPath, composer, globalDb);
-            if (!summary) {
-              continue;
-            }
-            composersById.set(summary.composerId, summary);
-            pushSession(sessionsByProject, summary);
-          }
-        } finally {
-          workspaceDb.close();
-        }
-      }
+      yield* collectComposerSessions({
+        workspaceDescriptors,
+        globalDb,
+        sessionsByProject,
+        composersById,
+        options: { resolveFirstMessage: true }
+      });
       const agentsById = yield* discoverBackgroundAgents(workspaceProjectPaths);
-      for (const agent of agentsById.values()) {
-        pushSession(sessionsByProject, agent);
-      }
+      pushSessions(sessionsByProject, agentsById.values());
       const plansById = yield* discoverMappedPlans(globalDb, composersById, agentsById);
-      for (const plan of plansById.values()) {
-        pushSession(sessionsByProject, plan);
-      }
-      const projects = buildProjects(sessionsByProject);
+      pushSessions(sessionsByProject, plansById.values());
       return {
-        projects,
+        projects: buildProjects(sessionsByProject),
         sessionsByProject,
         composersById,
         agentsById,
@@ -3103,11 +3225,44 @@ function toSessionSummary(session) {
     sessionType: session.sessionType
   };
 }
+function buildCursorDiscoveryIndex() {
+  return buildCursorIndex().pipe(Effect21.map((index) => ({
+    projects: index.projects,
+    sessionsByNativeId: new Map([...index.sessionsByProject.entries()].map(([projectPath, sessions]) => [
+      projectPath,
+      sessions.map(toSessionSummary)
+    ]))
+  })));
+}
 function discoverCursorProjects() {
-  return buildCursorIndex().pipe(Effect21.map((index) => index.projects));
+  return Effect21.gen(function* () {
+    const globalDb = yield* openCursorGlobalDb();
+    const sessionsByProject = new Map;
+    const composersById = new Map;
+    try {
+      const workspaceDescriptors = yield* discoverWorkspaceDescriptors();
+      const workspaceProjectPaths = [...new Set(workspaceDescriptors.map((descriptor) => descriptor.projectPath))];
+      yield* collectComposerSessions({
+        workspaceDescriptors,
+        globalDb,
+        sessionsByProject,
+        composersById,
+        options: { resolveFirstMessage: false }
+      });
+      const agentsById = yield* discoverBackgroundAgents(workspaceProjectPaths, { readPreviewText: false });
+      pushSessions(sessionsByProject, agentsById.values());
+      const plansById = yield* discoverMappedPlans(globalDb, composersById, agentsById, {
+        loadDisplayName: false
+      });
+      pushSessions(sessionsByProject, plansById.values());
+      return buildProjects(sessionsByProject);
+    } finally {
+      globalDb?.close();
+    }
+  });
 }
 function listCursorSessions(nativeId) {
-  return buildCursorIndex().pipe(Effect21.map((index) => {
+  return buildCursorProjectIndex(nativeId).pipe(Effect21.map((index) => {
     const sessions = index.sessionsByProject.get(nativeId) ?? [];
     sortByIsoDesc(sessions, (session) => session.timestamp);
     return sessions.map(toSessionSummary);
@@ -3341,7 +3496,7 @@ function loadCursorAgentSession(summary) {
 }
 function loadCursorSession(nativeId, sessionId) {
   return Effect22.gen(function* () {
-    const index = yield* buildCursorIndex();
+    const index = yield* buildCursorProjectIndex(nativeId);
     const session = index.composersById.get(sessionId.replace(COMPOSER_PREFIX_REGEX, "")) ?? index.agentsById.get(sessionId.replace(AGENT_PREFIX_REGEX, "")) ?? index.plansById.get(sessionId.replace(PLAN_PREFIX_REGEX, ""));
     if (!session || session.projectPath !== nativeId) {
       return yield* Effect22.fail(new Error(`Cursor session not found: ${sessionId}`));
@@ -3379,6 +3534,12 @@ var cursorPlugin = {
     message: String(err),
     cause: err
   })))),
+  discoverIndex: buildCursorDiscoveryIndex().pipe(Effect23.catchAll((err) => Effect23.fail(new PluginError({
+    pluginId: "cursor",
+    operation: "discoverIndex",
+    message: String(err),
+    cause: err
+  })))),
   listSessions: (nativeId) => listCursorSessions(nativeId).pipe(Effect23.catchAll((err) => Effect23.fail(new PluginError({
     pluginId: "cursor",
     operation: "listSessions",
@@ -3569,13 +3730,11 @@ function getProjects(registry) {
 }
 function getSessions(registry, params) {
   return Effect27.gen(function* () {
-    const projects = yield* registry.discoverAllProjects();
-    const project = projects.find((p) => p.encodedPath === params.encodedPath);
-    if (!project) {
+    const discovered = yield* registry.discoverAllProjectsWithSessions();
+    if (!discovered.projects.find((project) => project.encodedPath === params.encodedPath)) {
       return { sessions: [] };
     }
-    const sessions = yield* registry.listAllSessions(project);
-    return { sessions };
+    return { sessions: discovered.sessionsByEncodedPath.get(params.encodedPath) ?? [] };
   });
 }
 function getSession(registry, params) {
@@ -3633,10 +3792,10 @@ function projectNameFromPath(fullPath) {
 }
 function searchSessions(registry) {
   return Effect27.gen(function* () {
-    const projects = yield* registry.discoverAllProjects();
-    const perProject = yield* Effect27.forEach(projects, (project) => registry.listAllSessions(project).pipe(Effect27.map((sessions) => ({ project, sessions }))), { concurrency: "unbounded" });
+    const discovered = yield* registry.discoverAllProjectsWithSessions();
     const allSessions = [];
-    for (const { project, sessions } of perProject) {
+    for (const project of discovered.projects) {
+      const sessions = discovered.sessionsByEncodedPath.get(project.encodedPath) ?? [];
       const projectName = projectNameFromPath(project.name);
       for (const session of sessions) {
         allSessions.push({
@@ -3755,6 +3914,8 @@ function updateUpdateSettings(settingsPath, params) {
 }
 
 // ../../packages/server/src/services/stats-service.ts
+import { dirname as dirname2, join as join14 } from "node:path";
+import { FileSystem as FileSystem11 } from "@effect/platform";
 import { Effect as Effect30 } from "effect";
 
 // ../../packages/server/src/services/stats.ts
@@ -3820,11 +3981,11 @@ function countVisibleMessages(turns) {
 }
 function collectSessionsWithProjects(registry, stats) {
   return Effect29.gen(function* () {
-    const projects = yield* registry.discoverAllProjects();
-    stats.projects = projects.length;
+    const discovered = yield* registry.discoverAllProjectsWithSessions();
+    stats.projects = discovered.projects.length;
     const sessionsWithProject = [];
-    for (const project of projects) {
-      const sessions = yield* registry.listAllSessions(project);
+    for (const project of discovered.projects) {
+      const sessions = discovered.sessionsByEncodedPath.get(project.encodedPath) ?? [];
       stats.sessions += sessions.length;
       for (const session of sessions) {
         sessionsWithProject.push({ project, session });
@@ -3865,6 +4026,9 @@ function applyUsageStats(stats, modelUsage, usage) {
   modelUsage.cacheReadTokens += usage.cacheReadTokens ?? 0;
   modelUsage.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
 }
+function totalUsageTokens(usage) {
+  return usage.inputTokens + usage.outputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheCreationTokens ?? 0);
+}
 function applyTurnStats(stats, turns, fallbackModel) {
   stats.messages += countVisibleMessages(turns);
   for (const turn of turns) {
@@ -3872,10 +4036,10 @@ function applyTurnStats(stats, turns, fallbackModel) {
       continue;
     }
     stats.toolCalls += turn.contentBlocks.filter((block) => block.type === "tool_call").length;
-    const modelUsage = ensureModelUsage(stats.models, turn.model || fallbackModel || "unknown");
-    if (!turn.usage) {
+    if (!turn.usage || totalUsageTokens(turn.usage) <= 0) {
       continue;
     }
+    const modelUsage = ensureModelUsage(stats.models, turn.model || fallbackModel || "unknown");
     applyUsageStats(stats, modelUsage, turn.usage);
   }
 }
@@ -3899,10 +4063,163 @@ function scanStats(registry) {
 }
 
 // ../../packages/server/src/services/stats-service.ts
-function getStats(registry) {
+var STATS_CACHE_FILENAME = "stats-cache.json";
+var refreshBootTimes = new Map;
+var refreshEpochs = new Map;
+var refreshingCachePaths = new Set;
+function getStatsCachePath(settingsPath) {
+  return join14(dirname2(settingsPath), STATS_CACHE_FILENAME);
+}
+function getRefreshBootTime(cachePath) {
+  const existing = refreshBootTimes.get(cachePath);
+  if (existing) {
+    return existing;
+  }
+  const bootTime = new Date().toISOString();
+  refreshBootTimes.set(cachePath, bootTime);
+  return bootTime;
+}
+function getRefreshEpoch(cachePath) {
+  return refreshEpochs.get(cachePath) ?? 0;
+}
+function bumpRefreshEpoch(cachePath) {
+  const nextEpoch = getRefreshEpoch(cachePath) + 1;
+  refreshEpochs.set(cachePath, nextEpoch);
+  return nextEpoch;
+}
+function isDashboardStats(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  const requiredNumberFields = [
+    "projects",
+    "sessions",
+    "messages",
+    "todaySessions",
+    "thisWeekSessions",
+    "inputTokens",
+    "outputTokens",
+    "cacheReadTokens",
+    "cacheCreationTokens",
+    "toolCalls"
+  ];
+  for (const field of requiredNumberFields) {
+    if (typeof candidate[field] !== "number") {
+      return false;
+    }
+  }
+  return typeof candidate["models"] === "object" && candidate["models"] !== null;
+}
+function isStatsCacheFile(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return candidate["version"] === 1 && typeof candidate["cachedAt"] === "string" && isDashboardStats(candidate["stats"]);
+}
+function loadStatsCache(settingsPath) {
+  return Effect30.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
+    const cachePath = getStatsCachePath(settingsPath);
+    const raw = yield* fs.readFileString(cachePath).pipe(Effect30.catchAll(() => Effect30.succeed(null)));
+    if (raw === null) {
+      return null;
+    }
+    const parsed = yield* Effect30.try({
+      try: () => JSON.parse(raw),
+      catch: () => null
+    }).pipe(Effect30.catchAll(() => Effect30.succeed(null)));
+    return parsed !== null && isStatsCacheFile(parsed) ? parsed : null;
+  });
+}
+function persistStatsCache(settingsPath, stats, expectedEpoch) {
+  return Effect30.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
+    const cachePath = getStatsCachePath(settingsPath);
+    const cacheDir = dirname2(cachePath);
+    const cachedAt = new Date().toISOString();
+    yield* fs.makeDirectory(cacheDir, { recursive: true }).pipe(Effect30.catchAll(() => Effect30.void));
+    if (getRefreshEpoch(cachePath) !== expectedEpoch) {
+      return null;
+    }
+    const tmpPath = join14(cacheDir, `.stats-cache-${Date.now()}.tmp`);
+    const payload = {
+      version: 1,
+      cachedAt,
+      stats
+    };
+    const wroteTempFile = yield* fs.writeFileString(tmpPath, JSON.stringify(payload, null, 2)).pipe(Effect30.map(() => true), Effect30.catchAll(() => Effect30.succeed(false)));
+    if (!wroteTempFile) {
+      return null;
+    }
+    if (getRefreshEpoch(cachePath) !== expectedEpoch) {
+      yield* fs.remove(tmpPath).pipe(Effect30.catchAll(() => Effect30.void));
+      return null;
+    }
+    const renamed = yield* fs.rename(tmpPath, cachePath).pipe(Effect30.map(() => true), Effect30.catchAll(() => fs.remove(tmpPath).pipe(Effect30.catchAll(() => Effect30.void), Effect30.map(() => false))));
+    if (!renamed) {
+      return null;
+    }
+    return getRefreshEpoch(cachePath) === expectedEpoch ? cachedAt : null;
+  });
+}
+function computeAndPersistStats(settingsPath, registry, expectedEpoch) {
   return Effect30.gen(function* () {
     const stats = yield* scanStats(registry);
-    return { stats };
+    const cachedAt = yield* persistStatsCache(settingsPath, stats, expectedEpoch);
+    return { stats, ...cachedAt ? { cachedAt } : {} };
+  });
+}
+function refreshStats(settingsPath, registry) {
+  return Effect30.gen(function* () {
+    const cachePath = getStatsCachePath(settingsPath);
+    const expectedEpoch = getRefreshEpoch(cachePath);
+    refreshingCachePaths.add(cachePath);
+    const result = yield* computeAndPersistStats(settingsPath, registry, expectedEpoch);
+    return { ...result, refreshing: false };
+  }).pipe(Effect30.ensuring(Effect30.sync(() => {
+    refreshingCachePaths.delete(getStatsCachePath(settingsPath));
+  })));
+}
+function scheduleRefresh(settingsPath, registry) {
+  return Effect30.gen(function* () {
+    const cachePath = getStatsCachePath(settingsPath);
+    if (refreshingCachePaths.has(cachePath)) {
+      return;
+    }
+    const expectedEpoch = getRefreshEpoch(cachePath);
+    refreshingCachePaths.add(cachePath);
+    yield* computeAndPersistStats(settingsPath, registry, expectedEpoch).pipe(Effect30.catchAllCause(() => Effect30.void), Effect30.ensuring(Effect30.sync(() => {
+      refreshingCachePaths.delete(cachePath);
+    })), Effect30.forkDaemon);
+  });
+}
+function getStats(settingsPath, registry) {
+  return Effect30.gen(function* () {
+    const cachePath = getStatsCachePath(settingsPath);
+    const cached = yield* loadStatsCache(settingsPath);
+    if (!cached) {
+      return yield* refreshStats(settingsPath, registry);
+    }
+    const bootTime = getRefreshBootTime(cachePath);
+    const shouldRefresh = cached.cachedAt < bootTime;
+    if (shouldRefresh) {
+      yield* scheduleRefresh(settingsPath, registry);
+    }
+    return {
+      stats: cached.stats,
+      cachedAt: cached.cachedAt,
+      refreshing: shouldRefresh || refreshingCachePaths.has(cachePath)
+    };
+  });
+}
+function invalidateStatsCache(settingsPath) {
+  return Effect30.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
+    const cachePath = getStatsCachePath(settingsPath);
+    bumpRefreshEpoch(cachePath);
+    yield* fs.remove(cachePath).pipe(Effect30.catchAll(() => Effect30.void));
   });
 }
 
@@ -3931,7 +4248,7 @@ var KloviServicesLive = Layer6.effect(KloviServices, Effect31.gen(function* () {
   return {
     acceptRisks: () => completeOnboarding(settingsPath),
     getVersion: () => Effect31.succeed(getVersion(versionState)),
-    getStats: () => getStats(registry),
+    getStats: () => getStats(settingsPath, registry),
     getProjects: () => getProjects(registry),
     getSessions: (params) => getSessions(registry, params),
     getSession: (params) => getSession(registry, params),
@@ -3941,6 +4258,7 @@ var KloviServicesLive = Layer6.effect(KloviServices, Effect31.gen(function* () {
     updatePluginSetting: (params) => Effect31.gen(function* () {
       const result = yield* updatePluginSetting(settingsPath, params);
       yield* refreshRegistry();
+      yield* invalidateStatsCache(settingsPath);
       return result;
     }),
     getGeneralSettings: () => getGeneralSettings(settingsPath),
@@ -3949,6 +4267,7 @@ var KloviServicesLive = Layer6.effect(KloviServices, Effect31.gen(function* () {
     resetSettings: () => Effect31.gen(function* () {
       const result = yield* resetSettings(settingsPath);
       yield* refreshRegistry();
+      yield* invalidateStatsCache(settingsPath);
       return result;
     }),
     getUpdateSettings: () => getUpdateSettings(settingsPath),
@@ -3961,7 +4280,7 @@ var KloviServicesLive = Layer6.effect(KloviServices, Effect31.gen(function* () {
 // ../../packages/server/src/effect/bootstrap.ts
 function getDefaultSettingsPath() {
   const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
-  return join14(home, ".klovi", "settings.json");
+  return join15(home, ".klovi", "settings.json");
 }
 function detectRuntime(requested = "auto") {
   if (requested !== "auto") {
@@ -4100,11 +4419,16 @@ import { Effect as Effect35 } from "effect";
 // src/static-handler.ts
 import { HttpServerRequest as HttpServerRequest2, HttpServerResponse as HttpServerResponse2 } from "@effect/platform";
 import { Effect as Effect34 } from "effect";
+var notFound = HttpServerResponse2.unsafeJson({ error: "Not found" }, { status: 404 });
+var isNavigationRequest = (pathname) => {
+  const lastSegment2 = pathname.split("/").pop() ?? "";
+  return !lastSegment2.includes(".");
+};
 var makeStaticHandler = (staticDir) => Effect34.gen(function* () {
   const req = yield* HttpServerRequest2.HttpServerRequest;
   const url = new URL(req.url, "http://localhost");
   const filePath = url.pathname === "/" ? "/index.html" : url.pathname;
-  return yield* HttpServerResponse2.file(`${staticDir}${filePath}`).pipe(Effect34.orElse(() => HttpServerResponse2.file(`${staticDir}/index.html`)), Effect34.orElse(() => Effect34.succeed(HttpServerResponse2.unsafeJson({ error: "Not found" }, { status: 404 }))));
+  return yield* HttpServerResponse2.file(`${staticDir}${filePath}`).pipe(Effect34.orElse(() => isNavigationRequest(url.pathname) ? HttpServerResponse2.file(`${staticDir}/index.html`).pipe(Effect34.orElse(() => Effect34.succeed(notFound))) : Effect34.succeed(notFound)));
 });
 
 // src/http-app.ts