@claude-sessions/core 0.4.6 → 0.4.7-beta.1

package/dist/index.js

@@ -66,14 +66,13 @@ var extractTitle = (input) => {
     text = extractTextContent(input, { stripIdeTags: true });
   }
   if (!text) return "Untitled";
-  const { name, args } = parseCommandMessage(text);
-  if (name) return args ? `${name} ${args}` : name;
-  let cleaned = text.trim();
-  if (!cleaned) return "Untitled";
-  if (cleaned.includes("\n\n")) {
-    cleaned = cleaned.split("\n\n")[0];
+  let firstParagraph = text.trim();
+  if (firstParagraph.includes("\n\n")) {
+    firstParagraph = firstParagraph.split("\n\n")[0];
   }
-  return cleaned || "Untitled";
+  const { name, args } = parseCommandMessage(firstParagraph);
+  if (name) return args ? `${name} ${args}` : name;
+  return firstParagraph || "Untitled";
 };
 var isInvalidApiKeyMessage = (msg) => {
   const text = extractTextContent(msg.message);
@@ -102,11 +101,12 @@ var getDisplayTitle = (customTitle, currentSummary, title, maxLength = 60, fallb
     return currentSummary.length > maxLength ? currentSummary.slice(0, maxLength - 3) + "..." : currentSummary;
   }
   if (title && title !== "Untitled") {
-    if (title.includes("<command-name>")) {
-      const { name, args } = parseCommandMessage(title);
+    const firstParagraph = title.includes("\n\n") ? title.split("\n\n")[0] : title;
+    if (firstParagraph.includes("<command-name>")) {
+      const { name, args } = parseCommandMessage(firstParagraph);
       if (name) return args ? `${name} ${args}` : name;
     }
-    return title;
+    return firstParagraph;
   }
   return fallback;
 };
@@ -152,27 +152,32 @@ var tryParseJsonLine = (line, lineNumber, filePath) => {
     return JSON.parse(line);
   } catch {
     if (filePath) {
-      console.warn(`Skipping invalid JSON at line ${lineNumber} in ${filePath}`);
+      logger.warn(`Skipping invalid JSON at line ${lineNumber} in ${filePath}`);
     }
     return null;
   }
 };
-var parseJsonlLines = (lines, filePath) => {
-  return lines.map((line, idx) => {
+var parseJsonlLines = (lines, filePath, { strict = false } = {}) => {
+  const results = [];
+  for (let idx = 0; idx < lines.length; idx++) {
     try {
-      return JSON.parse(line);
+      results.push(JSON.parse(lines[idx]));
     } catch (e) {
       const err = e;
-      throw new Error(`Failed to parse line ${idx + 1} in ${filePath}: ${err.message}`, {
-        cause: e
-      });
+      if (strict) {
+        throw new Error(`Failed to parse line ${idx + 1} in ${filePath}: ${err.message}`, {
+          cause: e
+        });
+      }
+      logger.warn(`Skipping malformed line ${idx + 1} in ${filePath}: ${err.message}`);
     }
-  });
+  }
+  return results;
 };
-var readJsonlFile = (filePath) => Effect.gen(function* () {
+var readJsonlFile = (filePath, options) => Effect.gen(function* () {
   const content = yield* Effect.tryPromise(() => fs.readFile(filePath, "utf-8"));
   const lines = content.trim().split("\n").filter(Boolean);
-  return parseJsonlLines(lines, filePath);
+  return parseJsonlLines(lines, filePath, options);
 });
 var formatRelativeTime = (timestamp) => {
   const date = typeof timestamp === "string" ? new Date(timestamp) : new Date(timestamp);
@@ -333,14 +338,14 @@ var resolvePathFromClaudeConfig = async (folderName, fileSystem = fsp) => {
 };
 var folderNameToPath = async (folderName) => {
   const homeDir = os.homedir();
-  const realPath = getRealPathFromSession(folderName);
-  if (realPath) {
-    return toRelativePath(realPath, homeDir);
-  }
   const configPath = await resolvePathFromClaudeConfig(folderName);
   if (configPath) {
     return toRelativePath(configPath, homeDir);
   }
+  const realPath = getRealPathFromSession(folderName);
+  if (realPath) {
+    return toRelativePath(realPath, homeDir);
+  }
   const absolutePath = folderNameToDisplayPath(folderName);
   return toRelativePath(absolutePath, homeDir);
 };
@@ -1081,7 +1086,7 @@ function deleteMessageWithChainRepair(messages, targetId, targetType) {
 // src/session/crud.ts
 var updateSessionSummary = (projectName, sessionId, newSummary) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const messages = yield* readJsonlFile(filePath);
+  const messages = yield* readJsonlFile(filePath, { strict: true });
   const summaryIdx = messages.findIndex((m) => m.type === "summary");
   if (summaryIdx >= 0) {
     messages[summaryIdx] = { ...messages[summaryIdx], summary: newSummary };
@@ -1160,7 +1165,7 @@ var readSession = (projectName, sessionId) => Effect5.gen(function* () {
 });
 var deleteMessage = (projectName, sessionId, messageUuid, targetType) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const messages = yield* readJsonlFile(filePath);
+  const messages = yield* readJsonlFile(filePath, { strict: true });
   const result = deleteMessageWithChainRepair(messages, messageUuid, targetType);
   if (!result.deleted) {
     return { success: false, error: "Message not found" };
@@ -1171,7 +1176,7 @@ var deleteMessage = (projectName, sessionId, messageUuid, targetType) => Effect5
 });
 var restoreMessage = (projectName, sessionId, message, index) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const messages = yield* readJsonlFile(filePath);
+  const messages = yield* readJsonlFile(filePath, { strict: true });
   const msgUuid = message.uuid ?? message.messageId;
   if (!msgUuid) {
     return { success: false, error: "Message has no uuid or messageId" };
@@ -1236,7 +1241,7 @@ var renameSession = (projectName, sessionId, newTitle) => Effect5.gen(function*
   if (lines.length === 0) {
     return { success: false, error: "Empty session" };
   }
-  const messages = parseJsonlLines(lines, filePath);
+  const messages = parseJsonlLines(lines, filePath, { strict: true });
   const customTitleIdx = messages.findIndex((m) => m.type === "custom-title");
   if (customTitleIdx >= 0) {
     messages.splice(customTitleIdx, 1);
@@ -1286,7 +1291,7 @@ var moveSession = (sourceProject, sessionId, targetProject) => Effect5.gen(funct
 var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect5.gen(function* () {
   const projectPath = path5.join(getSessionsDir(), projectName);
   const filePath = path5.join(projectPath, `${sessionId}.jsonl`);
-  const allMessages = yield* readJsonlFile(filePath);
+  const allMessages = yield* readJsonlFile(filePath, { strict: true });
   const splitIndex = allMessages.findIndex((m) => m.uuid === splitAtMessageUuid);
   if (splitIndex === -1) {
     return { success: false, error: "Message not found" };
@@ -1333,7 +1338,9 @@ var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect5.gen(f
     const agentContent = yield* Effect5.tryPromise(() => fs6.readFile(agentPath, "utf-8"));
     const agentLines = agentContent.trim().split("\n").filter(Boolean);
     if (agentLines.length === 0) continue;
-    const agentMessages = parseJsonlLines(agentLines, agentPath);
+    const agentMessages = parseJsonlLines(agentLines, agentPath, {
+      strict: true
+    });
     const firstAgentMsg = agentMessages[0];
     if (firstAgentMsg.sessionId === sessionId) {
       const agentId = agentFile.replace("agent-", "").replace(".jsonl", "");
@@ -1359,7 +1366,7 @@ var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect5.gen(f
 });
 var repairChain = (projectName, sessionId) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const messages = yield* readJsonlFile(filePath);
+  const messages = yield* readJsonlFile(filePath, { strict: true });
   const beforeResult = validateChain(messages);
   const repairCount = autoRepairChain(messages);
   if (repairCount > 0) {
@@ -1376,8 +1383,75 @@ var repairChain = (projectName, sessionId) => Effect5.gen(function* () {
 
 // src/session/tree.ts
 import { Effect as Effect6 } from "effect";
+import * as fs8 from "fs/promises";
+import * as path7 from "path";
+
+// src/session/cache.ts
 import * as fs7 from "fs/promises";
 import * as path6 from "path";
+var log2 = createLogger("cache");
+var CACHE_VERSION = 1;
+var CACHE_FILENAME = ".tree-cache.json";
+var getCachePath = (projectName) => path6.join(getSessionsDir(), projectName, CACHE_FILENAME);
+var loadTreeCache = async (projectName) => {
+  const cachePath = getCachePath(projectName);
+  try {
+    const raw = await fs7.readFile(cachePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION) {
+      log2.debug(`cache version mismatch (${parsed.version} !== ${CACHE_VERSION}), ignoring`);
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var writeTreeCache = async (projectName, cache) => {
+  const cachePath = getCachePath(projectName);
+  const tmpPath = cachePath + ".tmp";
+  try {
+    await fs7.writeFile(tmpPath, JSON.stringify(cache), "utf-8");
+    await fs7.rename(tmpPath, cachePath);
+  } catch (e) {
+    log2.debug(`failed to write cache: ${e}`);
+    try {
+      await fs7.unlink(tmpPath);
+    } catch {
+    }
+  }
+};
+var validateCache = (cache, sessionFileIds, currentMtimes) => {
+  const cachedIds = new Set(Object.keys(cache.sessions));
+  const currentIds = new Set(sessionFileIds);
+  const changedSessionIds = [];
+  const unchangedSessionIds = [];
+  const newSessionIds = [];
+  const deletedSessionIds = [];
+  for (const id of currentIds) {
+    if (!cachedIds.has(id)) {
+      newSessionIds.push(id);
+    } else {
+      const cachedMtime = cache.sessions[id].fileMtime;
+      const currentMtime = currentMtimes.get(id) ?? 0;
+      if (Math.abs(cachedMtime - currentMtime) <= 1) {
+        unchangedSessionIds.push(id);
+      } else {
+        changedSessionIds.push(id);
+      }
+    }
+  }
+  for (const id of cachedIds) {
+    if (!currentIds.has(id)) {
+      deletedSessionIds.push(id);
+    }
+  }
+  const isFullHit = changedSessionIds.length === 0 && newSessionIds.length === 0 && deletedSessionIds.length === 0;
+  return { isFullHit, changedSessionIds, unchangedSessionIds, deletedSessionIds, newSessionIds };
+};
+
+// src/session/tree.ts
+var log3 = createLogger("tree");
 var sortSessions = (sessions, sort) => {
   return sessions.sort((a, b) => {
     let comparison = 0;
@@ -1417,9 +1491,9 @@ var sortSessions = (sessions, sort) => {
   });
 };
 var loadSessionTreeDataInternal = (projectName, sessionId, summariesByTargetSession, fileMtime) => Effect6.gen(function* () {
-  const projectPath = path6.join(getSessionsDir(), projectName);
-  const filePath = path6.join(projectPath, `${sessionId}.jsonl`);
-  const content = yield* Effect6.tryPromise(() => fs7.readFile(filePath, "utf-8"));
+  const projectPath = path7.join(getSessionsDir(), projectName);
+  const filePath = path7.join(projectPath, `${sessionId}.jsonl`);
+  const content = yield* Effect6.tryPromise(() => fs8.readFile(filePath, "utf-8"));
   const lines = content.trim().split("\n").filter(Boolean);
   const messages = parseJsonlLines(lines, filePath);
   let summaries;
@@ -1437,12 +1511,12 @@ var loadSessionTreeDataInternal = (projectName, sessionId, summariesByTargetSess
         sessionUuids.add(msg.uuid);
       }
     }
-    const projectFiles = yield* Effect6.tryPromise(() => fs7.readdir(projectPath));
+    const projectFiles = yield* Effect6.tryPromise(() => fs8.readdir(projectPath));
     const allJsonlFiles = projectFiles.filter((f) => f.endsWith(".jsonl"));
     for (const file of allJsonlFiles) {
       try {
-        const otherFilePath = path6.join(projectPath, file);
-        const otherContent = yield* Effect6.tryPromise(() => fs7.readFile(otherFilePath, "utf-8"));
+        const otherFilePath = path7.join(projectPath, file);
+        const otherContent = yield* Effect6.tryPromise(() => fs8.readFile(otherFilePath, "utf-8"));
         const otherLines = otherContent.trim().split("\n").filter(Boolean);
         for (let i = 0; i < otherLines.length; i++) {
           const msg = tryParseJsonLine(otherLines[i], i + 1, otherFilePath);
@@ -1486,9 +1560,9 @@ var loadSessionTreeDataInternal = (projectName, sessionId, summariesByTargetSess
   const linkedAgentIds = yield* findLinkedAgents(projectName, sessionId);
   const agents = [];
   for (const agentId of linkedAgentIds) {
-    const agentPath = path6.join(projectPath, `${agentId}.jsonl`);
+    const agentPath = path7.join(projectPath, `${agentId}.jsonl`);
     try {
-      const agentContent = yield* Effect6.tryPromise(() => fs7.readFile(agentPath, "utf-8"));
+      const agentContent = yield* Effect6.tryPromise(() => fs8.readFile(agentPath, "utf-8"));
       const agentLines = agentContent.trim().split("\n").filter(Boolean);
       const agentMsgs = agentLines.map((l) => JSON.parse(l));
       const agentUserAssistant = agentMsgs.filter(
@@ -1535,40 +1609,17 @@ var loadSessionTreeDataInternal = (projectName, sessionId, summariesByTargetSess
   };
 });
 var loadSessionTreeData = (projectName, sessionId) => loadSessionTreeDataInternal(projectName, sessionId, void 0);
-var DEFAULT_SORT = { field: "summary", order: "desc" };
-var loadProjectTreeData = (projectName, sortOptions) => Effect6.gen(function* () {
-  const project = (yield* listProjects).find((p) => p.name === projectName);
-  if (!project) {
-    return null;
-  }
-  const sort = sortOptions ?? DEFAULT_SORT;
-  const projectPath = path6.join(getSessionsDir(), projectName);
-  const files = yield* Effect6.tryPromise(() => fs7.readdir(projectPath));
-  const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
-  const fileMtimes = /* @__PURE__ */ new Map();
-  yield* Effect6.all(
-    sessionFiles.map(
-      (file) => Effect6.gen(function* () {
-        const filePath = path6.join(projectPath, file);
-        try {
-          const stat4 = yield* Effect6.tryPromise(() => fs7.stat(filePath));
-          fileMtimes.set(file.replace(".jsonl", ""), stat4.mtimeMs);
-        } catch {
-        }
-      })
-    ),
-    { concurrency: 20 }
-  );
+var DEFAULT_SORT = { field: "updated", order: "desc" };
+var buildPhase1 = (projectPath, allJsonlFiles) => Effect6.gen(function* () {
   const globalUuidMap = /* @__PURE__ */ new Map();
   const allSummaries = [];
-  const allJsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
   yield* Effect6.all(
     allJsonlFiles.map(
       (file) => Effect6.gen(function* () {
-        const filePath = path6.join(projectPath, file);
+        const filePath = path7.join(projectPath, file);
         const fileSessionId = file.replace(".jsonl", "");
         try {
-          const content = yield* Effect6.tryPromise(() => fs7.readFile(filePath, "utf-8"));
+          const content = yield* Effect6.tryPromise(() => fs8.readFile(filePath, "utf-8"));
           const lines = content.trim().split("\n").filter(Boolean);
           for (let i = 0; i < lines.length; i++) {
             const msg = tryParseJsonLine(lines[i], i + 1, filePath);
@@ -1600,6 +1651,9 @@ var loadProjectTreeData = (projectName, sortOptions) => Effect6.gen(function* ()
     ),
     { concurrency: 20 }
   );
+  return { globalUuidMap, allSummaries };
+});
+var buildSummariesByTargetSession = (globalUuidMap, allSummaries) => {
   const summariesByTargetSession = /* @__PURE__ */ new Map();
   for (const summaryData of allSummaries) {
     if (summaryData.leafUuid) {
@@ -1612,21 +1666,22 @@ var loadProjectTreeData = (projectName, sortOptions) => Effect6.gen(function* ()
         summariesByTargetSession.get(targetSessionId).push({
           summary: summaryData.summary,
           leafUuid: summaryData.leafUuid,
-          // Use summary's own timestamp for sorting, not the target message's timestamp
           timestamp: summaryData.timestamp ?? targetInfo.timestamp,
           sourceFile: summaryData.sourceFile
         });
       }
     }
   }
-  const sessions = yield* Effect6.all(
-    sessionFiles.map((file) => {
-      const sessionId = file.replace(".jsonl", "");
-      const mtime = fileMtimes.get(sessionId);
-      return loadSessionTreeDataInternal(projectName, sessionId, summariesByTargetSession, mtime);
-    }),
-    { concurrency: 10 }
-  );
+  return summariesByTargetSession;
+};
+var sortSummaries = (summaries) => {
+  return [...summaries].sort((a, b) => {
+    const timestampCmp = (a.timestamp ?? "").localeCompare(b.timestamp ?? "");
+    if (timestampCmp !== 0) return timestampCmp;
+    return (b.sourceFile ?? "").localeCompare(a.sourceFile ?? "");
+  });
+};
+var buildProjectTreeResult = (project, sessions, sort) => {
   const sortedSessions = sortSessions(sessions, sort);
   const filteredSessions = sortedSessions.filter((s) => {
     if (isErrorSessionTitle(s.title)) return false;
@@ -1641,12 +1696,165 @@ var loadProjectTreeData = (projectName, sortOptions) => Effect6.gen(function* ()
     sessionCount: filteredSessions.length,
     sessions: filteredSessions
   };
+};
+var buildTreeCache = (globalUuidMap, allSummaries, sessions, fileMtimes) => {
+  const uuidMapRecord = {};
+  for (const [key, val] of globalUuidMap) {
+    uuidMapRecord[key] = val;
+  }
+  const sessionsRecord = {};
+  for (const s of sessions) {
+    sessionsRecord[s.id] = {
+      fileMtime: fileMtimes.get(s.id) ?? 0,
+      data: s
+    };
+  }
+  return {
+    version: 1,
+    globalUuidMap: uuidMapRecord,
+    allSummaries,
+    sessions: sessionsRecord
+  };
+};
+var updateSessionSummaries = (cached, summariesByTargetSession) => {
+  const newSummaries = sortSummaries(summariesByTargetSession.get(cached.id) ?? []);
+  const oldJson = JSON.stringify(cached.summaries);
+  const newJson = JSON.stringify(newSummaries);
+  if (oldJson === newJson) return cached;
+  const newSortTimestamp = getSessionSortTimestamp({
+    summaries: newSummaries,
+    createdAt: cached.createdAt
+  });
+  return {
+    ...cached,
+    summaries: newSummaries,
+    currentSummary: newSummaries[0]?.summary,
+    sortTimestamp: newSortTimestamp
+  };
+};
+var loadProjectTreeData = (projectName, sortOptions) => Effect6.gen(function* () {
+  const projectPath = path7.join(getSessionsDir(), projectName);
+  const exists = yield* Effect6.tryPromise(
+    () => fs8.access(projectPath).then(() => true).catch(() => false)
+  );
+  if (!exists) return null;
+  const displayName = yield* Effect6.tryPromise(() => folderNameToPath(projectName));
+  const project = { name: projectName, displayName, path: projectPath };
+  const sort = sortOptions ?? DEFAULT_SORT;
+  const files = yield* Effect6.tryPromise(() => fs8.readdir(projectPath));
+  const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+  const sessionFileIds = sessionFiles.map((f) => f.replace(".jsonl", ""));
+  const fileMtimes = /* @__PURE__ */ new Map();
+  yield* Effect6.all(
+    sessionFiles.map(
+      (file) => Effect6.gen(function* () {
+        const filePath = path7.join(projectPath, file);
+        try {
+          const stat4 = yield* Effect6.tryPromise(() => fs8.stat(filePath));
+          fileMtimes.set(file.replace(".jsonl", ""), stat4.mtimeMs);
+        } catch {
+        }
+      })
+    ),
+    { concurrency: 20 }
+  );
+  const cache = yield* Effect6.tryPromise(() => loadTreeCache(projectName));
+  if (cache) {
+    const validation = validateCache(cache, sessionFileIds, fileMtimes);
+    if (validation.isFullHit) {
+      log3.debug(`cache hit for ${projectName} (${sessionFileIds.length} sessions)`);
+      const sessions = sessionFileIds.map((id) => cache.sessions[id]?.data).filter((s) => s != null);
+      return buildProjectTreeResult(project, sessions, sort);
+    }
+    const changedCount = validation.changedSessionIds.length + validation.newSessionIds.length + validation.deletedSessionIds.length;
+    log3.debug(
+      `cache partial miss for ${projectName}: ${validation.changedSessionIds.length} changed, ${validation.newSessionIds.length} new, ${validation.deletedSessionIds.length} deleted, ${validation.unchangedSessionIds.length} unchanged`
+    );
+    if (changedCount <= sessionFileIds.length / 2) {
+      const result = yield* loadProjectTreeDataIncremental(
+        projectName,
+        projectPath,
+        files,
+        sessionFiles,
+        fileMtimes,
+        cache,
+        validation,
+        project,
+        sort
+      );
+      return result;
+    }
+  }
+  log3.debug(`full load for ${projectName} (${sessionFileIds.length} sessions)`);
+  return yield* loadProjectTreeDataFull(
+    projectName,
+    projectPath,
+    files,
+    sessionFiles,
+    fileMtimes,
+    project,
+    sort
+  );
+});
+var loadProjectTreeDataFull = (projectName, projectPath, files, sessionFiles, fileMtimes, project, sort) => Effect6.gen(function* () {
+  const allJsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+  const { globalUuidMap, allSummaries } = yield* buildPhase1(projectPath, allJsonlFiles);
+  const summariesByTargetSession = buildSummariesByTargetSession(globalUuidMap, allSummaries);
+  const sessions = yield* Effect6.all(
+    sessionFiles.map((file) => {
+      const sessionId = file.replace(".jsonl", "");
+      const mtime = fileMtimes.get(sessionId);
+      return loadSessionTreeDataInternal(projectName, sessionId, summariesByTargetSession, mtime);
+    }),
+    { concurrency: 10 }
+  );
+  const cacheData = buildTreeCache(globalUuidMap, allSummaries, sessions, fileMtimes);
+  writeTreeCache(projectName, cacheData).catch((err) => {
+    log3.debug(`cache write failed for ${projectName}: ${err}`);
+  });
+  return buildProjectTreeResult(project, sessions, sort);
+});
+var loadProjectTreeDataIncremental = (projectName, projectPath, files, sessionFiles, fileMtimes, cache, validation, project, sort) => Effect6.gen(function* () {
+  const allJsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+  const { globalUuidMap, allSummaries } = yield* buildPhase1(projectPath, allJsonlFiles);
+  const summariesByTargetSession = buildSummariesByTargetSession(globalUuidMap, allSummaries);
+  const sessionsToLoad = [...validation.changedSessionIds, ...validation.newSessionIds];
+  const loadedSessions = yield* Effect6.all(
+    sessionsToLoad.map((sessionId) => {
+      const mtime = fileMtimes.get(sessionId);
+      return loadSessionTreeDataInternal(projectName, sessionId, summariesByTargetSession, mtime);
+    }),
+    { concurrency: 10 }
+  );
+  const loadedMap = /* @__PURE__ */ new Map();
+  for (const s of loadedSessions) {
+    loadedMap.set(s.id, s);
+  }
+  const allSessions = [];
+  for (const file of sessionFiles) {
+    const sessionId = file.replace(".jsonl", "");
+    const loaded = loadedMap.get(sessionId);
+    if (loaded) {
+      allSessions.push(loaded);
+    } else if (cache.sessions[sessionId]) {
+      const updated = updateSessionSummaries(
+        cache.sessions[sessionId].data,
+        summariesByTargetSession
+      );
+      allSessions.push({ ...updated, fileMtime: fileMtimes.get(sessionId) });
+    }
+  }
+  const cacheData = buildTreeCache(globalUuidMap, allSummaries, allSessions, fileMtimes);
+  writeTreeCache(projectName, cacheData).catch((err) => {
+    log3.debug(`cache write failed for ${projectName}: ${err}`);
+  });
+  return buildProjectTreeResult(project, allSessions, sort);
 });
 
 // src/session/analysis.ts
 import { Effect as Effect7 } from "effect";
-import * as fs8 from "fs/promises";
-import * as path7 from "path";
+import * as fs9 from "fs/promises";
+import * as path8 from "path";
 var isToolUse = (item) => item !== null && typeof item === "object" && "type" in item && item.type === "tool_use";
 var isToolResultError = (item) => item !== null && typeof item === "object" && "type" in item && item.type === "tool_result" && "is_error" in item && item.is_error === true;
 var findToolUseById = (messages, toolUseId) => {
@@ -1777,11 +1985,11 @@ var analyzeSession = (projectName, sessionId) => Effect7.gen(function* () {
 });
 var compressSession = (projectName, sessionId, options = {}) => Effect7.gen(function* () {
   const { keepSnapshots = "first_last", maxToolOutputLength = 5e3 } = options;
-  const filePath = path7.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const content = yield* Effect7.tryPromise(() => fs8.readFile(filePath, "utf-8"));
+  const filePath = path8.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
+  const content = yield* Effect7.tryPromise(() => fs9.readFile(filePath, "utf-8"));
   const originalSize = Buffer.byteLength(content, "utf-8");
   const lines = content.trim().split("\n").filter(Boolean);
-  const messages = parseJsonlLines(lines, filePath);
+  const messages = parseJsonlLines(lines, filePath, { strict: true });
   let removedCustomTitles = 0;
   let removedProgress = 0;
   let removedSnapshots = 0;
@@ -1843,7 +2051,7 @@ var compressSession = (projectName, sessionId, options = {}) => Effect7.gen(func
   }
   const newContent = filteredMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
   const compressedSize = Buffer.byteLength(newContent, "utf-8");
-  yield* Effect7.tryPromise(() => fs8.writeFile(filePath, newContent, "utf-8"));
+  yield* Effect7.tryPromise(() => fs9.writeFile(filePath, newContent, "utf-8"));
   return {
     success: true,
     originalSize,
@@ -1856,10 +2064,10 @@ var compressSession = (projectName, sessionId, options = {}) => Effect7.gen(func
 });
 var extractProjectKnowledge = (projectName, sessionIds) => Effect7.gen(function* () {
   const sessionsDir = getSessionsDir();
-  const projectDir = path7.join(sessionsDir, projectName);
+  const projectDir = path8.join(sessionsDir, projectName);
   let targetSessionIds = sessionIds;
   if (!targetSessionIds) {
-    const files = yield* Effect7.tryPromise(() => fs8.readdir(projectDir));
+    const files = yield* Effect7.tryPromise(() => fs9.readdir(projectDir));
     targetSessionIds = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-")).map((f) => f.replace(".jsonl", ""));
   }
   const fileModifyCount = /* @__PURE__ */ new Map();
@@ -1986,11 +2194,11 @@ var summarizeSession = (projectName, sessionId, options = {}) => Effect7.gen(fun
 
 // src/session/cleanup.ts
 import { Effect as Effect8 } from "effect";
-import * as fs9 from "fs/promises";
-import * as path8 from "path";
+import * as fs10 from "fs/promises";
+import * as path9 from "path";
 var cleanInvalidMessages = (projectName, sessionId) => Effect8.gen(function* () {
-  const filePath = path8.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const content = yield* Effect8.tryPromise(() => fs9.readFile(filePath, "utf-8"));
+  const filePath = path9.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
+  const content = yield* Effect8.tryPromise(() => fs10.readFile(filePath, "utf-8"));
   const lines = content.trim().split("\n").filter(Boolean);
   if (lines.length === 0) return { removedCount: 0, remainingCount: 0 };
   const messages = parseJsonlLines(lines, filePath);
@@ -2022,7 +2230,7 @@ var cleanInvalidMessages = (projectName, sessionId) => Effect8.gen(function* ()
     lastValidUuid = msg.uuid;
   }
   const newContent = filtered.length > 0 ? filtered.map((m) => JSON.stringify(m)).join("\n") + "\n" : "";
-  yield* Effect8.tryPromise(() => fs9.writeFile(filePath, newContent, "utf-8"));
+  yield* Effect8.tryPromise(() => fs10.writeFile(filePath, newContent, "utf-8"));
   const remainingUserAssistant = filtered.filter(
     (m) => m.type === "user" || m.type === "assistant"
   ).length;
@@ -2088,8 +2296,8 @@ var clearSessions = (options) => Effect8.gen(function* () {
   const sessionsToDelete = [];
   if (clearInvalid) {
     for (const project of targetProjects) {
-      const projectPath = path8.join(getSessionsDir(), project.name);
-      const files = yield* Effect8.tryPromise(() => fs9.readdir(projectPath));
+      const projectPath = path9.join(getSessionsDir(), project.name);
+      const files = yield* Effect8.tryPromise(() => fs10.readdir(projectPath));
       const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
       for (const file of sessionFiles) {
         const sessionId = file.replace(".jsonl", "");
@@ -2146,8 +2354,8 @@ var clearSessions = (options) => Effect8.gen(function* () {
 
 // src/session/search.ts
 import { Effect as Effect9, pipe as pipe2 } from "effect";
-import * as fs10 from "fs/promises";
-import * as path9 from "path";
+import * as fs11 from "fs/promises";
+import * as path10 from "path";
 var extractSnippet = (text, matchIndex, queryLength) => {
   const start = Math.max(0, matchIndex - 50);
   const end = Math.min(text.length, matchIndex + queryLength + 50);
@@ -2171,7 +2379,7 @@ var findContentMatch = (lines, queryLower, filePath) => {
   return null;
 };
 var searchSessionContent = (projectName, sessionId, filePath, queryLower) => pipe2(
-  Effect9.tryPromise(() => fs10.readFile(filePath, "utf-8")),
+  Effect9.tryPromise(() => fs11.readFile(filePath, "utf-8")),
   Effect9.map((content) => {
     const lines = content.trim().split("\n").filter(Boolean);
     const match = findContentMatch(lines, queryLower, filePath);
@@ -2189,12 +2397,12 @@ var searchSessionContent = (projectName, sessionId, filePath, queryLower) => pip
   Effect9.catchAll(() => Effect9.succeed(null))
 );
 var searchProjectContent = (project, queryLower, alreadyFoundIds) => Effect9.gen(function* () {
-  const projectPath = path9.join(getSessionsDir(), project.name);
-  const files = yield* Effect9.tryPromise(() => fs10.readdir(projectPath));
+  const projectPath = path10.join(getSessionsDir(), project.name);
+  const files = yield* Effect9.tryPromise(() => fs11.readdir(projectPath));
   const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
   const searchEffects = sessionFiles.map((file) => ({
     sessionId: file.replace(".jsonl", ""),
-    filePath: path9.join(projectPath, file)
+    filePath: path10.join(projectPath, file)
   })).filter(({ sessionId }) => !alreadyFoundIds.has(`${project.name}:${sessionId}`)).map(
     ({ sessionId, filePath }) => searchSessionContent(project.name, sessionId, filePath, queryLower)
   );
@@ -2298,12 +2506,12 @@ var getSessionFiles = (projectName, sessionId) => Effect10.gen(function* () {
 
 // src/session/index-file.ts
 import { Effect as Effect11 } from "effect";
-import * as fs11 from "fs/promises";
-import * as path10 from "path";
+import * as fs12 from "fs/promises";
+import * as path11 from "path";
 var loadSessionsIndex = (projectName) => Effect11.gen(function* () {
-  const indexPath = path10.join(getSessionsDir(), projectName, "sessions-index.json");
+  const indexPath = path11.join(getSessionsDir(), projectName, "sessions-index.json");
   try {
-    const content = yield* Effect11.tryPromise(() => fs11.readFile(indexPath, "utf-8"));
+    const content = yield* Effect11.tryPromise(() => fs12.readFile(indexPath, "utf-8"));
     const index = JSON.parse(content);
     return index;
   } catch {
@@ -2331,9 +2539,9 @@ var sortIndexEntriesByModified = (entries) => {
   });
 };
 var hasSessionsIndex = (projectName) => Effect11.gen(function* () {
-  const indexPath = path10.join(getSessionsDir(), projectName, "sessions-index.json");
+  const indexPath = path11.join(getSessionsDir(), projectName, "sessions-index.json");
   try {
-    yield* Effect11.tryPromise(() => fs11.access(indexPath));
+    yield* Effect11.tryPromise(() => fs12.access(indexPath));
     return true;
   } catch {
     return false;
@@ -2366,6 +2574,7 @@ export {
   folderNameToPath,
   formatRelativeTime,
   generateTreeNodeId,
+  getCachePath,
   getDisplayTitle,
   getIndexEntryDisplayTitle,
   getLogger,