@cookielab.io/klovi 3.3.0 → 3.5.0

package/dist/cli.js

@@ -38,6 +38,69 @@ function epochSecondsToIso(epochSeconds) {
 }
 var MS_PER_SECOND = 1000;
 
+// ../../packages/plugin-core/src/jsonl-stream.ts
+import { FileSystem } from "@effect/platform";
+import { Effect, Ref, Stream } from "effect";
+function parseAndVisit(line, lineIndex, visitor, onMalformed) {
+  if (!line.trim()) {
+    return;
+  }
+  const lineNumber = lineIndex + 1;
+  try {
+    const parsed = JSON.parse(line);
+    return visitor({ parsed, line, lineIndex, lineNumber });
+  } catch (error) {
+    onMalformed?.(line, lineNumber, error);
+    return;
+  }
+}
+function processLine(line, state) {
+  return Effect.gen(function* () {
+    if (yield* Ref.get(state.bailedRef)) {
+      return;
+    }
+    const lineIndex = yield* Ref.getAndUpdate(state.indexRef, (n) => n + 1);
+    const result = parseAndVisit(line, lineIndex, state.visitor, state.onMalformed);
+    if (result === false) {
+      yield* Ref.set(state.bailedRef, true);
+    }
+  });
+}
+function streamJsonlHead(filePath, visitor, options = {}) {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const indexRef = yield* Ref.make(0);
+    const bailedRef = yield* Ref.make(false);
+    const chunkSize = options.chunkSize ?? DEFAULT_HEAD_CHUNK_SIZE;
+    const baseStream = fs.stream(filePath, { chunkSize });
+    const linesStream = baseStream.pipe(Stream.decodeText("utf-8"), Stream.splitLines);
+    const cappedStream = options.maxLines === undefined ? linesStream : linesStream.pipe(Stream.take(options.maxLines));
+    const state = {
+      visitor,
+      indexRef,
+      bailedRef,
+      onMalformed: options.onMalformed
+    };
+    yield* cappedStream.pipe(Stream.takeUntilEffect(() => Ref.get(bailedRef)), Stream.runForEach((line) => processLine(line, state)));
+  });
+}
+function streamJsonl(filePath, visitor, options = {}) {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const indexRef = yield* Ref.make(0);
+    const chunkSize = options.chunkSize ?? DEFAULT_FULL_CHUNK_SIZE;
+    yield* fs.stream(filePath, { chunkSize }).pipe(Stream.decodeText("utf-8"), Stream.splitLines, Stream.runForEach((line) => Effect.gen(function* () {
+      const lineIndex = yield* Ref.getAndUpdate(indexRef, (n) => n + 1);
+      parseAndVisit(line, lineIndex, visitor, options.onMalformed);
+    })));
+  });
+}
+var KILOBYTE_BYTES = 1024, DEFAULT_HEAD_CHUNK_KILOBYTES = 8, DEFAULT_HEAD_CHUNK_SIZE, DEFAULT_FULL_CHUNK_KILOBYTES = 64, DEFAULT_FULL_CHUNK_SIZE;
+var init_jsonl_stream = __esm(() => {
+  DEFAULT_HEAD_CHUNK_SIZE = DEFAULT_HEAD_CHUNK_KILOBYTES * KILOBYTE_BYTES;
+  DEFAULT_FULL_CHUNK_SIZE = DEFAULT_FULL_CHUNK_KILOBYTES * KILOBYTE_BYTES;
+});
+
 // ../../packages/plugin-core/src/plugin-config.ts
 import { Context } from "effect";
 var PluginConfig;
@@ -56,8 +119,8 @@ var init_plugin_errors = __esm(() => {
 
 // ../../packages/plugin-core/src/resolve-worktree.ts
 import { join } from "node:path";
-import { FileSystem } from "@effect/platform";
-import { Effect } from "effect";
+import { FileSystem as FileSystem2 } from "@effect/platform";
+import { Effect as Effect2 } from "effect";
 function stripT3CodeSuffix(path) {
   if (!T3CODE_SUFFIX_REGEX.test(path)) {
     return null;
@@ -68,14 +131,14 @@ function stripT3CodeSuffix(path) {
   return { path: parentPath, projectName };
 }
 function resolveGitWorktree(worktreePath) {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
+  return Effect2.gen(function* () {
+    const fs = yield* FileSystem2.FileSystem;
     const dotGitPath = join(worktreePath, ".git");
-    const info = yield* fs.stat(dotGitPath).pipe(Effect.catchAll(() => Effect.succeed(null)));
+    const info = yield* fs.stat(dotGitPath).pipe(Effect2.catchAll(() => Effect2.succeed(null)));
     if (!info || info.type !== "File") {
       return worktreePath;
     }
-    const content = yield* fs.readFileString(dotGitPath).pipe(Effect.catchAll(() => Effect.succeed("")));
+    const content = yield* fs.readFileString(dotGitPath).pipe(Effect2.catchAll(() => Effect2.succeed("")));
     if (!content) {
       return worktreePath;
     }
@@ -132,7 +195,7 @@ function buildNameMap(projects, t3codeProjects) {
   return nameToResolvedPaths;
 }
 function resolveEntry(entry, nameMap) {
-  return Effect.gen(function* () {
+  return Effect2.gen(function* () {
     const candidates = nameMap.get(entry.projectName);
     if (!candidates || candidates.length === 0) {
       return;
@@ -151,7 +214,7 @@ function resolveEntry(entry, nameMap) {
   });
 }
 function resolveT3CodePaths(projects) {
-  return Effect.gen(function* () {
+  return Effect2.gen(function* () {
     const t3codeEntries = collectT3CodeEntries(projects);
     if (t3codeEntries.length === 0) {
       return;
@@ -186,7 +249,7 @@ function parseSessionId(sessionId) {
 var SESSION_ID_SEPARATOR = "::";
 
 // ../../packages/plugin-core/src/plugin-registry.ts
-import { Effect as Effect2, Layer } from "effect";
+import { Effect as Effect3, Layer } from "effect";
 function encodeResolvedPath(resolvedPath) {
   if (resolvedPath.startsWith("/")) {
     return resolvedPath.replace(/\//gu, "-");
@@ -224,13 +287,22 @@ class PluginRegistry {
   getAllPlugins() {
     return [...this.plugins.values()].map((entry) => entry.plugin);
   }
-  discoverAllProjects() {
-    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);
-      }
+  discoverPluginStates(includeSessions) {
+    return Effect3.gen(this, function* () {
+      const entries = [...this.plugins.values()];
+      return yield* Effect3.forEach(entries, (entry) => Effect3.gen(function* () {
+        const discoveredIndex = includeSessions && entry.plugin.discoverIndex ? yield* entry.plugin.discoverIndex.pipe(Effect3.provide(entry.configLayer), Effect3.catchAll(() => Effect3.succeed(undefined))) : undefined;
+        const projects = discoveredIndex?.projects ?? (yield* entry.plugin.discoverProjects.pipe(Effect3.provide(entry.configLayer), Effect3.catchAll(() => Effect3.succeed([]))));
+        return {
+          entry,
+          projects,
+          ...discoveredIndex ? { sessionsByNativeId: discoveredIndex.sessionsByNativeId } : {}
+        };
+      }), { concurrency: "unbounded" });
+    });
+  }
+  mergeProjects(allProjects) {
+    return Effect3.gen(function* () {
       yield* resolveT3CodePaths(allProjects);
       const projectsByPath = new Map;
       for (const project of allProjects) {
@@ -260,20 +332,59 @@ 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 Effect3.succeed(this.encodeSessions(source.pluginId, discoveredSessions));
+    }
+    return state.entry.plugin.listSessions(source.nativeId).pipe(Effect3.provide(state.entry.configLayer), Effect3.catchAll(() => Effect3.succeed([])), Effect3.map((sessions) => this.encodeSessions(source.pluginId, sessions)));
+  }
+  discoverAllProjects() {
+    return Effect3.gen(this, function* () {
+      const states = yield* this.discoverPluginStates(false);
+      return yield* this.mergeProjects(states.flatMap((state) => state.projects));
+    });
+  }
+  discoverAllProjectsWithSessions() {
+    return Effect3.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* () {
+    return Effect3.gen(this, function* () {
       const allSessions = [];
       for (const source of project.sources) {
         const entry = this.plugins.get(source.pluginId);
         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(Effect3.provide(entry.configLayer), Effect3.catchAll(() => Effect3.succeed([])), Effect3.map((sessions) => this.encodeSessions(source.pluginId, sessions))));
       }
       sortByIsoDesc(allSessions, (session) => session.timestamp);
       return allSessions;
@@ -304,6 +415,7 @@ var init_sqlite_service = __esm(() => {
 
 // ../../packages/plugin-core/src/index.ts
 var init_src = __esm(() => {
+  init_jsonl_stream();
   init_plugin_config();
   init_plugin_errors();
   init_plugin_registry();
@@ -313,18 +425,18 @@ var init_src = __esm(() => {
 
 // ../../packages/plugin-opencode/src/db.ts
 import { join as join2 } from "node:path";
-import { FileSystem as FileSystem2 } from "@effect/platform";
-import { Effect as Effect3 } from "effect";
+import { FileSystem as FileSystem3 } from "@effect/platform";
+import { Effect as Effect4 } from "effect";
 function getOpenCodeDbPath() {
-  return Effect3.gen(function* () {
+  return Effect4.gen(function* () {
     const config = yield* PluginConfig;
     return join2(config.dataDir, "opencode.db");
   });
 }
 function openOpenCodeDb() {
-  return Effect3.gen(function* () {
+  return Effect4.gen(function* () {
     const dbPath = yield* getOpenCodeDbPath();
-    const fs = yield* FileSystem2.FileSystem;
+    const fs = yield* FileSystem3.FileSystem;
     const exists = yield* fs.exists(dbPath);
     if (!exists) {
       return null;
@@ -347,7 +459,7 @@ function tryParseJson(value) {
 }
 
 // ../../packages/plugin-opencode/src/discovery.ts
-import { Effect as Effect4 } from "effect";
+import { Effect as Effect5 } from "effect";
 function getColumns(db, tableName) {
   const rows = db.query(`PRAGMA table_info(${tableName})`).all();
   return new Set(rows.map((r) => r.name));
@@ -368,7 +480,7 @@ function inspectSchema(db) {
   };
 }
 function discoverOpenCodeProjects() {
-  return Effect4.gen(function* () {
+  return Effect5.gen(function* () {
     const db = yield* openOpenCodeDb();
     if (!db) {
       return [];
@@ -459,7 +571,7 @@ function sessionRowToSummary(db, row) {
   };
 }
 function listOpenCodeSessions(nativeId) {
-  return Effect4.gen(function* () {
+  return Effect5.gen(function* () {
     const db = yield* openOpenCodeDb();
     if (!db) {
       return [];
@@ -526,7 +638,7 @@ var init_discovery = __esm(() => {
 });
 
 // ../../packages/plugin-opencode/src/parser.ts
-import { Effect as Effect5 } from "effect";
+import { Effect as Effect6 } from "effect";
 function partToContentBlock(partData, nextToolUseId) {
   switch (partData.type) {
     case "text": {
@@ -735,7 +847,7 @@ function loadSessionFromDb(db, nativeId, sessionId) {
   return { sessionId, project, turns, pluginId: "opencode" };
 }
 function loadOpenCodeSession(nativeId, sessionId) {
-  return Effect5.gen(function* () {
+  return Effect6.gen(function* () {
     const db = yield* openOpenCodeDb();
     if (!db) {
       return emptySession(nativeId, sessionId);
@@ -770,12 +882,12 @@ var init_config = __esm(() => {
 });
 
 // ../../packages/plugin-opencode/src/runtime/bun-sqlite.ts
-import { Effect as Effect6, Layer as Layer3 } from "effect";
+import { Effect as Effect7, Layer as Layer3 } from "effect";
 var bunSqliteClient, BunSqliteLayer;
 var init_bun_sqlite = __esm(() => {
   init_src();
   bunSqliteClient = {
-    open: (dbPath, options) => Effect6.try({
+    open: (dbPath, options) => Effect7.try({
       try: () => {
         const sqlite = __require("bun:sqlite");
         return new sqlite.Database(dbPath, {
@@ -783,18 +895,18 @@ var init_bun_sqlite = __esm(() => {
         });
       },
       catch: () => null
-    }).pipe(Effect6.catchAll(() => Effect6.succeed(null)))
+    }).pipe(Effect7.catchAll(() => Effect7.succeed(null)))
   };
   BunSqliteLayer = Layer3.succeed(SqliteClientTag, bunSqliteClient);
 });
 
 // ../../packages/plugin-opencode/src/runtime/node-sqlite.ts
-import { Effect as Effect7, Layer as Layer4 } from "effect";
+import { Effect as Effect8, Layer as Layer4 } from "effect";
 var nodeSqliteClient, NodeSqliteLayer;
 var init_node_sqlite = __esm(() => {
   init_src();
   nodeSqliteClient = {
-    open: (dbPath, options) => Effect7.tryPromise({
+    open: (dbPath, options) => Effect8.tryPromise({
       try: async () => {
         const sqlite = await import("node:sqlite");
         const db = new sqlite.DatabaseSync(dbPath, {
@@ -815,15 +927,15 @@ var init_node_sqlite = __esm(() => {
         };
       },
       catch: () => null
-    }).pipe(Effect7.catchAll(() => Effect7.succeed(null)))
+    }).pipe(Effect8.catchAll(() => Effect8.succeed(null)))
   };
   NodeSqliteLayer = Layer4.succeed(SqliteClientTag, nodeSqliteClient);
 });
 
 // ../../packages/plugin-opencode/src/index.ts
 import { join as join4 } from "node:path";
-import { FileSystem as FileSystem3 } from "@effect/platform";
-import { Effect as Effect8 } from "effect";
+import { FileSystem as FileSystem4 } from "@effect/platform";
+import { Effect as Effect9 } from "effect";
 var openCodePlugin;
 var init_src2 = __esm(() => {
   init_src();
@@ -836,24 +948,24 @@ var init_src2 = __esm(() => {
     id: "opencode",
     displayName: "OpenCode",
     getDefaultDataDir: () => null,
-    isDataAvailable: Effect8.gen(function* () {
+    isDataAvailable: Effect9.gen(function* () {
       const config = yield* PluginConfig;
-      const fs = yield* FileSystem3.FileSystem;
-      return yield* fs.exists(join4(config.dataDir, "opencode.db")).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
+      const fs = yield* FileSystem4.FileSystem;
+      return yield* fs.exists(join4(config.dataDir, "opencode.db")).pipe(Effect9.catchAll(() => Effect9.succeed(false)));
     }),
-    discoverProjects: discoverOpenCodeProjects().pipe(Effect8.catchAll((err) => Effect8.fail(new PluginError({
+    discoverProjects: discoverOpenCodeProjects().pipe(Effect9.catchAll((err) => Effect9.fail(new PluginError({
       pluginId: "opencode",
       operation: "discoverProjects",
       message: String(err),
       cause: err
     })))),
-    listSessions: (nativeId) => listOpenCodeSessions(nativeId).pipe(Effect8.catchAll((err) => Effect8.fail(new PluginError({
+    listSessions: (nativeId) => listOpenCodeSessions(nativeId).pipe(Effect9.catchAll((err) => Effect9.fail(new PluginError({
       pluginId: "opencode",
       operation: "listSessions",
       message: String(err),
       cause: err
     })))),
-    loadSession: (nativeId, sessionId) => loadOpenCodeSession(nativeId, sessionId).pipe(Effect8.catchAll((err) => Effect8.fail(new PluginError({
+    loadSession: (nativeId, sessionId) => loadOpenCodeSession(nativeId, sessionId).pipe(Effect9.catchAll((err) => Effect9.fail(new PluginError({
       pluginId: "opencode",
       operation: "loadSession",
       message: String(err),
@@ -881,9 +993,9 @@ 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";
+import { Cause, Effect as Effect33, Fiber, Layer as Layer8 } from "effect";
 
 // ../../packages/server/src/effect/platform-bun.ts
 init_src2();
@@ -899,20 +1011,20 @@ class ServerConfig extends Context3.Tag("@klovi/ServerConfig")() {
 }
 
 // ../../packages/server/src/effect/server-services.ts
-import { Context as Context4, Effect as Effect31, Layer as Layer6 } from "effect";
+import { Context as Context4, Effect as Effect32, Layer as Layer6 } from "effect";
 
 // ../../packages/server/src/services/auto-discover.ts
 init_src();
-import { Effect as Effect24 } from "effect";
+import { Effect as Effect25 } from "effect";
 
 // ../../packages/plugin-claude-code/src/index.ts
 init_src();
-import { Effect as Effect12 } from "effect";
+import { Effect as Effect13 } from "effect";
 
 // ../../packages/plugin-claude-code/src/discovery.ts
 init_src();
 import { join as join6 } from "node:path";
-import { Effect as Effect10 } from "effect";
+import { Effect as Effect11 } from "effect";
 
 // ../../packages/plugin-claude-code/src/command-message.ts
 var COMMAND_ARGS_REGEX = /<command-args>(?<content>[\s\S]*?)<\/command-args>/u;
@@ -950,62 +1062,44 @@ function parseCommandMessage(text) {
 // ../../packages/plugin-claude-code/src/shared/discovery-utils.ts
 init_src();
 import { join as join5 } from "node:path";
-import { FileSystem as FileSystem4 } from "@effect/platform";
-import { Effect as Effect9 } from "effect";
+import { FileSystem as FileSystem5 } from "@effect/platform";
+import { Effect as Effect10 } from "effect";
 var WINDOWS_DRIVE_LETTER_REGEX = /^[A-Za-z]\//u;
+var STAT_CONCURRENCY = 32;
 function readDirEntriesSafe(dir) {
-  return Effect9.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
-    const names = yield* fs.readDirectory(dir).pipe(Effect9.catchAll(() => Effect9.succeed([])));
-    const entries = [];
-    for (const name of names) {
-      const info = yield* fs.stat(join5(dir, name)).pipe(Effect9.catchAll(() => Effect9.succeed(null)));
-      if (info) {
-        entries.push({ name, isDirectory: info.type === "Directory" });
-      }
-    }
-    return entries;
+  return Effect10.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
+    const names = yield* fs.readDirectory(dir).pipe(Effect10.catchAll(() => Effect10.succeed([])));
+    const entries = yield* Effect10.forEach(names, (name) => Effect10.gen(function* () {
+      const info = yield* fs.stat(join5(dir, name)).pipe(Effect10.catchAll(() => Effect10.succeed(null)));
+      return info ? { name, isDirectory: info.type === "Directory" } : null;
+    }), { concurrency: STAT_CONCURRENCY });
+    return entries.filter((entry) => entry !== null);
   });
 }
 function listFilesBySuffix(dir, suffix) {
-  return Effect9.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
-    const names = yield* fs.readDirectory(dir).pipe(Effect9.catchAll(() => Effect9.succeed([])));
+  return Effect10.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
+    const names = yield* fs.readDirectory(dir).pipe(Effect10.catchAll(() => Effect10.succeed([])));
     return names.filter((name) => name.endsWith(suffix));
   });
 }
 function listFilesWithMtime(dir, suffix) {
-  return Effect9.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
+  return Effect10.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
     const names = yield* listFilesBySuffix(dir, suffix);
-    const results = [];
-    for (const fileName of names) {
-      const info = yield* fs.stat(join5(dir, fileName)).pipe(Effect9.catchAll(() => Effect9.succeed(null)));
-      if (info?.mtime._tag === "Some") {
-        results.push({ fileName, mtime: info.mtime.value.toISOString() });
-      }
-    }
+    const candidates = yield* Effect10.forEach(names, (fileName) => Effect10.gen(function* () {
+      const info = yield* fs.stat(join5(dir, fileName)).pipe(Effect10.catchAll(() => Effect10.succeed(null)));
+      return info?.mtime._tag === "Some" ? { fileName, mtime: info.mtime.value.toISOString() } : null;
+    }), { concurrency: STAT_CONCURRENCY });
+    const results = candidates.filter((r) => r !== null);
     sortByIsoDesc(results, (item) => item.mtime);
     return results;
   });
 }
-function readTextPrefix(filePath, maxBytes) {
-  return Effect9.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
-    const bytes = yield* fs.readFile(filePath);
-    const slice = bytes.subarray(0, maxBytes);
-    return new TextDecoder().decode(slice);
-  });
-}
-function readFileText(filePath) {
-  return Effect9.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
-    return yield* fs.readFileString(filePath);
-  });
-}
 function fileExists(filePath) {
-  return Effect9.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
+  return Effect10.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
     return yield* fs.exists(filePath);
   });
 }
@@ -1020,98 +1114,65 @@ function decodeEncodedPath(encoded) {
   return encoded.replace(/-/gu, "/");
 }
 
-// ../../packages/plugin-claude-code/src/shared/jsonl-utils.ts
-function iterateJsonl(text, visitor, options = {}) {
-  const lines = text.split(`
-`);
-  const start = Math.max(0, options.startAt ?? 0);
-  const end = options.maxLines === undefined ? lines.length : Math.min(lines.length, start + options.maxLines);
-  for (let i = start;i < end; i++) {
-    const line = lines[i];
-    if (!line?.trim()) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(line);
-      const shouldContinue = visitor({
-        parsed,
-        line,
-        lineIndex: i,
-        lineNumber: i + 1
-      });
-      if (shouldContinue === false) {
-        break;
-      }
-    } catch (error) {
-      options.onMalformed?.(line, i + 1, error);
-    }
-  }
-}
-
 // ../../packages/plugin-claude-code/src/discovery.ts
-var BYTES_PER_KB = 1024;
-var CWD_SCAN_KB = 64;
-var CWD_SCAN_BYTES = CWD_SCAN_KB * BYTES_PER_KB;
-var SESSION_META_SCAN_BYTES = BYTES_PER_KB * BYTES_PER_KB;
 var BRACKETED_TEXT_REGEX = /^\[.+\]$/u;
+var PROJECT_DIR_CONCURRENCY = 16;
+var SESSION_FILE_CONCURRENCY = 16;
 function inspectProjectSessions(projectDir, sessionFiles) {
-  return Effect10.gen(function* () {
+  return Effect11.gen(function* () {
     const lastActivity = sessionFiles[0]?.mtime || "";
     let resolvedPath = "";
     for (const sessionFile of sessionFiles) {
       const filePath = join6(projectDir, sessionFile.fileName);
-      if (!resolvedPath) {
-        resolvedPath = yield* extractCwd(filePath);
+      resolvedPath = yield* extractCwd(filePath);
+      if (resolvedPath) {
+        break;
       }
     }
     return { lastActivity, resolvedPath };
   });
 }
 function discoverClaudeProjects() {
-  return Effect10.gen(function* () {
+  return Effect11.gen(function* () {
     const config = yield* PluginConfig;
     const projectsDir = join6(config.dataDir, "projects");
     const entries = yield* readDirEntriesSafe(projectsDir);
-    const projects = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory) {
-        continue;
-      }
+    const directories = entries.filter((entry) => entry.isDirectory);
+    const projects = yield* Effect11.forEach(directories, (entry) => Effect11.gen(function* () {
       const projectDir = join6(projectsDir, entry.name);
       const sessionFiles = yield* listFilesWithMtime(projectDir, ".jsonl");
       if (sessionFiles.length === 0) {
-        continue;
+        return null;
       }
       const projectInfo = yield* inspectProjectSessions(projectDir, sessionFiles);
       const resolvedPath = projectInfo.resolvedPath || decodeEncodedPath(entry.name);
-      projects.push({
+      return {
         pluginId: "claude-code",
         nativeId: entry.name,
         resolvedPath,
         displayName: resolvedPath,
         sessionCount: sessionFiles.length,
         lastActivity: projectInfo.lastActivity
-      });
-    }
-    sortByIsoDesc(projects, (project) => project.lastActivity);
-    return projects;
+      };
+    }), { concurrency: PROJECT_DIR_CONCURRENCY });
+    const filtered = projects.filter((p) => p !== null);
+    sortByIsoDesc(filtered, (project) => project.lastActivity);
+    return filtered;
   });
 }
 var PLAN_PREFIX = "Implement the following plan";
 function listClaudeSessions(nativeId) {
-  return Effect10.gen(function* () {
+  return Effect11.gen(function* () {
     const config = yield* PluginConfig;
     const projectDir = join6(config.dataDir, "projects", nativeId);
     const files = yield* listFilesBySuffix(projectDir, ".jsonl");
-    const sessions = [];
-    for (const file of files) {
+    const candidates = yield* Effect11.forEach(files, (file) => Effect11.gen(function* () {
       const filePath = join6(projectDir, file);
       const sessionId = file.replace(".jsonl", "");
       const meta = yield* extractSessionMeta(filePath);
-      if (meta) {
-        sessions.push({ sessionId, pluginId: "claude-code", ...meta });
-      }
-    }
+      return meta ? { sessionId, pluginId: "claude-code", ...meta } : null;
+    }), { concurrency: SESSION_FILE_CONCURRENCY });
+    const sessions = candidates.filter((s) => s !== null);
     classifySessionTypes(sessions);
     sortByIsoDesc(sessions, (session) => session.timestamp);
     return sessions;
@@ -1134,20 +1195,16 @@ function classifySessionTypes(sessions) {
   }
 }
 function extractCwd(filePath) {
-  return Effect10.gen(function* () {
-    const text = yield* readTextPrefix(filePath, CWD_SCAN_BYTES).pipe(Effect10.catchAll(() => Effect10.succeed("")));
-    if (!text) {
-      return "";
-    }
+  return Effect11.gen(function* () {
     let cwd = "";
-    iterateJsonl(text, ({ parsed }) => {
+    yield* streamJsonlHead(filePath, ({ parsed }) => {
       const obj = parsed;
       if (obj.cwd) {
         ({ cwd } = obj);
         return false;
       }
       return;
-    }, { maxLines: 20 });
+    }, { maxLines: 20 }).pipe(Effect11.catchAll(() => Effect11.void));
     return cwd;
   });
 }
@@ -1192,11 +1249,7 @@ function processMetaLine(obj, meta) {
   }
 }
 function extractSessionMeta(filePath) {
-  return Effect10.gen(function* () {
-    const text = yield* readTextPrefix(filePath, SESSION_META_SCAN_BYTES).pipe(Effect10.catchAll(() => Effect10.succeed("")));
-    if (!text) {
-      return null;
-    }
+  return Effect11.gen(function* () {
     const meta = {
       timestamp: "",
       slug: "",
@@ -1204,7 +1257,7 @@ function extractSessionMeta(filePath) {
       model: "",
       gitBranch: ""
     };
-    iterateJsonl(text, ({ parsed }) => {
+    yield* streamJsonlHead(filePath, ({ parsed }) => {
       const obj = parsed;
       processMetaLine(obj, meta);
       if (isMetaComplete(meta)) {
@@ -1214,7 +1267,7 @@ function extractSessionMeta(filePath) {
     }, {
       maxLines: 50,
       onMalformed: () => {}
-    });
+    }).pipe(Effect11.catchAll(() => Effect11.void));
     if (!(meta.timestamp && meta.firstMessage)) {
       return null;
     }
@@ -1231,10 +1284,10 @@ function extractSessionMeta(filePath) {
 // ../../packages/plugin-claude-code/src/parser.ts
 init_src();
 import { join as join7 } from "node:path";
-import { Effect as Effect11 } from "effect";
+import { Effect as Effect12 } from "effect";
 var MAX_RAW_LINE_LENGTH = 500;
 function loadClaudeSession(nativeId, sessionId) {
-  return Effect11.gen(function* () {
+  return Effect12.gen(function* () {
     const config = yield* PluginConfig;
     const filePath = join7(config.dataDir, "projects", nativeId, `${sessionId}.jsonl`);
     const { rawLines, parseErrors } = yield* readJsonlLines(filePath);
@@ -1266,10 +1319,10 @@ function loadClaudeSession(nativeId, sessionId) {
   });
 }
 function parseSubAgentSession(sessionId, encodedPath, agentId) {
-  return Effect11.gen(function* () {
+  return Effect12.gen(function* () {
     const config = yield* PluginConfig;
     const filePath = join7(config.dataDir, "projects", encodedPath, sessionId, "subagents", `agent-${agentId}.jsonl`);
-    const parsed = yield* readJsonlLines(filePath).pipe(Effect11.catchAll(() => Effect11.succeed({ rawLines: [], parseErrors: [] })));
+    const parsed = yield* readJsonlLines(filePath).pipe(Effect12.catchAll(() => Effect12.succeed({ rawLines: [], parseErrors: [] })));
     const subAgentMap = extractSubAgentMap(parsed.rawLines);
     const turns = buildTurns(parsed.rawLines, parsed.parseErrors);
     for (const turn of turns) {
@@ -1355,11 +1408,10 @@ function findImplSessionId(slug, sessions, currentSessionId) {
   return match?.sessionId;
 }
 function readJsonlLines(filePath) {
-  return Effect11.gen(function* () {
-    const text = yield* readFileText(filePath);
+  return Effect12.gen(function* () {
     const rawLines = [];
     const parseErrors = [];
-    iterateJsonl(text, ({ parsed }) => {
+    yield* streamJsonl(filePath, ({ parsed }) => {
       rawLines.push(parsed);
     }, {
       onMalformed: (line, lineNumber, error) => {
@@ -1664,20 +1716,20 @@ var claudeCodePlugin = {
   id: "claude-code",
   displayName: "Claude Code",
   getDefaultDataDir: () => null,
-  isDataAvailable: Effect12.gen(function* () {
+  isDataAvailable: Effect13.gen(function* () {
     const config = yield* PluginConfig;
-    return yield* fileExists(config.dataDir).pipe(Effect12.catchAll(() => Effect12.succeed(false)));
+    return yield* fileExists(config.dataDir).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
   }),
   discoverProjects: discoverClaudeProjects(),
   listSessions: (nativeId) => listClaudeSessions(nativeId),
-  loadSession: (nativeId, sessionId) => loadClaudeSession(nativeId, sessionId).pipe(Effect12.map((r) => r.session), Effect12.catchAll((err) => Effect12.fail(new PluginError({
+  loadSession: (nativeId, sessionId) => loadClaudeSession(nativeId, sessionId).pipe(Effect13.map((r) => r.session), Effect13.catchAll((err) => Effect13.fail(new PluginError({
     pluginId: "claude-code",
     operation: "loadSession",
     message: String(err),
     cause: err
   })))),
-  loadSessionDetail: (nativeId, sessionId) => Effect12.gen(function* () {
-    const [{ session, slug }, sessions] = yield* Effect12.all([
+  loadSessionDetail: (nativeId, sessionId) => Effect13.gen(function* () {
+    const [{ session, slug }, sessions] = yield* Effect13.all([
       loadClaudeSession(nativeId, sessionId),
       listClaudeSessions(nativeId)
     ]);
@@ -1686,7 +1738,7 @@ var claudeCodePlugin = {
       planSessionId: findPlanSessionId(session.turns, slug, sessions, sessionId),
       implSessionId: findImplSessionId(slug, sessions, sessionId)
     };
-  }).pipe(Effect12.catchAll((err) => Effect12.fail(new PluginError({
+  }).pipe(Effect13.catchAll((err) => Effect13.fail(new PluginError({
     pluginId: "claude-code",
     operation: "loadSessionDetail",
     message: String(err),
@@ -1698,74 +1750,17 @@ var claudeCodePlugin = {
 
 // ../../packages/plugin-codex/src/index.ts
 init_src();
-import { Effect as Effect17 } from "effect";
+import { Effect as Effect18 } from "effect";
 
 // ../../packages/plugin-codex/src/discovery.ts
 init_src();
-import { Effect as Effect15 } from "effect";
+import { Effect as Effect16 } from "effect";
 
 // ../../packages/plugin-codex/src/session-index.ts
 init_src();
 import { join as join9 } from "node:path";
 import { FileSystem as FileSystem6 } from "@effect/platform";
 import { Effect as Effect14 } from "effect";
-
-// ../../packages/plugin-codex/src/shared/discovery-utils.ts
-import { FileSystem as FileSystem5 } from "@effect/platform";
-import { Effect as Effect13 } from "effect";
-function readTextPrefix2(filePath, maxBytes) {
-  return Effect13.gen(function* () {
-    const fs = yield* FileSystem5.FileSystem;
-    const bytes = yield* fs.readFile(filePath);
-    const slice = bytes.subarray(0, maxBytes);
-    return new TextDecoder().decode(slice);
-  });
-}
-function readFileText2(filePath) {
-  return Effect13.gen(function* () {
-    const fs = yield* FileSystem5.FileSystem;
-    return yield* fs.readFileString(filePath);
-  });
-}
-function fileExists2(filePath) {
-  return Effect13.gen(function* () {
-    const fs = yield* FileSystem5.FileSystem;
-    return yield* fs.exists(filePath);
-  });
-}
-
-// ../../packages/plugin-codex/src/shared/jsonl-utils.ts
-function iterateJsonl2(text, visitor, options = {}) {
-  const lines = text.split(`
-`);
-  const start = Math.max(0, options.startAt ?? 0);
-  const end = options.maxLines === undefined ? lines.length : Math.min(lines.length, start + options.maxLines);
-  for (let i = start;i < end; i++) {
-    const line = lines[i];
-    if (!line?.trim()) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(line);
-      const shouldContinue = visitor({
-        parsed,
-        line,
-        lineIndex: i,
-        lineNumber: i + 1
-      });
-      if (shouldContinue === false) {
-        break;
-      }
-    } catch (error) {
-      options.onMalformed?.(line, i + 1, error);
-    }
-  }
-}
-
-// ../../packages/plugin-codex/src/session-index.ts
-var BYTES_PER_KB2 = 1024;
-var FIRST_LINE_SCAN_KB = 512;
-var FIRST_LINE_SCAN_BYTES = FIRST_LINE_SCAN_KB * BYTES_PER_KB2;
 var MS_PER_SECOND2 = 1000;
 function isCodexSessionMeta(obj) {
   return typeof obj === "object" && obj !== null && "uuid" in obj && "cwd" in obj && "timestamps" in obj && typeof obj.uuid === "string" && typeof obj.cwd === "string";
@@ -1805,50 +1800,45 @@ function extractTurnContextModel(parsed) {
   }
   return typeof event.payload?.model === "string" ? event.payload.model : null;
 }
-function inferModelFromPrefix(prefixText) {
-  let model = null;
-  iterateJsonl2(prefixText, ({ parsed }) => {
-    const extracted = extractTurnContextModel(parsed);
-    if (isKnownModel(extracted)) {
-      model = extracted;
-      return false;
-    }
-    return;
-  }, { startAt: 1, maxLines: 256 });
-  return model;
+function streamInferredModel(filePath) {
+  return Effect14.gen(function* () {
+    let model = null;
+    yield* streamJsonlHead(filePath, ({ parsed, lineIndex }) => {
+      if (lineIndex === 0) {
+        return;
+      }
+      const extracted = extractTurnContextModel(parsed);
+      if (isKnownModel(extracted)) {
+        model = extracted;
+        return false;
+      }
+      return;
+    }, { maxLines: 256 }).pipe(Effect14.catchAll(() => Effect14.void));
+    return model;
+  });
 }
 function parseSessionMeta(filePath, fileMtimeEpoch) {
   return Effect14.gen(function* () {
-    const prefix = yield* readTextPrefix2(filePath, FIRST_LINE_SCAN_BYTES).pipe(Effect14.catchAll(() => Effect14.succeed("")));
-    if (!prefix) {
+    const captured = { value: null };
+    yield* streamJsonlHead(filePath, ({ parsed }) => {
+      captured.value = normalizeSessionMeta(parsed, fileMtimeEpoch);
+      return false;
+    }, { maxLines: 1 }).pipe(Effect14.catchAll(() => Effect14.void));
+    const firstLineMeta = captured.value;
+    if (!firstLineMeta) {
       return null;
     }
-    const firstNewline = prefix.indexOf(`
-`);
-    const firstLine = firstNewline === -1 ? prefix : prefix.slice(0, firstNewline);
-    const trimmedFirstLine = firstLine.trim();
-    if (!trimmedFirstLine) {
-      return null;
+    if (isKnownModel(firstLineMeta.model)) {
+      return firstLineMeta;
     }
-    try {
-      const parsed = JSON.parse(trimmedFirstLine);
-      const meta = normalizeSessionMeta(parsed, fileMtimeEpoch);
-      if (!meta) {
-        return null;
-      }
-      if (isKnownModel(meta.model)) {
-        return meta;
-      }
-      const inferred = inferModelFromPrefix(prefix);
-      if (isKnownModel(inferred)) {
-        return { ...meta, model: inferred };
-      }
-      if (isKnownModel(meta.provider_id)) {
-        return { ...meta, model: meta.provider_id };
-      }
-      return meta;
-    } catch {}
-    return null;
+    const inferred = yield* streamInferredModel(filePath);
+    if (isKnownModel(inferred)) {
+      return { ...firstLineMeta, model: inferred };
+    }
+    if (isKnownModel(firstLineMeta.provider_id)) {
+      return { ...firstLineMeta, model: firstLineMeta.provider_id };
+    }
+    return firstLineMeta;
   });
 }
 function walkJsonlFiles(dir, visit) {
@@ -1934,15 +1924,57 @@ function findCodexSessionFileById(sessionId) {
   });
 }
 
-// ../../packages/plugin-codex/src/discovery.ts
-var BYTES_PER_KB3 = 1024;
-var SESSION_TITLE_SCAN_KB = 256;
-var SESSION_TITLE_SCAN_BYTES = SESSION_TITLE_SCAN_KB * BYTES_PER_KB3;
-function discoverCodexProjects() {
+// ../../packages/plugin-codex/src/shared/discovery-utils.ts
+import { FileSystem as FileSystem7 } from "@effect/platform";
+import { Effect as Effect15 } from "effect";
+function readFileText(filePath) {
   return Effect15.gen(function* () {
-    const sessions = yield* scanCodexSessions();
-    const byCwd = new Map;
-    for (const session of sessions) {
+    const fs = yield* FileSystem7.FileSystem;
+    return yield* fs.readFileString(filePath);
+  });
+}
+function fileExists2(filePath) {
+  return Effect15.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    return yield* fs.exists(filePath);
+  });
+}
+
+// ../../packages/plugin-codex/src/shared/jsonl-utils.ts
+function iterateJsonl(text, visitor, options = {}) {
+  const lines = text.split(`
+`);
+  const start = Math.max(0, options.startAt ?? 0);
+  const end = options.maxLines === undefined ? lines.length : Math.min(lines.length, start + options.maxLines);
+  for (let i = start;i < end; i++) {
+    const line = lines[i];
+    if (!line?.trim()) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      const shouldContinue = visitor({
+        parsed,
+        line,
+        lineIndex: i,
+        lineNumber: i + 1
+      });
+      if (shouldContinue === false) {
+        break;
+      }
+    } catch (error) {
+      options.onMalformed?.(line, i + 1, error);
+    }
+  }
+}
+
+// ../../packages/plugin-codex/src/discovery.ts
+var SESSION_FILE_CONCURRENCY2 = 16;
+function discoverCodexProjects() {
+  return Effect16.gen(function* () {
+    const sessions = yield* scanCodexSessions();
+    const byCwd = new Map;
+    for (const session of sessions) {
       const existing = byCwd.get(session.meta.cwd);
       if (existing) {
         existing.push(session);
@@ -1971,9 +2003,41 @@ function discoverCodexProjects() {
     return projects;
   });
 }
-function extractFirstUserMessage(text) {
+function visitForFirstUserMessage(parsed, captured) {
+  const event = parsed;
+  if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item.text) {
+    const maxPreviewLength = 200;
+    captured.value = event.item.text.slice(0, maxPreviewLength);
+    return true;
+  }
+  if (event.type === "event_msg" && event.payload?.type === "user_message") {
+    const payloadText = event.payload.message || event.payload.text;
+    if (typeof payloadText === "string" && payloadText) {
+      const maxMsgLength = 200;
+      captured.value = payloadText.slice(0, maxMsgLength);
+      return true;
+    }
+  }
+  return false;
+}
+function streamFirstUserMessage(filePath) {
+  return Effect16.gen(function* () {
+    const captured = { value: null };
+    yield* streamJsonlHead(filePath, ({ parsed, lineIndex }) => {
+      if (lineIndex === 0) {
+        return;
+      }
+      if (visitForFirstUserMessage(parsed, captured)) {
+        return false;
+      }
+      return;
+    }, { maxLines: 200 }).pipe(Effect16.catchAll(() => Effect16.void));
+    return captured.value;
+  });
+}
+function extractFirstUserMessageFromText(text) {
   let message = null;
-  iterateJsonl2(text, ({ parsed }) => {
+  iterateJsonl(text, ({ parsed }) => {
     const event = parsed;
     if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item.text) {
       const maxPreviewLength = 200;
@@ -1993,23 +2057,21 @@ function extractFirstUserMessage(text) {
   return message;
 }
 function listCodexSessions(nativeId) {
-  return Effect15.gen(function* () {
+  return Effect16.gen(function* () {
     const allSessions = yield* scanCodexSessions();
     const matching = allSessions.filter((s) => s.meta.cwd === nativeId);
-    const sessions = [];
-    for (const s of matching) {
+    const sessions = yield* Effect16.forEach(matching, (s) => Effect16.gen(function* () {
       let firstMessage = s.meta.name ?? "";
       if (!firstMessage) {
-        const prefix = yield* readTextPrefix2(s.filePath, SESSION_TITLE_SCAN_BYTES).pipe(Effect15.catchAll(() => Effect15.succeed("")));
-        firstMessage = extractFirstUserMessage(prefix) ?? "";
+        firstMessage = (yield* streamFirstUserMessage(s.filePath)) ?? "";
         if (!firstMessage) {
-          const fullText = yield* readFileText2(s.filePath).pipe(Effect15.catchAll(() => Effect15.succeed("")));
-          firstMessage = extractFirstUserMessage(fullText) ?? "";
+          const fullText = yield* readFileText(s.filePath).pipe(Effect16.catchAll(() => Effect16.succeed("")));
+          firstMessage = extractFirstUserMessageFromText(fullText) ?? "";
         }
         firstMessage ||= "Codex session";
       }
       const timestamp = epochSecondsToIso(s.meta.timestamps.created);
-      sessions.push({
+      return {
         sessionId: s.meta.uuid,
         timestamp,
         slug: s.meta.uuid,
@@ -2017,8 +2079,8 @@ function listCodexSessions(nativeId) {
         model: s.meta.model || "unknown",
         gitBranch: "",
         pluginId: "codex-cli"
-      });
-    }
+      };
+    }), { concurrency: SESSION_FILE_CONCURRENCY2 });
     sortByIsoDesc(sessions, (session) => session.timestamp);
     return sessions;
   });
@@ -2026,7 +2088,7 @@ function listCodexSessions(nativeId) {
 
 // ../../packages/plugin-codex/src/parser.ts
 init_src();
-import { Effect as Effect16 } from "effect";
+import { Effect as Effect17 } from "effect";
 function isKnownModel2(model) {
   return typeof model === "string" && model.length > 0 && model !== "unknown";
 }
@@ -2364,7 +2426,7 @@ function buildCodexTurns(events, model, timestamp) {
   return state.turns;
 }
 function loadCodexSession(_nativeId, sessionId) {
-  return Effect16.gen(function* () {
+  return Effect17.gen(function* () {
     const filePath = yield* findCodexSessionFileById(sessionId);
     if (!filePath) {
       return {
@@ -2374,11 +2436,11 @@ function loadCodexSession(_nativeId, sessionId) {
         pluginId: "codex-cli"
       };
     }
-    const text = yield* readFileText2(filePath);
+    const text = yield* readFileText(filePath);
     let meta = null;
     const events = [];
     let turnContextModel = null;
-    iterateJsonl2(text, ({ parsed, lineIndex }) => {
+    iterateJsonl(text, ({ parsed, lineIndex }) => {
       if (lineIndex === 0) {
         const normalized = normalizeSessionMeta(parsed);
         if (normalized) {
@@ -2418,13 +2480,13 @@ var codexCliPlugin = {
   id: "codex-cli",
   displayName: "Codex",
   getDefaultDataDir: () => null,
-  isDataAvailable: Effect17.gen(function* () {
+  isDataAvailable: Effect18.gen(function* () {
     const config = yield* PluginConfig;
-    return yield* fileExists2(config.dataDir).pipe(Effect17.catchAll(() => Effect17.succeed(false)));
+    return yield* fileExists2(config.dataDir).pipe(Effect18.catchAll(() => Effect18.succeed(false)));
   }),
   discoverProjects: discoverCodexProjects(),
   listSessions: (nativeId) => listCodexSessions(nativeId),
-  loadSession: (nativeId, sessionId) => loadCodexSession(nativeId, sessionId).pipe(Effect17.catchAll((err) => Effect17.fail(new PluginError({
+  loadSession: (nativeId, sessionId) => loadCodexSession(nativeId, sessionId).pipe(Effect18.catchAll((err) => Effect18.fail(new PluginError({
     pluginId: "codex-cli",
     operation: "loadSession",
     message: String(err),
@@ -2435,8 +2497,8 @@ var codexCliPlugin = {
 
 // ../../packages/plugin-cursor/src/index.ts
 init_src();
-import { FileSystem as FileSystem9 } from "@effect/platform";
-import { Effect as Effect23 } from "effect";
+import { FileSystem as FileSystem10 } from "@effect/platform";
+import { Effect as Effect24 } from "effect";
 
 // ../../packages/plugin-cursor/src/config.ts
 import { posix, win32 } from "node:path";
@@ -2494,16 +2556,16 @@ var DEFAULT_CURSOR_DIR = getDefaultCursorDir();
 init_src();
 import { join as join12 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Effect as Effect21 } from "effect";
+import { Effect as Effect22 } from "effect";
 
 // ../../packages/plugin-cursor/src/db.ts
 init_src();
-import { FileSystem as FileSystem7 } from "@effect/platform";
-import { Effect as Effect18 } from "effect";
+import { FileSystem as FileSystem8 } from "@effect/platform";
+import { Effect as Effect19 } from "effect";
 function openCursorDbIfExists(dbPath) {
-  return Effect18.gen(function* () {
-    const fs = yield* FileSystem7.FileSystem;
-    const exists = yield* fs.exists(dbPath).pipe(Effect18.catchAll(() => Effect18.succeed(false)));
+  return Effect19.gen(function* () {
+    const fs = yield* FileSystem8.FileSystem;
+    const exists = yield* fs.exists(dbPath).pipe(Effect19.catchAll(() => Effect19.succeed(false)));
     if (!exists) {
       return null;
     }
@@ -2515,25 +2577,25 @@ function openCursorGlobalDb() {
   return openCursorDbIfExists(getCursorGlobalDbPath());
 }
 function getCursorWorkspaceStorageDirEffect() {
-  return Effect18.succeed(getCursorWorkspaceStorageDir());
+  return Effect19.succeed(getCursorWorkspaceStorageDir());
 }
 
 // ../../packages/plugin-cursor/src/plans.ts
 import { basename } from "node:path";
-import { Effect as Effect20 } from "effect";
+import { Effect as Effect21 } from "effect";
 
 // ../../packages/plugin-cursor/src/shared/discovery-utils.ts
 init_src();
 import { join as join11 } from "node:path";
-import { FileSystem as FileSystem8 } from "@effect/platform";
-import { Effect as Effect19 } from "effect";
+import { FileSystem as FileSystem9 } from "@effect/platform";
+import { Effect as Effect20 } from "effect";
 function readDirEntriesSafe2(dir) {
-  return Effect19.gen(function* () {
-    const fs = yield* FileSystem8.FileSystem;
-    const names = yield* fs.readDirectory(dir).pipe(Effect19.catchAll(() => Effect19.succeed([])));
+  return Effect20.gen(function* () {
+    const fs = yield* FileSystem9.FileSystem;
+    const names = yield* fs.readDirectory(dir).pipe(Effect20.catchAll(() => Effect20.succeed([])));
     const entries = [];
     for (const name of names) {
-      const info = yield* fs.stat(join11(dir, name)).pipe(Effect19.catchAll(() => Effect19.succeed(null)));
+      const info = yield* fs.stat(join11(dir, name)).pipe(Effect20.catchAll(() => Effect20.succeed(null)));
       if (info) {
         entries.push({ name, isDirectory: info.type === "Directory" });
       }
@@ -2541,28 +2603,28 @@ function readDirEntriesSafe2(dir) {
     return entries;
   });
 }
-function readFileText3(filePath) {
-  return Effect19.gen(function* () {
-    const fs = yield* FileSystem8.FileSystem;
+function readFileText2(filePath) {
+  return Effect20.gen(function* () {
+    const fs = yield* FileSystem9.FileSystem;
     return yield* fs.readFileString(filePath);
   });
 }
 function fileExists3(filePath) {
-  return Effect19.gen(function* () {
-    const fs = yield* FileSystem8.FileSystem;
-    return yield* fs.exists(filePath).pipe(Effect19.catchAll(() => Effect19.succeed(false)));
+  return Effect20.gen(function* () {
+    const fs = yield* FileSystem9.FileSystem;
+    return yield* fs.exists(filePath).pipe(Effect20.catchAll(() => Effect20.succeed(false)));
   });
 }
 function listFilesWithMtime2(dir, suffix) {
-  return Effect19.gen(function* () {
-    const fs = yield* FileSystem8.FileSystem;
-    const names = yield* fs.readDirectory(dir).pipe(Effect19.catchAll(() => Effect19.succeed([])));
+  return Effect20.gen(function* () {
+    const fs = yield* FileSystem9.FileSystem;
+    const names = yield* fs.readDirectory(dir).pipe(Effect20.catchAll(() => Effect20.succeed([])));
     const results = [];
     for (const name of names) {
       if (!name.endsWith(suffix)) {
         continue;
       }
-      const info = yield* fs.stat(join11(dir, name)).pipe(Effect19.catchAll(() => Effect19.succeed(null)));
+      const info = yield* fs.stat(join11(dir, name)).pipe(Effect20.catchAll(() => Effect20.succeed(null)));
       if (info?.mtime._tag === "Some") {
         results.push({ fileName: name, mtime: info.mtime.value.toISOString() });
       }
@@ -2629,7 +2691,7 @@ function getPlanFallbackName(filePath) {
   return basename(filePath).replace(PLAN_FILE_SUFFIX_REGEX, "");
 }
 function readPlanDisplayName(filePath) {
-  return readFileText3(filePath).pipe(Effect20.map((text) => {
+  return readFileText2(filePath).pipe(Effect21.map((text) => {
     const parsed = parsePlanFrontmatter(text);
     return parsed.name || extractFirstHeading(parsed.body) || getPlanFallbackName(filePath);
   }));
@@ -2643,7 +2705,7 @@ function makeSystemTurn(text, timestamp) {
   };
 }
 function loadCursorPlanSession(plan) {
-  return readFileText3(plan.filePath).pipe(Effect20.map((text) => {
+  return readFileText2(plan.filePath).pipe(Effect21.map((text) => {
     const parsed = parsePlanFrontmatter(text);
     return {
       sessionId: plan.rawSessionId,
@@ -2664,7 +2726,7 @@ function tryParseJson2(value) {
 }
 
 // ../../packages/plugin-cursor/src/shared/jsonl-utils.ts
-function iterateJsonl3(text, visitor, options = {}) {
+function iterateJsonl2(text, visitor, options = {}) {
   const lines = text.split(`
 `);
   const start = Math.max(0, options.startAt ?? 0);
@@ -2774,6 +2836,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}`);
@@ -2787,13 +2858,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") {
@@ -2804,7 +2869,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;
   }
@@ -2814,7 +2885,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}`,
@@ -2841,6 +2912,31 @@ function parseProjectPathFromWorkspaceJson(content) {
   }
   return fileUrlToPath(parsed.folder);
 }
+function discoverWorkspaceDescriptors(targetProjectPath) {
+  return Effect22.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* readFileText2(workspaceJsonPath).pipe(Effect22.map(parseProjectPathFromWorkspaceJson), Effect22.catchAll(() => Effect22.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) {
@@ -2853,9 +2949,49 @@ 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 Effect22.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 }) => {
+  iterateJsonl2(text, ({ parsed }) => {
     const line = parsed;
     if (line.role !== "user" || !Array.isArray(line.message?.content)) {
       return;
@@ -2872,7 +3008,7 @@ function readFirstTranscriptUserMessage(text) {
   return firstMessage;
 }
 function listTranscriptFiles(agentTranscriptsDir) {
-  return Effect21.gen(function* () {
+  return Effect22.gen(function* () {
     const agentDirs = yield* readDirEntriesSafe2(agentTranscriptsDir);
     const files = [];
     for (const entry of agentDirs) {
@@ -2896,45 +3032,50 @@ function listTranscriptFiles(agentTranscriptsDir) {
     return files;
   });
 }
-function discoverBackgroundAgents(workspaceProjectPaths) {
-  return Effect21.gen(function* () {
+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 Effect22.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 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* readFileText2(transcript.filePath).pipe(Effect22.catchAll(() => Effect22.succeed("")));
+        firstMessage = readFirstTranscriptUserMessage(text) || firstMessage;
       }
-      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 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"
-        });
+      agentsById.set(transcript.agentId, createBackgroundAgentSummary(projectPath, transcript, firstMessage));
+    }
+    return agentsById;
+  });
+}
+function discoverBackgroundAgents(projectPaths, options = { readPreviewText: true }) {
+  return Effect22.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;
@@ -2971,8 +3112,8 @@ function createPlanSummary(entry, projectPath, filePath, displayName) {
     sessionType: "plan"
   };
 }
-function discoverMappedPlans(globalDb, composersById, agentsById) {
-  return Effect21.gen(function* () {
+function discoverMappedPlans(globalDb, composersById, agentsById, options = { loadDisplayName: true }) {
+  return Effect22.gen(function* () {
     const plansById = new Map;
     if (!globalDb) {
       return plansById;
@@ -2993,8 +3134,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(Effect22.catchAll(() => Effect22.succeed(""))) : "";
+      const summary = createPlanSummary(entry, projectPath, filePath, displayName || entry.name?.trim() || "Cursor plan");
       if (!summary) {
         continue;
       }
@@ -3025,63 +3166,57 @@ function buildProjects(sessionsByProject) {
   sortByIsoDesc(projects, (project) => project.lastActivity);
   return projects;
 }
+function buildCursorProjectIndex(nativeId) {
+  return Effect22.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);
+  return Effect22.gen(function* () {
     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,
@@ -3104,11 +3239,44 @@ function toSessionSummary(session) {
     sessionType: session.sessionType
   };
 }
+function buildCursorDiscoveryIndex() {
+  return buildCursorIndex().pipe(Effect22.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 Effect22.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(Effect22.map((index) => {
     const sessions = index.sessionsByProject.get(nativeId) ?? [];
     sortByIsoDesc(sessions, (session) => session.timestamp);
     return sessions.map(toSessionSummary);
@@ -3116,7 +3284,7 @@ function listCursorSessions(nativeId) {
 }
 
 // ../../packages/plugin-cursor/src/parser.ts
-import { Effect as Effect22 } from "effect";
+import { Effect as Effect23 } from "effect";
 var COMPOSER_PREFIX_REGEX = /^composer:/u;
 var AGENT_PREFIX_REGEX = /^agent:/u;
 var PLAN_PREFIX_REGEX = /^plan:/u;
@@ -3255,7 +3423,7 @@ function partialCursorSessionNotice(timestamp) {
 Klovi could not reconstruct the full Composer transcript from Cursor state. Showing recovered content only.`);
 }
 function loadCursorComposerSession(summary) {
-  return Effect22.gen(function* () {
+  return Effect23.gen(function* () {
     const globalDb = yield* openCursorGlobalDb();
     const baseTimestampMs = summary.createdAtMs;
     try {
@@ -3305,11 +3473,11 @@ function loadCursorComposerSession(summary) {
   });
 }
 function loadCursorAgentSession(summary) {
-  return Effect22.gen(function* () {
-    const text = yield* readFileText3(summary.filePath);
+  return Effect23.gen(function* () {
+    const text = yield* readFileText2(summary.filePath);
     const turns = [];
     let turnIndex = 0;
-    iterateJsonl3(text, ({ parsed }) => {
+    iterateJsonl2(text, ({ parsed }) => {
       const line = parsed;
       if (!Array.isArray(line.message?.content)) {
         return;
@@ -3341,11 +3509,11 @@ function loadCursorAgentSession(summary) {
   });
 }
 function loadCursorSession(nativeId, sessionId) {
-  return Effect22.gen(function* () {
-    const index = yield* buildCursorIndex();
+  return Effect23.gen(function* () {
+    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}`));
+      return yield* Effect23.fail(new Error(`Cursor session not found: ${sessionId}`));
     }
     if (session.kind === "composer") {
       return yield* loadCursorComposerSession(session);
@@ -3361,32 +3529,38 @@ var cursorPlugin = {
   id: "cursor",
   displayName: "Cursor",
   getDefaultDataDir: () => null,
-  isDataAvailable: Effect23.gen(function* () {
+  isDataAvailable: Effect24.gen(function* () {
     const config = yield* PluginConfig;
-    const fs = yield* FileSystem9.FileSystem;
-    const userDataExists = yield* fileExists3(config.dataDir).pipe(Effect23.catchAll(() => Effect23.succeed(false)));
+    const fs = yield* FileSystem10.FileSystem;
+    const userDataExists = yield* fileExists3(config.dataDir).pipe(Effect24.catchAll(() => Effect24.succeed(false)));
     if (userDataExists) {
       return true;
     }
-    const globalDbExists = yield* fs.exists(getCursorGlobalDbPath()).pipe(Effect23.catchAll(() => Effect23.succeed(false)));
+    const globalDbExists = yield* fs.exists(getCursorGlobalDbPath()).pipe(Effect24.catchAll(() => Effect24.succeed(false)));
     if (globalDbExists) {
       return true;
     }
-    return yield* fs.exists(getCursorWorkspaceStorageDir()).pipe(Effect23.catchAll(() => Effect23.succeed(false)));
+    return yield* fs.exists(getCursorWorkspaceStorageDir()).pipe(Effect24.catchAll(() => Effect24.succeed(false)));
   }),
-  discoverProjects: discoverCursorProjects().pipe(Effect23.catchAll((err) => Effect23.fail(new PluginError({
+  discoverProjects: discoverCursorProjects().pipe(Effect24.catchAll((err) => Effect24.fail(new PluginError({
     pluginId: "cursor",
     operation: "discoverProjects",
     message: String(err),
     cause: err
   })))),
-  listSessions: (nativeId) => listCursorSessions(nativeId).pipe(Effect23.catchAll((err) => Effect23.fail(new PluginError({
+  discoverIndex: buildCursorDiscoveryIndex().pipe(Effect24.catchAll((err) => Effect24.fail(new PluginError({
+    pluginId: "cursor",
+    operation: "discoverIndex",
+    message: String(err),
+    cause: err
+  })))),
+  listSessions: (nativeId) => listCursorSessions(nativeId).pipe(Effect24.catchAll((err) => Effect24.fail(new PluginError({
     pluginId: "cursor",
     operation: "listSessions",
     message: String(err),
     cause: err
   })))),
-  loadSession: (nativeId, sessionId) => loadCursorSession(nativeId, sessionId).pipe(Effect23.catchAll((err) => Effect23.fail(new PluginError({
+  loadSession: (nativeId, sessionId) => loadCursorSession(nativeId, sessionId).pipe(Effect24.catchAll((err) => Effect24.fail(new PluginError({
     pluginId: "cursor",
     operation: "loadSession",
     message: String(err),
@@ -3427,7 +3601,7 @@ class PluginRegistry2 extends PluginRegistry {
 
 // ../../packages/server/src/services/auto-discover.ts
 function createRegistry(settings) {
-  return Effect24.gen(function* () {
+  return Effect25.gen(function* () {
     const registry = new PluginRegistry2;
     for (const { plugin, defaultDir, defaultEnabled } of BUILTIN_PLUGIN_DESCRIPTORS) {
       const pluginSettings = settings?.plugins[plugin.id];
@@ -3437,7 +3611,7 @@ function createRegistry(settings) {
       }
       const dataDir = pluginSettings?.dataDir ?? defaultDir;
       const configLayer = makePluginConfigLayer({ dataDir });
-      const available = yield* plugin.isDataAvailable.pipe(Effect24.provide(configLayer), Effect24.catchAll(() => Effect24.succeed(false)));
+      const available = yield* plugin.isDataAvailable.pipe(Effect25.provide(configLayer), Effect25.catchAll(() => Effect25.succeed(false)));
       if (available) {
         registry.register(plugin, { dataDir });
       }
@@ -3447,12 +3621,12 @@ function createRegistry(settings) {
 }
 
 // ../../packages/server/src/services/onboarding-service.ts
-import { Effect as Effect26 } from "effect";
+import { Effect as Effect27 } from "effect";
 
 // ../../packages/server/src/services/settings.ts
 import { dirname, join as join13 } from "node:path";
-import { FileSystem as FileSystem10 } from "@effect/platform";
-import { Effect as Effect25 } from "effect";
+import { FileSystem as FileSystem11 } from "@effect/platform";
+import { Effect as Effect26 } from "effect";
 
 // ../../packages/server/src/services/errors.ts
 import { Data as Data2 } from "effect";
@@ -3497,16 +3671,16 @@ function getDefaultSettings() {
   };
 }
 function loadSettings(path) {
-  return Effect25.gen(function* () {
-    const fs = yield* FileSystem10.FileSystem;
-    const content = yield* fs.readFileString(path).pipe(Effect25.catchAll(() => Effect25.succeed(null)));
+  return Effect26.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
+    const content = yield* fs.readFileString(path).pipe(Effect26.catchAll(() => Effect26.succeed(null)));
     if (content === null) {
       return getDefaultSettings();
     }
-    const parsed = yield* Effect25.try({
+    const parsed = yield* Effect26.try({
       try: () => JSON.parse(content),
       catch: () => null
-    }).pipe(Effect25.catchAll(() => Effect25.succeed(null)));
+    }).pipe(Effect26.catchAll(() => Effect26.succeed(null)));
     if (parsed === null || parsed["version"] !== 1 || typeof parsed["plugins"] !== "object") {
       return getDefaultSettings();
     }
@@ -3514,37 +3688,37 @@ function loadSettings(path) {
   });
 }
 function saveSettings(path, settings) {
-  return Effect25.gen(function* () {
-    const fs = yield* FileSystem10.FileSystem;
+  return Effect26.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
     const dir = dirname(path);
-    yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect25.mapError((cause) => new SettingsWriteError({ path, cause })));
+    yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect26.mapError((cause) => new SettingsWriteError({ path, cause })));
     const tmpPath = join13(dir, `.settings-${Date.now()}.tmp`);
-    yield* fs.writeFileString(tmpPath, JSON.stringify(settings, null, 2)).pipe(Effect25.mapError((cause) => new SettingsWriteError({ path, cause })));
-    yield* fs.rename(tmpPath, path).pipe(Effect25.mapError((cause) => new SettingsWriteError({ path, cause })));
+    yield* fs.writeFileString(tmpPath, JSON.stringify(settings, null, 2)).pipe(Effect26.mapError((cause) => new SettingsWriteError({ path, cause })));
+    yield* fs.rename(tmpPath, path).pipe(Effect26.mapError((cause) => new SettingsWriteError({ path, cause })));
   });
 }
 function settingsFileExists(path) {
-  return Effect25.gen(function* () {
-    const fs = yield* FileSystem10.FileSystem;
-    return yield* fs.exists(path).pipe(Effect25.catchAll(() => Effect25.succeed(false)));
+  return Effect26.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
+    return yield* fs.exists(path).pipe(Effect26.catchAll(() => Effect26.succeed(false)));
   });
 }
 function deleteSettingsFile(path) {
-  return Effect25.gen(function* () {
-    const fs = yield* FileSystem10.FileSystem;
-    yield* fs.remove(path).pipe(Effect25.catchAll(() => Effect25.void));
+  return Effect26.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
+    yield* fs.remove(path).pipe(Effect26.catchAll(() => Effect26.void));
   });
 }
 
 // ../../packages/server/src/services/onboarding-service.ts
 function isFirstLaunch(settingsPath) {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     const exists = yield* settingsFileExists(settingsPath);
     return { firstLaunch: !exists };
   });
 }
 function completeOnboarding(settingsPath) {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     const { firstLaunch } = yield* isFirstLaunch(settingsPath);
     if (firstLaunch) {
       yield* saveSettings(settingsPath, getDefaultSettings());
@@ -3553,7 +3727,7 @@ function completeOnboarding(settingsPath) {
   });
 }
 function resetSettings(settingsPath) {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     yield* deleteSettingsFile(settingsPath);
     return { ok: true };
   });
@@ -3561,62 +3735,81 @@ function resetSettings(settingsPath) {
 
 // ../../packages/server/src/services/sessions-service.ts
 init_src();
-import { Effect as Effect27 } from "effect";
+import { Effect as Effect28 } from "effect";
+var DEFAULT_HEAD_SIZE = 100;
 function getProjects(registry) {
-  return Effect27.gen(function* () {
+  return Effect28.gen(function* () {
     const projects = yield* registry.discoverAllProjects();
     return { projects };
   });
 }
 function getSessions(registry, params) {
-  return Effect27.gen(function* () {
-    const projects = yield* registry.discoverAllProjects();
-    const project = projects.find((p) => p.encodedPath === params.encodedPath);
-    if (!project) {
+  return Effect28.gen(function* () {
+    const discovered = yield* registry.discoverAllProjectsWithSessions();
+    if (!discovered.projects.some((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) {
-  return Effect27.gen(function* () {
+function loadSessionInternal(registry, params) {
+  return Effect28.gen(function* () {
     const parsed = parseSessionId(params.sessionId);
     if (!(parsed.pluginId && parsed.rawSessionId)) {
-      return yield* Effect27.fail(new InvalidSessionIdError({ value: params.sessionId }));
+      return yield* Effect28.fail(new InvalidSessionIdError({ value: params.sessionId }));
     }
     const { pluginId } = parsed;
     const { rawSessionId } = parsed;
     const projects = yield* registry.discoverAllProjects();
     const project = projects.find((p) => p.encodedPath === params.project);
     if (!project) {
-      return yield* Effect27.fail(new ProjectNotFoundError({ encodedPath: params.project }));
+      return yield* Effect28.fail(new ProjectNotFoundError({ encodedPath: params.project }));
     }
     const source = project.sources.find((s) => s.pluginId === pluginId);
     if (!source) {
-      return yield* Effect27.fail(new PluginSourceNotFoundError({ pluginId, project: params.project }));
+      return yield* Effect28.fail(new PluginSourceNotFoundError({ pluginId, project: params.project }));
     }
     const plugin = registry.getPlugin(pluginId);
     const pluginConfig = registry.getPluginConfig(pluginId);
     const configLayer = makePluginConfigLayer(pluginConfig);
-    const sessionDetail = plugin.loadSessionDetail ? yield* plugin.loadSessionDetail(source.nativeId, rawSessionId).pipe(Effect27.provide(configLayer), Effect27.catchAll(() => Effect27.succeed(undefined))) : undefined;
-    const session = sessionDetail?.session ?? (yield* plugin.loadSession(source.nativeId, rawSessionId).pipe(Effect27.provide(configLayer), Effect27.catchAll(() => Effect27.die("loadSession failed"))));
+    const sessionDetail = plugin.loadSessionDetail ? yield* plugin.loadSessionDetail(source.nativeId, rawSessionId).pipe(Effect28.provide(configLayer), Effect28.catchAll(() => Effect28.succeed(undefined))) : undefined;
+    const session = sessionDetail?.session ?? (yield* plugin.loadSession(source.nativeId, rawSessionId).pipe(Effect28.provide(configLayer), Effect28.catchAll(() => Effect28.die("loadSession failed"))));
     session.sessionId = encodeSessionId(pluginId, rawSessionId);
     session.pluginId = pluginId;
     session.planSessionId = sessionDetail?.planSessionId ? encodeSessionId(pluginId, sessionDetail.planSessionId) : undefined;
     session.implSessionId = sessionDetail?.implSessionId ? encodeSessionId(pluginId, sessionDetail.implSessionId) : undefined;
-    return { session };
+    return { session, pluginId, rawSessionId };
+  });
+}
+function getSession(registry, params) {
+  return loadSessionInternal(registry, params).pipe(Effect28.map(({ session }) => ({ session })));
+}
+function getSessionHead(registry, params) {
+  return Effect28.gen(function* () {
+    const { session } = yield* loadSessionInternal(registry, params);
+    const headSize = params.headSize ?? DEFAULT_HEAD_SIZE;
+    const totalTurns = session.turns.length;
+    const headSession = { ...session, turns: session.turns.slice(0, headSize) };
+    return { session: headSession, totalTurns };
+  });
+}
+function getSessionTail(registry, params) {
+  return Effect28.gen(function* () {
+    const { session } = yield* loadSessionInternal(registry, params);
+    const fromTurn = Math.max(0, params.fromTurn);
+    const totalTurns = session.turns.length;
+    return { turns: fromTurn >= totalTurns ? [] : session.turns.slice(fromTurn) };
   });
 }
 function getSubAgent(registry, params) {
-  return Effect27.gen(function* () {
+  return Effect28.gen(function* () {
     const parsed = parseSessionId(params.sessionId);
     if (!(parsed.pluginId && parsed.rawSessionId)) {
-      return yield* Effect27.fail(new InvalidSessionIdError({ value: params.sessionId }));
+      return yield* Effect28.fail(new InvalidSessionIdError({ value: params.sessionId }));
     }
     const plugin = registry.getPlugin(parsed.pluginId);
     if (!plugin.loadSubAgentSession) {
-      return yield* Effect27.fail(new SubAgentNotSupportedError({ pluginId: parsed.pluginId }));
+      return yield* Effect28.fail(new SubAgentNotSupportedError({ pluginId: parsed.pluginId }));
     }
     const pluginConfig = registry.getPluginConfig(parsed.pluginId);
     const configLayer = makePluginConfigLayer(pluginConfig);
@@ -3624,7 +3817,7 @@ function getSubAgent(registry, params) {
       sessionId: parsed.rawSessionId,
       project: params.project,
       agentId: params.agentId
-    }).pipe(Effect27.provide(configLayer), Effect27.catchAll(() => Effect27.die("loadSubAgentSession failed")));
+    }).pipe(Effect28.provide(configLayer), Effect28.catchAll(() => Effect28.die("loadSubAgentSession failed")));
     return { session };
   });
 }
@@ -3633,11 +3826,11 @@ function projectNameFromPath(fullPath) {
   return parts.slice(-2).join("/");
 }
 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" });
+  return Effect28.gen(function* () {
+    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({
@@ -3653,10 +3846,10 @@ function searchSessions(registry) {
 }
 
 // ../../packages/server/src/services/settings-service.ts
-import { Effect as Effect28 } from "effect";
+import { Effect as Effect29 } from "effect";
 var DEFAULT_CHECK_INTERVAL_HOURS = 6;
 function buildPluginSettingsResponse(settingsPath) {
-  return Effect28.gen(function* () {
+  return Effect29.gen(function* () {
     const settings = yield* loadSettings(settingsPath);
     const plugins = BUILTIN_PLUGIN_DESCRIPTORS.map(({ plugin, defaultDir, defaultEnabled }) => {
       const { id } = plugin;
@@ -3680,13 +3873,13 @@ function getPluginSettings(settingsPath) {
   return buildPluginSettingsResponse(settingsPath);
 }
 function getGeneralSettings(settingsPath) {
-  return Effect28.gen(function* () {
+  return Effect29.gen(function* () {
     const settings = yield* loadSettings(settingsPath);
     return { showSecurityWarning: settings.general?.showSecurityWarning ?? true };
   });
 }
 function updateGeneralSettings(settingsPath, params) {
-  return Effect28.gen(function* () {
+  return Effect29.gen(function* () {
     const settings = yield* loadSettings(settingsPath);
     if (!settings.general) {
       settings.general = {};
@@ -3699,9 +3892,9 @@ function updateGeneralSettings(settingsPath, params) {
   });
 }
 function updatePluginSetting(settingsPath, params) {
-  return Effect28.gen(function* () {
+  return Effect29.gen(function* () {
     if (!BUILTIN_PLUGIN_ID_SET.has(params.pluginId)) {
-      return yield* Effect28.fail(new UnknownPluginError({ pluginId: params.pluginId }));
+      return yield* Effect29.fail(new UnknownPluginError({ pluginId: params.pluginId }));
     }
     const settings = yield* loadSettings(settingsPath);
     const descriptor = BUILTIN_PLUGIN_DESCRIPTORS.find(({ plugin }) => plugin.id === params.pluginId);
@@ -3721,7 +3914,7 @@ function updatePluginSetting(settingsPath, params) {
   });
 }
 function getUpdateSettings(settingsPath) {
-  return Effect28.gen(function* () {
+  return Effect29.gen(function* () {
     const settings = yield* loadSettings(settingsPath);
     return {
       channel: settings.updates?.channel ?? "stable",
@@ -3731,7 +3924,7 @@ function getUpdateSettings(settingsPath) {
   });
 }
 function updateUpdateSettings(settingsPath, params) {
-  return Effect28.gen(function* () {
+  return Effect29.gen(function* () {
     const settings = yield* loadSettings(settingsPath);
     if (!settings.updates) {
       settings.updates = { channel: "stable", checkIntervalHours: 6, autoDownload: true };
@@ -3756,11 +3949,13 @@ function updateUpdateSettings(settingsPath, params) {
 }
 
 // ../../packages/server/src/services/stats-service.ts
-import { Effect as Effect30 } from "effect";
+import { dirname as dirname2, join as join14 } from "node:path";
+import { FileSystem as FileSystem12 } from "@effect/platform";
+import { Effect as Effect31 } from "effect";
 
 // ../../packages/server/src/services/stats.ts
 init_src();
-import { Effect as Effect29 } from "effect";
+import { Effect as Effect30 } from "effect";
 function emptyStats(projects = 0) {
   return {
     projects,
@@ -3820,12 +4015,12 @@ function countVisibleMessages(turns) {
   return turns.filter((turn) => turn.kind !== "parse_error").length;
 }
 function collectSessionsWithProjects(registry, stats) {
-  return Effect29.gen(function* () {
-    const projects = yield* registry.discoverAllProjects();
-    stats.projects = projects.length;
+  return Effect30.gen(function* () {
+    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 });
@@ -3840,7 +4035,7 @@ function applyRecentSessionStats(stats, sessionsWithProject) {
   stats.thisWeekSessions = recent.thisWeekSessions;
 }
 function loadSessionForStats(registry, project, session) {
-  return Effect29.gen(function* () {
+  return Effect30.gen(function* () {
     if (!session.pluginId) {
       return null;
     }
@@ -3852,7 +4047,7 @@ function loadSessionForStats(registry, project, session) {
     const pluginConfig = registry.getPluginConfig(session.pluginId);
     const { rawSessionId } = parseSessionId(session.sessionId);
     const configLayer = makePluginConfigLayer(pluginConfig);
-    const loaded = yield* plugin.loadSession(source.nativeId, rawSessionId).pipe(Effect29.provide(configLayer), Effect29.catchAll(() => Effect29.succeed(null)));
+    const loaded = yield* plugin.loadSession(source.nativeId, rawSessionId).pipe(Effect30.provide(configLayer), Effect30.catchAll(() => Effect30.succeed(null)));
     return loaded?.turns ?? null;
   });
 }
@@ -3866,6 +4061,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) {
@@ -3873,19 +4071,19 @@ 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);
   }
 }
 function computeStats(registry) {
-  return Effect29.gen(function* () {
+  return Effect30.gen(function* () {
     const stats = emptyStats();
     const sessionsWithProject = yield* collectSessionsWithProjects(registry, stats);
     applyRecentSessionStats(stats, sessionsWithProject);
-    const turnsPerSession = yield* Effect29.forEach(sessionsWithProject, (item) => loadSessionForStats(registry, item.project, item.session).pipe(Effect29.map((turns) => ({ item, turns }))), { concurrency: "unbounded" });
+    const turnsPerSession = yield* Effect30.forEach(sessionsWithProject, (item) => loadSessionForStats(registry, item.project, item.session).pipe(Effect30.map((turns) => ({ item, turns }))), { concurrency: "unbounded" });
     for (const { item, turns } of turnsPerSession) {
       if (!turns) {
         continue;
@@ -3900,10 +4098,163 @@ function scanStats(registry) {
 }
 
 // ../../packages/server/src/services/stats-service.ts
-function getStats(registry) {
-  return Effect30.gen(function* () {
+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 Effect31.gen(function* () {
+    const fs = yield* FileSystem12.FileSystem;
+    const cachePath = getStatsCachePath(settingsPath);
+    const raw = yield* fs.readFileString(cachePath).pipe(Effect31.catchAll(() => Effect31.succeed(null)));
+    if (raw === null) {
+      return null;
+    }
+    const parsed = yield* Effect31.try({
+      try: () => JSON.parse(raw),
+      catch: () => null
+    }).pipe(Effect31.catchAll(() => Effect31.succeed(null)));
+    return parsed !== null && isStatsCacheFile(parsed) ? parsed : null;
+  });
+}
+function persistStatsCache(settingsPath, stats, expectedEpoch) {
+  return Effect31.gen(function* () {
+    const fs = yield* FileSystem12.FileSystem;
+    const cachePath = getStatsCachePath(settingsPath);
+    const cacheDir = dirname2(cachePath);
+    const cachedAt = new Date().toISOString();
+    yield* fs.makeDirectory(cacheDir, { recursive: true }).pipe(Effect31.catchAll(() => Effect31.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(Effect31.map(() => true), Effect31.catchAll(() => Effect31.succeed(false)));
+    if (!wroteTempFile) {
+      return null;
+    }
+    if (getRefreshEpoch(cachePath) !== expectedEpoch) {
+      yield* fs.remove(tmpPath).pipe(Effect31.catchAll(() => Effect31.void));
+      return null;
+    }
+    const renamed = yield* fs.rename(tmpPath, cachePath).pipe(Effect31.map(() => true), Effect31.catchAll(() => fs.remove(tmpPath).pipe(Effect31.catchAll(() => Effect31.void), Effect31.map(() => false))));
+    if (!renamed) {
+      return null;
+    }
+    return getRefreshEpoch(cachePath) === expectedEpoch ? cachedAt : null;
+  });
+}
+function computeAndPersistStats(settingsPath, registry, expectedEpoch) {
+  return Effect31.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 Effect31.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(Effect31.ensuring(Effect31.sync(() => {
+    refreshingCachePaths.delete(getStatsCachePath(settingsPath));
+  })));
+}
+function scheduleRefresh(settingsPath, registry) {
+  return Effect31.gen(function* () {
+    const cachePath = getStatsCachePath(settingsPath);
+    if (refreshingCachePaths.has(cachePath)) {
+      return;
+    }
+    const expectedEpoch = getRefreshEpoch(cachePath);
+    refreshingCachePaths.add(cachePath);
+    yield* computeAndPersistStats(settingsPath, registry, expectedEpoch).pipe(Effect31.catchAllCause(() => Effect31.void), Effect31.ensuring(Effect31.sync(() => {
+      refreshingCachePaths.delete(cachePath);
+    })), Effect31.forkDaemon);
+  });
+}
+function getStats(settingsPath, registry) {
+  return Effect31.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 Effect31.gen(function* () {
+    const fs = yield* FileSystem12.FileSystem;
+    const cachePath = getStatsCachePath(settingsPath);
+    bumpRefreshEpoch(cachePath);
+    yield* fs.remove(cachePath).pipe(Effect31.catchAll(() => Effect31.void));
   });
 }
 
@@ -3919,37 +4270,41 @@ function getVersion(state) {
 // ../../packages/server/src/effect/server-services.ts
 class KloviServices extends Context4.Tag("@klovi/KloviServices")() {
 }
-var KloviServicesLive = Layer6.effect(KloviServices, Effect31.gen(function* () {
+var KloviServicesLive = Layer6.effect(KloviServices, Effect32.gen(function* () {
   const config = yield* ServerConfig;
   const { settingsPath } = config;
   const versionState = makeVersionState(config.version, config.commit);
   const settings = yield* loadSettings(settingsPath);
   let registry = yield* createRegistry(settings);
-  const refreshRegistry = () => Effect31.gen(function* () {
+  const refreshRegistry = () => Effect32.gen(function* () {
     const freshSettings = yield* loadSettings(settingsPath);
     registry = yield* createRegistry(freshSettings);
   });
   return {
     acceptRisks: () => completeOnboarding(settingsPath),
-    getVersion: () => Effect31.succeed(getVersion(versionState)),
-    getStats: () => getStats(registry),
+    getVersion: () => Effect32.succeed(getVersion(versionState)),
+    getStats: () => getStats(settingsPath, registry),
     getProjects: () => getProjects(registry),
     getSessions: (params) => getSessions(registry, params),
     getSession: (params) => getSession(registry, params),
+    getSessionHead: (params) => getSessionHead(registry, params),
+    getSessionTail: (params) => getSessionTail(registry, params),
     getSubAgent: (params) => getSubAgent(registry, params),
     searchSessions: () => searchSessions(registry),
     getPluginSettings: () => getPluginSettings(settingsPath),
-    updatePluginSetting: (params) => Effect31.gen(function* () {
+    updatePluginSetting: (params) => Effect32.gen(function* () {
       const result = yield* updatePluginSetting(settingsPath, params);
       yield* refreshRegistry();
+      yield* invalidateStatsCache(settingsPath);
       return result;
     }),
     getGeneralSettings: () => getGeneralSettings(settingsPath),
     updateGeneralSettings: (params) => updateGeneralSettings(settingsPath, params),
     isFirstLaunch: () => isFirstLaunch(settingsPath),
-    resetSettings: () => Effect31.gen(function* () {
+    resetSettings: () => Effect32.gen(function* () {
       const result = yield* resetSettings(settingsPath);
       yield* refreshRegistry();
+      yield* invalidateStatsCache(settingsPath);
       return result;
     }),
     getUpdateSettings: () => getUpdateSettings(settingsPath),
@@ -3962,7 +4317,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") {
@@ -3998,28 +4353,28 @@ async function bootstrapServer(options, makeServe) {
     resolveAddress = resolve;
     rejectAddress = reject;
   });
-  const addressCapture = Layer8.effectDiscard(HttpServer.addressWith((address) => Effect32.gen(function* () {
+  const addressCapture = Layer8.effectDiscard(HttpServer.addressWith((address) => Effect33.gen(function* () {
     const addr = address;
     const url2 = `http://${addr.hostname}:${addr.port}`;
-    yield* Effect32.log(`Klovi server listening on ${url2}`);
+    yield* Effect33.log(`Klovi server listening on ${url2}`);
     resolveAddress(url2);
   })));
   const serveLayer = makeServe();
   const fullLayer = Layer8.merge(serveLayer, addressCapture).pipe(Layer8.provide(servicesLayer), Layer8.provide(configLayer), Layer8.provide(platformLayer));
-  const fiber = Effect32.runFork(Layer8.launch(fullLayer));
-  Effect32.runFork(Fiber.join(fiber).pipe(Effect32.catchAllCause((cause) => Effect32.sync(() => rejectAddress(Cause.squash(cause))))));
+  const fiber = Effect33.runFork(Layer8.launch(fullLayer));
+  Effect33.runFork(Fiber.join(fiber).pipe(Effect33.catchAllCause((cause) => Effect33.sync(() => rejectAddress(Cause.squash(cause))))));
   const url = await addressPromise;
   return {
     url,
     stop: () => {
-      Effect32.runFork(Fiber.interrupt(fiber));
+      Effect33.runFork(Fiber.interrupt(fiber));
     }
   };
 }
 
 // ../../packages/server/src/effect/http-app.ts
 import { HttpRouter, HttpServer as HttpServer2, HttpServerRequest, HttpServerResponse } from "@effect/platform";
-import { Effect as Effect33 } from "effect";
+import { Effect as Effect34 } from "effect";
 
 // ../../packages/server/src/rpc-error.ts
 class RPCError extends Error {
@@ -4060,7 +4415,7 @@ function mapDomainErrorToStatus(err) {
   const message = err instanceof Error ? err.message : "Internal server error";
   return { status: 500, message };
 }
-var rpcHandler = Effect33.gen(function* () {
+var rpcHandler = Effect34.gen(function* () {
   const services = yield* KloviServices;
   const routeParams = yield* HttpRouter.params;
   const req = yield* HttpServerRequest.HttpServerRequest;
@@ -4070,7 +4425,7 @@ var rpcHandler = Effect33.gen(function* () {
   }
   if (!isRpcMethod(method, services)) {
     const httpNotFound = 404;
-    return yield* Effect33.fail(new RPCError(httpNotFound, `Unknown method: ${method}`));
+    return yield* Effect34.fail(new RPCError(httpNotFound, `Unknown method: ${method}`));
   }
   let params = {};
   const bodyText = yield* req.text;
@@ -4084,34 +4439,39 @@ var rpcHandler = Effect33.gen(function* () {
   const handler = services[method];
   const value = yield* handler(params);
   return HttpServerResponse.unsafeJson(value);
-}).pipe(Effect33.catchAll((err) => {
+}).pipe(Effect34.catchAll((err) => {
   const { status, message } = mapDomainErrorToStatus(err);
-  return Effect33.succeed(HttpServerResponse.unsafeJson({ error: message }, { status }));
+  return Effect34.succeed(HttpServerResponse.unsafeJson({ error: message }, { status }));
 }));
-var emptyMethodHandler = Effect33.succeed(HttpServerResponse.unsafeJson({ error: "Method name required" }, { status: 400 }));
+var emptyMethodHandler = Effect34.succeed(HttpServerResponse.unsafeJson({ error: "Method name required" }, { status: 400 }));
 var makeRpcRouter = () => HttpRouter.empty.pipe(HttpRouter.post("/api/rpc/", emptyMethodHandler), HttpRouter.post("/api/rpc/:method", rpcHandler));
-var notFoundHandler = Effect33.succeed(HttpServerResponse.unsafeJson({ error: "Not found" }, { status: 404 }));
-var makeHttpApp = () => makeRpcRouter().pipe(Effect33.catchTag("RouteNotFound", () => notFoundHandler));
+var notFoundHandler = Effect34.succeed(HttpServerResponse.unsafeJson({ error: "Not found" }, { status: 404 }));
+var makeHttpApp = () => makeRpcRouter().pipe(Effect34.catchTag("RouteNotFound", () => notFoundHandler));
 var makeServeLayer = () => makeHttpApp().pipe(HttpServer2.serve());
 
 // src/http-app.ts
 import { HttpServer as HttpServer3 } from "@effect/platform";
-import { Effect as Effect35 } from "effect";
+import { Effect as Effect36 } from "effect";
 
 // src/static-handler.ts
 import { HttpServerRequest as HttpServerRequest2, HttpServerResponse as HttpServerResponse2 } from "@effect/platform";
-import { Effect as Effect34 } from "effect";
-var makeStaticHandler = (staticDir) => Effect34.gen(function* () {
+import { Effect as Effect35 } 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) => Effect35.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(Effect35.orElse(() => isNavigationRequest(url.pathname) ? HttpServerResponse2.file(`${staticDir}/index.html`).pipe(Effect35.orElse(() => Effect35.succeed(notFound))) : Effect35.succeed(notFound)));
 });
 
 // src/http-app.ts
 var makePackageHttpApp = (staticDir) => {
   const router = makeRpcRouter();
-  return router.pipe(Effect35.catchTag("RouteNotFound", () => makeStaticHandler(staticDir)));
+  return router.pipe(Effect36.catchTag("RouteNotFound", () => makeStaticHandler(staticDir)));
 };
 var makePackageServeLayer = (staticDir) => {
   if (!staticDir) {