@claude-sessions/core 0.4.1 → 0.4.2-beta.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/paths.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as os from "os";
 import * as path from "path";
 
@@ -22,19 +22,153 @@ var createLogger = (namespace) => ({
   error: (msg, ...args) => currentLogger.error(`[${namespace}] ${msg}`, ...args)
 });
 
+// src/utils.ts
+import { Effect } from "effect";
+import * as fs from "fs/promises";
+var logger = createLogger("utils");
+var extractTextContent = (message) => {
+  if (!message) return "";
+  const content = message.content;
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((item) => typeof item === "object" && item?.type === "text").map((item) => {
+      if (item.text == null) {
+        logger.warn("TextContent item has undefined or null text property");
+        return "";
+      }
+      return item.text;
+    }).join("");
+  }
+  return "";
+};
+var parseCommandMessage = (content) => {
+  const name = content?.match(/<command-name>([^<]+)<\/command-name>/)?.[1] ?? "";
+  const message = content?.match(/<command-message>([^<]+)<\/command-message>/)?.[1] ?? "";
+  return { name, message };
+};
+var extractTitle = (text) => {
+  if (!text) return "Untitled";
+  const { name } = parseCommandMessage(text);
+  if (name) return name;
+  let cleaned = text.replace(/<ide_[^>]*>[\s\S]*?<\/ide_[^>]*>/g, "").trim();
+  if (!cleaned) return "Untitled";
+  if (cleaned.includes("\n\n")) {
+    cleaned = cleaned.split("\n\n")[0];
+  }
+  if (cleaned.length > 100) {
+    return cleaned.slice(0, 100) + "...";
+  }
+  return cleaned || "Untitled";
+};
+var isInvalidApiKeyMessage = (msg) => {
+  const text = extractTextContent(msg.message);
+  return text.includes("Invalid API key");
+};
+var ERROR_SESSION_PATTERNS = [
+  "API Error",
+  "authentication_error",
+  "Invalid API key",
+  "OAuth token has expired",
+  "Please run /login"
+];
+var isErrorSessionTitle = (title) => {
+  if (!title) return false;
+  return ERROR_SESSION_PATTERNS.some((pattern) => title.includes(pattern));
+};
+var isContinuationSummary = (msg) => {
+  if (msg.isCompactSummary === true) return true;
+  if (msg.type !== "user") return false;
+  const text = extractTextContent(msg.message);
+  return text.startsWith("This session is being continued from");
+};
+var getDisplayTitle = (customTitle, currentSummary, title, maxLength = 60, fallback = "Untitled") => {
+  if (customTitle) return customTitle;
+  if (currentSummary) {
+    return currentSummary.length > maxLength ? currentSummary.slice(0, maxLength - 3) + "..." : currentSummary;
+  }
+  if (title && title !== "Untitled") {
+    if (title.includes("<command-name>")) {
+      const { name } = parseCommandMessage(title);
+      if (name) return name;
+    }
+    return title;
+  }
+  return fallback;
+};
+var replaceMessageContent = (msg, text) => ({
+  ...msg,
+  message: {
+    ...msg.message,
+    content: [{ type: "text", text }]
+  },
+  toolUseResult: void 0
+});
+var cleanupSplitFirstMessage = (msg) => {
+  const toolUseResult = msg.toolUseResult;
+  if (!toolUseResult) return msg;
+  if (typeof toolUseResult === "object" && "answers" in toolUseResult) {
+    const answers = toolUseResult.answers;
+    const qaText = Object.entries(answers).map(([q, a]) => `Q: ${q}
+A: ${a}`).join("\n\n");
+    return replaceMessageContent(msg, qaText);
+  }
+  if (typeof toolUseResult === "string") {
+    const rejectionMarker = "The user provided the following reason for the rejection:";
+    const rejectionIndex = toolUseResult.indexOf(rejectionMarker);
+    if (rejectionIndex === -1) return msg;
+    const text = toolUseResult.slice(rejectionIndex + rejectionMarker.length).trim();
+    if (!text) return msg;
+    return replaceMessageContent(msg, text);
+  }
+  return msg;
+};
+var maskHomePath = (text, homeDir) => {
+  if (!homeDir) return text;
+  const escapedHome = homeDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`${escapedHome}(?=[/\\\\]|$)`, "g");
+  return text.replace(regex, "~");
+};
+var getSessionSortTimestamp = (session) => {
+  const timestampStr = session.summaries?.[0]?.timestamp ?? session.createdAt;
+  return timestampStr ? new Date(timestampStr).getTime() : 0;
+};
+var tryParseJsonLine = (line, lineNumber, filePath) => {
+  try {
+    return JSON.parse(line);
+  } catch {
+    if (filePath) {
+      console.warn(`Skipping invalid JSON at line ${lineNumber} in ${filePath}`);
+    }
+    return null;
+  }
+};
+var parseJsonlLines = (lines, filePath) => {
+  return lines.map((line, idx) => {
+    try {
+      return JSON.parse(line);
+    } catch (e) {
+      const err = e;
+      throw new Error(`Failed to parse line ${idx + 1} in ${filePath}: ${err.message}`);
+    }
+  });
+};
+var readJsonlFile = (filePath) => 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);
+});
+
 // src/paths.ts
 var log = createLogger("paths");
 var getSessionsDir = () => process.env.CLAUDE_SESSIONS_DIR || path.join(os.homedir(), ".claude", "projects");
 var getTodosDir = () => path.join(os.homedir(), ".claude", "todos");
-var extractCwdFromContent = (content) => {
+var extractCwdFromContent = (content, filePath) => {
   const lines = content.split("\n").filter((l) => l.trim());
-  for (const line of lines) {
-    try {
-      const parsed = JSON.parse(line);
-      if (parsed?.cwd) {
-        return parsed.cwd;
-      }
-    } catch {
+  for (let i = 0; i < lines.length; i++) {
+    const parsed = tryParseJsonLine(lines[i], i + 1, filePath);
+    if (parsed?.cwd) {
+      return parsed.cwd;
     }
   }
   return null;
@@ -79,7 +213,7 @@ var pathToFolderName = (absolutePath) => {
   }
   return convertNonAscii(absolutePath).replace(/^\//g, "-").replace(/\/\./g, "--").replace(/\//g, "-").replace(/\./g, "-");
 };
-var tryGetCwdFromFile = (filePath, fileSystem = fs, logger2 = log) => {
+var tryGetCwdFromFile = (filePath, fileSystem = fs2, logger2 = log) => {
   const basename3 = path.basename(filePath);
   try {
     const content = fileSystem.readFileSync(filePath, "utf-8");
@@ -99,7 +233,7 @@ var tryGetCwdFromFile = (filePath, fileSystem = fs, logger2 = log) => {
     return null;
   }
 };
-var getRealPathFromSession = (folderName, sessionsDir = getSessionsDir(), fileSystem = fs, logger2 = log) => {
+var getRealPathFromSession = (folderName, sessionsDir = getSessionsDir(), fileSystem = fs2, logger2 = log) => {
   const projectDir = path.join(sessionsDir, folderName);
   try {
     const files = fileSystem.readdirSync(projectDir).filter(isSessionFile);
@@ -135,7 +269,7 @@ var folderNameToPath = (folderName) => {
   const absolutePath = folderNameToDisplayPath(folderName);
   return toRelativePath(absolutePath, homeDir);
 };
-var findProjectByWorkspacePath = (workspacePath, projectNames, sessionsDir = getSessionsDir(), fileSystem = fs, logger2 = log) => {
+var findProjectByWorkspacePath = (workspacePath, projectNames, sessionsDir = getSessionsDir(), fileSystem = fs2, logger2 = log) => {
   const directMatch = pathToFolderName(workspacePath);
   if (projectNames.includes(directMatch)) {
     return directMatch;
@@ -160,111 +294,7 @@ var findProjectByWorkspacePath = (workspacePath, projectNames, sessionsDir = get
   return null;
 };
 
-// src/utils.ts
-var logger = createLogger("utils");
-var extractTextContent = (message) => {
-  if (!message) return "";
-  const content = message.content;
-  if (!content) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter((item) => typeof item === "object" && item?.type === "text").map((item) => {
-      if (item.text == null) {
-        logger.warn("TextContent item has undefined or null text property");
-        return "";
-      }
-      return item.text;
-    }).join("");
-  }
-  return "";
-};
-var parseCommandMessage = (content) => {
-  const name = content?.match(/<command-name>([^<]+)<\/command-name>/)?.[1] ?? "";
-  const message = content?.match(/<command-message>([^<]+)<\/command-message>/)?.[1] ?? "";
-  return { name, message };
-};
-var extractTitle = (text) => {
-  if (!text) return "Untitled";
-  const { name } = parseCommandMessage(text);
-  if (name) return name;
-  let cleaned = text.replace(/<ide_[^>]*>[\s\S]*?<\/ide_[^>]*>/g, "").trim();
-  if (!cleaned) return "Untitled";
-  if (cleaned.includes("\n\n")) {
-    cleaned = cleaned.split("\n\n")[0];
-  }
-  if (cleaned.length > 100) {
-    return cleaned.slice(0, 100) + "...";
-  }
-  return cleaned || "Untitled";
-};
-var isInvalidApiKeyMessage = (msg) => {
-  const text = extractTextContent(msg.message);
-  return text.includes("Invalid API key");
-};
-var ERROR_SESSION_PATTERNS = [
-  "API Error",
-  "authentication_error",
-  "Invalid API key",
-  "OAuth token has expired",
-  "Please run /login"
-];
-var isErrorSessionTitle = (title) => {
-  if (!title) return false;
-  return ERROR_SESSION_PATTERNS.some((pattern) => title.includes(pattern));
-};
-var isContinuationSummary = (msg) => {
-  if (msg.isCompactSummary === true) return true;
-  if (msg.type !== "user") return false;
-  const text = extractTextContent(msg.message);
-  return text.startsWith("This session is being continued from");
-};
-var getDisplayTitle = (customTitle, currentSummary, title, maxLength = 60, fallback = "Untitled") => {
-  if (customTitle) return customTitle;
-  if (currentSummary) {
-    return currentSummary.length > maxLength ? currentSummary.slice(0, maxLength - 3) + "..." : currentSummary;
-  }
-  if (title && title !== "Untitled") {
-    if (title.includes("<command-name>")) {
-      const { name } = parseCommandMessage(title);
-      if (name) return name;
-    }
-    return title;
-  }
-  return fallback;
-};
-var replaceMessageContent = (msg, text) => ({
-  ...msg,
-  message: {
-    ...msg.message,
-    content: [{ type: "text", text }]
-  },
-  toolUseResult: void 0
-});
-var cleanupSplitFirstMessage = (msg) => {
-  const toolUseResult = msg.toolUseResult;
-  if (!toolUseResult) return msg;
-  if (typeof toolUseResult === "object" && "answers" in toolUseResult) {
-    const answers = toolUseResult.answers;
-    const qaText = Object.entries(answers).map(([q, a]) => `Q: ${q}
-A: ${a}`).join("\n\n");
-    return replaceMessageContent(msg, qaText);
-  }
-  if (typeof toolUseResult === "string") {
-    const rejectionMarker = "The user provided the following reason for the rejection:";
-    const rejectionIndex = toolUseResult.indexOf(rejectionMarker);
-    if (rejectionIndex === -1) return msg;
-    const text = toolUseResult.slice(rejectionIndex + rejectionMarker.length).trim();
-    if (!text) return msg;
-    return replaceMessageContent(msg, text);
-  }
-  return msg;
-};
-var maskHomePath = (text, homeDir) => {
-  if (!homeDir) return text;
-  const escapedHome = homeDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const regex = new RegExp(`${escapedHome}(?=[/\\\\]|$)`, "g");
-  return text.replace(regex, "~");
-};
+// src/projects.ts
 var sortProjects = (projects, options = {}) => {
   const { currentProjectName, homeDir, filterEmpty = true } = options;
   const filtered = filterEmpty ? projects.filter((p) => p.sessionCount > 0) : projects;
@@ -283,23 +313,19 @@ var sortProjects = (projects, options = {}) => {
     return a.displayName.localeCompare(b.displayName);
   });
 };
-var getSessionSortTimestamp = (session) => {
-  const timestampStr = session.summaries?.[0]?.timestamp ?? session.createdAt;
-  return timestampStr ? new Date(timestampStr).getTime() : 0;
-};
 
 // src/agents.ts
-import { Effect } from "effect";
-import * as fs2 from "fs/promises";
+import { Effect as Effect2 } from "effect";
+import * as fs3 from "fs/promises";
 import * as path2 from "path";
-var findLinkedAgents = (projectName, sessionId) => Effect.gen(function* () {
+var findLinkedAgents = (projectName, sessionId) => Effect2.gen(function* () {
   const projectPath = path2.join(getSessionsDir(), projectName);
-  const files = yield* Effect.tryPromise(() => fs2.readdir(projectPath));
+  const files = yield* Effect2.tryPromise(() => fs3.readdir(projectPath));
   const agentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
   const linkedAgents = [];
   for (const agentFile of agentFiles) {
     const filePath = path2.join(projectPath, agentFile);
-    const content = yield* Effect.tryPromise(() => fs2.readFile(filePath, "utf-8"));
+    const content = yield* Effect2.tryPromise(() => fs3.readFile(filePath, "utf-8"));
     const firstLine = content.split("\n")[0];
     if (firstLine) {
       try {
@@ -313,16 +339,16 @@ var findLinkedAgents = (projectName, sessionId) => Effect.gen(function* () {
   }
   return linkedAgents;
 });
-var findOrphanAgentsWithPaths = (projectName) => Effect.gen(function* () {
+var findOrphanAgentsWithPaths = (projectName) => Effect2.gen(function* () {
   const projectPath = path2.join(getSessionsDir(), projectName);
-  const files = yield* Effect.tryPromise(() => fs2.readdir(projectPath));
+  const files = yield* Effect2.tryPromise(() => fs3.readdir(projectPath));
   const sessionIds = new Set(
     files.filter((f) => !f.startsWith("agent-") && f.endsWith(".jsonl")).map((f) => f.replace(".jsonl", ""))
   );
   const orphanAgents = [];
   const checkAgentFile = async (filePath) => {
     try {
-      const content = await fs2.readFile(filePath, "utf-8");
+      const content = await fs3.readFile(filePath, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim());
       const firstLine = lines[0];
       if (!firstLine) return null;
@@ -342,27 +368,27 @@ var findOrphanAgentsWithPaths = (projectName) => Effect.gen(function* () {
   const rootAgentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
   for (const agentFile of rootAgentFiles) {
     const filePath = path2.join(projectPath, agentFile);
-    const orphan = yield* Effect.tryPromise(() => checkAgentFile(filePath));
+    const orphan = yield* Effect2.tryPromise(() => checkAgentFile(filePath));
     if (orphan) {
       orphanAgents.push({ ...orphan, filePath });
     }
   }
   for (const entry of files) {
     const entryPath = path2.join(projectPath, entry);
-    const stat4 = yield* Effect.tryPromise(() => fs2.stat(entryPath).catch(() => null));
+    const stat4 = yield* Effect2.tryPromise(() => fs3.stat(entryPath).catch(() => null));
     if (stat4?.isDirectory() && !entry.startsWith(".")) {
       const subagentsPath = path2.join(entryPath, "subagents");
-      const subagentsExists = yield* Effect.tryPromise(
-        () => fs2.stat(subagentsPath).then(() => true).catch(() => false)
+      const subagentsExists = yield* Effect2.tryPromise(
+        () => fs3.stat(subagentsPath).then(() => true).catch(() => false)
       );
       if (subagentsExists) {
-        const subagentFiles = yield* Effect.tryPromise(
-          () => fs2.readdir(subagentsPath).catch(() => [])
+        const subagentFiles = yield* Effect2.tryPromise(
+          () => fs3.readdir(subagentsPath).catch(() => [])
         );
         for (const subagentFile of subagentFiles) {
           if (subagentFile.startsWith("agent-") && subagentFile.endsWith(".jsonl")) {
             const filePath = path2.join(subagentsPath, subagentFile);
-            const orphan = yield* Effect.tryPromise(() => checkAgentFile(filePath));
+            const orphan = yield* Effect2.tryPromise(() => checkAgentFile(filePath));
             if (orphan) {
               orphanAgents.push({ ...orphan, filePath });
             }
@@ -373,11 +399,11 @@ var findOrphanAgentsWithPaths = (projectName) => Effect.gen(function* () {
   }
   return orphanAgents;
 });
-var findOrphanAgents = (projectName) => Effect.gen(function* () {
+var findOrphanAgents = (projectName) => Effect2.gen(function* () {
   const orphans = yield* findOrphanAgentsWithPaths(projectName);
   return orphans.map(({ agentId, sessionId }) => ({ agentId, sessionId }));
 });
-var deleteOrphanAgents = (projectName) => Effect.gen(function* () {
+var deleteOrphanAgents = (projectName) => Effect2.gen(function* () {
   const projectPath = path2.join(getSessionsDir(), projectName);
   const orphans = yield* findOrphanAgentsWithPaths(projectName);
   const deletedAgents = [];
@@ -391,35 +417,35 @@ var deleteOrphanAgents = (projectName) => Effect.gen(function* () {
       foldersToCheck.add(parentDir);
     }
     if (orphan.lineCount <= 2) {
-      yield* Effect.tryPromise(() => fs2.unlink(orphan.filePath));
+      yield* Effect2.tryPromise(() => fs3.unlink(orphan.filePath));
       deletedAgents.push(orphan.agentId);
     } else {
       if (!backupDirCreated) {
         const backupDir2 = path2.join(projectPath, ".bak");
-        yield* Effect.tryPromise(() => fs2.mkdir(backupDir2, { recursive: true }));
+        yield* Effect2.tryPromise(() => fs3.mkdir(backupDir2, { recursive: true }));
         backupDirCreated = true;
       }
       const backupDir = path2.join(projectPath, ".bak");
       const agentBackupPath = path2.join(backupDir, `${orphan.agentId}.jsonl`);
-      yield* Effect.tryPromise(() => fs2.rename(orphan.filePath, agentBackupPath));
+      yield* Effect2.tryPromise(() => fs3.rename(orphan.filePath, agentBackupPath));
       backedUpAgents.push(orphan.agentId);
     }
   }
   for (const subagentsDir of foldersToCheck) {
-    const isEmpty = yield* Effect.tryPromise(async () => {
-      const files = await fs2.readdir(subagentsDir);
+    const isEmpty = yield* Effect2.tryPromise(async () => {
+      const files = await fs3.readdir(subagentsDir);
       return files.length === 0;
     });
     if (isEmpty) {
-      yield* Effect.tryPromise(() => fs2.rmdir(subagentsDir));
+      yield* Effect2.tryPromise(() => fs3.rmdir(subagentsDir));
       cleanedFolders.push(subagentsDir);
       const sessionDir = path2.dirname(subagentsDir);
-      const sessionDirEmpty = yield* Effect.tryPromise(async () => {
-        const files = await fs2.readdir(sessionDir);
+      const sessionDirEmpty = yield* Effect2.tryPromise(async () => {
+        const files = await fs3.readdir(sessionDir);
         return files.length === 0;
       });
       if (sessionDirEmpty) {
-        yield* Effect.tryPromise(() => fs2.rmdir(sessionDir));
+        yield* Effect2.tryPromise(() => fs3.rmdir(sessionDir));
         cleanedFolders.push(sessionDir);
       }
     }
@@ -435,50 +461,53 @@ var deleteOrphanAgents = (projectName) => Effect.gen(function* () {
     count: deletedAgents.length + backedUpAgents.length
   };
 });
-var loadAgentMessages = (projectName, _sessionId, agentId) => Effect.gen(function* () {
+var loadAgentMessages = (projectName, _sessionId, agentId) => Effect2.gen(function* () {
   const projectPath = path2.join(getSessionsDir(), projectName);
   const agentFilePath = path2.join(projectPath, `${agentId}.jsonl`);
-  const content = yield* Effect.tryPromise(() => fs2.readFile(agentFilePath, "utf-8"));
+  const content = yield* Effect2.tryPromise(() => fs3.readFile(agentFilePath, "utf-8"));
   const lines = content.split("\n").filter((line) => line.trim());
   const messages = [];
-  for (const line of lines) {
-    try {
-      const parsed = JSON.parse(line);
-      if ("sessionId" in parsed && !("type" in parsed)) {
-        continue;
-      }
-      messages.push(parsed);
-    } catch {
+  for (let i = 0; i < lines.length; i++) {
+    const parsed = tryParseJsonLine(lines[i], i + 1, agentFilePath);
+    if (!parsed) continue;
+    if ("sessionId" in parsed && !("type" in parsed)) {
+      continue;
     }
+    messages.push(parsed);
   }
   return messages;
 });
 
 // src/todos.ts
-import { Effect as Effect2 } from "effect";
-import * as fs3 from "fs/promises";
+import { Effect as Effect3 } from "effect";
+import * as fs4 from "fs/promises";
 import * as path3 from "path";
-var findLinkedTodos = (sessionId, agentIds = []) => Effect2.gen(function* () {
+var findLinkedTodos = (sessionId, agentIds = []) => Effect3.gen(function* () {
   const todosDir = getTodosDir();
-  const exists = yield* Effect2.tryPromise(
-    () => fs3.access(todosDir).then(() => true).catch(() => false)
+  const exists = yield* Effect3.tryPromise(
+    () => fs4.access(todosDir).then(() => true).catch(() => false)
   );
   if (!exists) {
-    return void 0;
+    return {
+      sessionId,
+      sessionTodos: [],
+      agentTodos: [],
+      hasTodos: false
+    };
   }
   const sessionTodoPath = path3.join(todosDir, `${sessionId}.json`);
   let sessionTodos = [];
-  const sessionTodoExists = yield* Effect2.tryPromise(
-    () => fs3.access(sessionTodoPath).then(() => true).catch(() => false)
+  const sessionTodoExists = yield* Effect3.tryPromise(
+    () => fs4.access(sessionTodoPath).then(() => true).catch(() => false)
   );
   if (sessionTodoExists) {
-    const content = yield* Effect2.tryPromise(() => fs3.readFile(sessionTodoPath, "utf-8"));
+    const content = yield* Effect3.tryPromise(() => fs4.readFile(sessionTodoPath, "utf-8"));
     try {
       sessionTodos = JSON.parse(content);
     } catch {
     }
   }
-  const allFiles = yield* Effect2.tryPromise(() => fs3.readdir(todosDir));
+  const allFiles = yield* Effect3.tryPromise(() => fs4.readdir(todosDir));
   const agentTodoPattern = new RegExp(`^${sessionId}-agent-([a-f0-9-]+)\\.json$`);
   const discoveredAgentIds = new Set(agentIds);
   for (const file of allFiles) {
@@ -491,11 +520,11 @@ var findLinkedTodos = (sessionId, agentIds = []) => Effect2.gen(function* () {
   for (const agentId of discoveredAgentIds) {
     const shortAgentId = agentId.replace("agent-", "");
     const agentTodoPath = path3.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
-    const agentTodoExists = yield* Effect2.tryPromise(
-      () => fs3.access(agentTodoPath).then(() => true).catch(() => false)
+    const agentTodoExists = yield* Effect3.tryPromise(
+      () => fs4.access(agentTodoPath).then(() => true).catch(() => false)
     );
     if (agentTodoExists) {
-      const content = yield* Effect2.tryPromise(() => fs3.readFile(agentTodoPath, "utf-8"));
+      const content = yield* Effect3.tryPromise(() => fs4.readFile(agentTodoPath, "utf-8"));
       try {
         const todos = JSON.parse(content);
         if (todos.length > 0) {
@@ -513,25 +542,25 @@ var findLinkedTodos = (sessionId, agentIds = []) => Effect2.gen(function* () {
     hasTodos
   };
 });
-var sessionHasTodos = (sessionId, agentIds = []) => Effect2.gen(function* () {
+var sessionHasTodos = (sessionId, agentIds = []) => Effect3.gen(function* () {
   const todosDir = getTodosDir();
-  const exists = yield* Effect2.tryPromise(
-    () => fs3.access(todosDir).then(() => true).catch(() => false)
+  const exists = yield* Effect3.tryPromise(
+    () => fs4.access(todosDir).then(() => true).catch(() => false)
   );
   if (!exists) return false;
   const sessionTodoPath = path3.join(todosDir, `${sessionId}.json`);
-  const sessionTodoExists = yield* Effect2.tryPromise(
-    () => fs3.access(sessionTodoPath).then(() => true).catch(() => false)
+  const sessionTodoExists = yield* Effect3.tryPromise(
+    () => fs4.access(sessionTodoPath).then(() => true).catch(() => false)
   );
   if (sessionTodoExists) {
-    const content = yield* Effect2.tryPromise(() => fs3.readFile(sessionTodoPath, "utf-8"));
+    const content = yield* Effect3.tryPromise(() => fs4.readFile(sessionTodoPath, "utf-8"));
     try {
       const todos = JSON.parse(content);
       if (todos.length > 0) return true;
     } catch {
     }
   }
-  const allFiles = yield* Effect2.tryPromise(() => fs3.readdir(todosDir));
+  const allFiles = yield* Effect3.tryPromise(() => fs4.readdir(todosDir));
   const agentTodoPattern = new RegExp(`^${sessionId}-agent-([a-f0-9-]+)\\.json$`);
   const discoveredAgentIds = new Set(agentIds);
   for (const file of allFiles) {
@@ -543,11 +572,11 @@ var sessionHasTodos = (sessionId, agentIds = []) => Effect2.gen(function* () {
   for (const agentId of discoveredAgentIds) {
     const shortAgentId = agentId.replace("agent-", "");
     const agentTodoPath = path3.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
-    const agentTodoExists = yield* Effect2.tryPromise(
-      () => fs3.access(agentTodoPath).then(() => true).catch(() => false)
+    const agentTodoExists = yield* Effect3.tryPromise(
+      () => fs4.access(agentTodoPath).then(() => true).catch(() => false)
     );
     if (agentTodoExists) {
-      const content = yield* Effect2.tryPromise(() => fs3.readFile(agentTodoPath, "utf-8"));
+      const content = yield* Effect3.tryPromise(() => fs4.readFile(agentTodoPath, "utf-8"));
       try {
         const todos = JSON.parse(content);
         if (todos.length > 0) return true;
@@ -557,60 +586,60 @@ var sessionHasTodos = (sessionId, agentIds = []) => Effect2.gen(function* () {
   }
   return false;
 });
-var deleteLinkedTodos = (sessionId, agentIds) => Effect2.gen(function* () {
+var deleteLinkedTodos = (sessionId, agentIds) => Effect3.gen(function* () {
   const todosDir = getTodosDir();
-  const exists = yield* Effect2.tryPromise(
-    () => fs3.access(todosDir).then(() => true).catch(() => false)
+  const exists = yield* Effect3.tryPromise(
+    () => fs4.access(todosDir).then(() => true).catch(() => false)
   );
   if (!exists) return { deletedCount: 0 };
   const backupDir = path3.join(todosDir, ".bak");
-  yield* Effect2.tryPromise(() => fs3.mkdir(backupDir, { recursive: true }));
+  yield* Effect3.tryPromise(() => fs4.mkdir(backupDir, { recursive: true }));
   let deletedCount = 0;
   const sessionTodoPath = path3.join(todosDir, `${sessionId}.json`);
-  const sessionTodoExists = yield* Effect2.tryPromise(
-    () => fs3.access(sessionTodoPath).then(() => true).catch(() => false)
+  const sessionTodoExists = yield* Effect3.tryPromise(
+    () => fs4.access(sessionTodoPath).then(() => true).catch(() => false)
   );
   if (sessionTodoExists) {
     const backupPath = path3.join(backupDir, `${sessionId}.json`);
-    yield* Effect2.tryPromise(() => fs3.rename(sessionTodoPath, backupPath));
+    yield* Effect3.tryPromise(() => fs4.rename(sessionTodoPath, backupPath));
     deletedCount++;
   }
   for (const agentId of agentIds) {
     const shortAgentId = agentId.replace("agent-", "");
     const agentTodoPath = path3.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
-    const agentTodoExists = yield* Effect2.tryPromise(
-      () => fs3.access(agentTodoPath).then(() => true).catch(() => false)
+    const agentTodoExists = yield* Effect3.tryPromise(
+      () => fs4.access(agentTodoPath).then(() => true).catch(() => false)
     );
     if (agentTodoExists) {
       const backupPath = path3.join(backupDir, `${sessionId}-agent-${shortAgentId}.json`);
-      yield* Effect2.tryPromise(() => fs3.rename(agentTodoPath, backupPath));
+      yield* Effect3.tryPromise(() => fs4.rename(agentTodoPath, backupPath));
       deletedCount++;
     }
   }
   return { deletedCount };
 });
-var findOrphanTodos = () => Effect2.gen(function* () {
+var findOrphanTodos = () => Effect3.gen(function* () {
   const todosDir = getTodosDir();
   const sessionsDir = getSessionsDir();
-  const [todosExists, sessionsExists] = yield* Effect2.all([
-    Effect2.tryPromise(
-      () => fs3.access(todosDir).then(() => true).catch(() => false)
+  const [todosExists, sessionsExists] = yield* Effect3.all([
+    Effect3.tryPromise(
+      () => fs4.access(todosDir).then(() => true).catch(() => false)
     ),
-    Effect2.tryPromise(
-      () => fs3.access(sessionsDir).then(() => true).catch(() => false)
+    Effect3.tryPromise(
+      () => fs4.access(sessionsDir).then(() => true).catch(() => false)
     )
   ]);
   if (!todosExists || !sessionsExists) return [];
-  const todoFiles = yield* Effect2.tryPromise(() => fs3.readdir(todosDir));
+  const todoFiles = yield* Effect3.tryPromise(() => fs4.readdir(todosDir));
   const jsonFiles = todoFiles.filter((f) => f.endsWith(".json"));
   const validSessionIds = /* @__PURE__ */ new Set();
-  const projectEntries = yield* Effect2.tryPromise(
-    () => fs3.readdir(sessionsDir, { withFileTypes: true })
+  const projectEntries = yield* Effect3.tryPromise(
+    () => fs4.readdir(sessionsDir, { withFileTypes: true })
   );
   for (const entry of projectEntries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
     const projectPath = path3.join(sessionsDir, entry.name);
-    const files = yield* Effect2.tryPromise(() => fs3.readdir(projectPath));
+    const files = yield* Effect3.tryPromise(() => fs4.readdir(projectPath));
     for (const f of files) {
       if (f.endsWith(".jsonl") && !f.startsWith("agent-")) {
         validSessionIds.add(f.replace(".jsonl", ""));
@@ -629,40 +658,40 @@ var findOrphanTodos = () => Effect2.gen(function* () {
   }
   return orphans;
 });
-var deleteOrphanTodos = () => Effect2.gen(function* () {
+var deleteOrphanTodos = () => Effect3.gen(function* () {
   const todosDir = getTodosDir();
   const orphans = yield* findOrphanTodos();
   if (orphans.length === 0) return { success: true, deletedCount: 0 };
   const backupDir = path3.join(todosDir, ".bak");
-  yield* Effect2.tryPromise(() => fs3.mkdir(backupDir, { recursive: true }));
+  yield* Effect3.tryPromise(() => fs4.mkdir(backupDir, { recursive: true }));
   let deletedCount = 0;
   for (const orphan of orphans) {
     const filePath = path3.join(todosDir, orphan);
     const backupPath = path3.join(backupDir, orphan);
-    yield* Effect2.tryPromise(() => fs3.rename(filePath, backupPath));
+    yield* Effect3.tryPromise(() => fs4.rename(filePath, backupPath));
     deletedCount++;
   }
   return { success: true, deletedCount };
 });
 
 // src/session/projects.ts
-import { Effect as Effect3 } from "effect";
-import * as fs4 from "fs/promises";
+import { Effect as Effect4 } from "effect";
+import * as fs5 from "fs/promises";
 import * as path4 from "path";
-var listProjects = Effect3.gen(function* () {
+var listProjects = Effect4.gen(function* () {
   const sessionsDir = getSessionsDir();
-  const exists = yield* Effect3.tryPromise(
-    () => fs4.access(sessionsDir).then(() => true).catch(() => false)
+  const exists = yield* Effect4.tryPromise(
+    () => fs5.access(sessionsDir).then(() => true).catch(() => false)
   );
   if (!exists) {
     return [];
   }
-  const entries = yield* Effect3.tryPromise(() => fs4.readdir(sessionsDir, { withFileTypes: true }));
-  const projects = yield* Effect3.all(
+  const entries = yield* Effect4.tryPromise(() => fs5.readdir(sessionsDir, { withFileTypes: true }));
+  const projects = yield* Effect4.all(
     entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map(
-      (entry) => Effect3.gen(function* () {
+      (entry) => Effect4.gen(function* () {
         const projectPath = path4.join(sessionsDir, entry.name);
-        const files = yield* Effect3.tryPromise(() => fs4.readdir(projectPath));
+        const files = yield* Effect4.tryPromise(() => fs5.readdir(projectPath));
         const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
         return {
           name: entry.name,
@@ -678,8 +707,8 @@ var listProjects = Effect3.gen(function* () {
 });
 
 // src/session/crud.ts
-import { Effect as Effect4, pipe, Array as A, Option as O } from "effect";
-import * as fs5 from "fs/promises";
+import { Effect as Effect5, pipe, Array as A, Option as O } from "effect";
+import * as fs6 from "fs/promises";
 import * as path5 from "path";
 import * as crypto from "crypto";
 
@@ -853,11 +882,9 @@ function deleteMessageWithChainRepair(messages, targetId, targetType) {
 }
 
 // src/session/crud.ts
-var updateSessionSummary = (projectName, sessionId, newSummary) => Effect4.gen(function* () {
+var updateSessionSummary = (projectName, sessionId, newSummary) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const content = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
-  const lines = content.trim().split("\n").filter(Boolean);
-  const messages = lines.map((line) => JSON.parse(line));
+  const messages = yield* readJsonlFile(filePath);
   const summaryIdx = messages.findIndex((m) => m.type === "summary");
   if (summaryIdx >= 0) {
     messages[summaryIdx] = { ...messages[summaryIdx], summary: newSummary };
@@ -871,20 +898,18 @@ var updateSessionSummary = (projectName, sessionId, newSummary) => Effect4.gen(f
     messages.unshift(summaryMsg);
   }
   const newContent = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  yield* Effect4.tryPromise(() => fs5.writeFile(filePath, newContent, "utf-8"));
+  yield* Effect5.tryPromise(() => fs6.writeFile(filePath, newContent, "utf-8"));
   return { success: true };
 });
-var listSessions = (projectName) => Effect4.gen(function* () {
+var listSessions = (projectName) => Effect5.gen(function* () {
   const projectPath = path5.join(getSessionsDir(), projectName);
-  const files = yield* Effect4.tryPromise(() => fs5.readdir(projectPath));
+  const files = yield* Effect5.tryPromise(() => fs6.readdir(projectPath));
   const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
-  const sessions = yield* Effect4.all(
+  const sessions = yield* Effect5.all(
     sessionFiles.map(
-      (file) => Effect4.gen(function* () {
+      (file) => Effect5.gen(function* () {
         const filePath = path5.join(projectPath, file);
-        const content = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
-        const lines = content.trim().split("\n").filter(Boolean);
-        const messages = lines.map((line) => JSON.parse(line));
+        const messages = yield* readJsonlFile(filePath);
         const sessionId = file.replace(".jsonl", "");
         const userAssistantMessages = messages.filter(
           (m) => m.type === "user" || m.type === "assistant"
@@ -935,30 +960,24 @@ var listSessions = (projectName) => Effect4.gen(function* () {
     return dateB - dateA;
   });
 });
-var readSession = (projectName, sessionId) => Effect4.gen(function* () {
+var readSession = (projectName, sessionId) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const content = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
-  const lines = content.trim().split("\n").filter(Boolean);
-  return lines.map((line) => JSON.parse(line));
+  return yield* readJsonlFile(filePath);
 });
-var deleteMessage = (projectName, sessionId, messageUuid, targetType) => Effect4.gen(function* () {
+var deleteMessage = (projectName, sessionId, messageUuid, targetType) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const content = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
-  const lines = content.trim().split("\n").filter(Boolean);
-  const messages = lines.map((line) => JSON.parse(line));
+  const messages = yield* readJsonlFile(filePath);
   const result = deleteMessageWithChainRepair(messages, messageUuid, targetType);
   if (!result.deleted) {
     return { success: false, error: "Message not found" };
   }
   const newContent = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  yield* Effect4.tryPromise(() => fs5.writeFile(filePath, newContent, "utf-8"));
+  yield* Effect5.tryPromise(() => fs6.writeFile(filePath, newContent, "utf-8"));
   return { success: true, deletedMessage: result.deleted };
 });
-var restoreMessage = (projectName, sessionId, message, index) => Effect4.gen(function* () {
+var restoreMessage = (projectName, sessionId, message, index) => Effect5.gen(function* () {
   const filePath = path5.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const content = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
-  const lines = content.trim().split("\n").filter(Boolean);
-  const messages = lines.map((line) => JSON.parse(line));
+  const messages = yield* readJsonlFile(filePath);
   const msgUuid = message.uuid ?? message.messageId;
   if (!msgUuid) {
     return { success: false, error: "Message has no uuid or messageId" };
@@ -973,41 +992,41 @@ var restoreMessage = (projectName, sessionId, message, index) => Effect4.gen(fun
   const insertIndex = Math.min(index, messages.length);
   messages.splice(insertIndex, 0, message);
   const newContent = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  yield* Effect4.tryPromise(() => fs5.writeFile(filePath, newContent, "utf-8"));
+  yield* Effect5.tryPromise(() => fs6.writeFile(filePath, newContent, "utf-8"));
   return { success: true };
 });
-var deleteSession = (projectName, sessionId) => Effect4.gen(function* () {
+var deleteSession = (projectName, sessionId) => Effect5.gen(function* () {
   const sessionsDir = getSessionsDir();
   const projectPath = path5.join(sessionsDir, projectName);
   const filePath = path5.join(projectPath, `${sessionId}.jsonl`);
   const linkedAgents = yield* findLinkedAgents(projectName, sessionId);
-  const stat4 = yield* Effect4.tryPromise(() => fs5.stat(filePath));
+  const stat4 = yield* Effect5.tryPromise(() => fs6.stat(filePath));
   if (stat4.size === 0) {
-    yield* Effect4.tryPromise(() => fs5.unlink(filePath));
+    yield* Effect5.tryPromise(() => fs6.unlink(filePath));
     const agentBackupDir2 = path5.join(projectPath, ".bak");
-    yield* Effect4.tryPromise(() => fs5.mkdir(agentBackupDir2, { recursive: true }));
+    yield* Effect5.tryPromise(() => fs6.mkdir(agentBackupDir2, { recursive: true }));
     for (const agentId of linkedAgents) {
       const agentPath = path5.join(projectPath, `${agentId}.jsonl`);
       const agentBackupPath = path5.join(agentBackupDir2, `${agentId}.jsonl`);
-      yield* Effect4.tryPromise(() => fs5.rename(agentPath, agentBackupPath).catch(() => {
+      yield* Effect5.tryPromise(() => fs6.rename(agentPath, agentBackupPath).catch(() => {
       }));
     }
     yield* deleteLinkedTodos(sessionId, linkedAgents);
     return { success: true, deletedAgents: linkedAgents.length };
   }
   const backupDir = path5.join(sessionsDir, ".bak");
-  yield* Effect4.tryPromise(() => fs5.mkdir(backupDir, { recursive: true }));
+  yield* Effect5.tryPromise(() => fs6.mkdir(backupDir, { recursive: true }));
   const agentBackupDir = path5.join(projectPath, ".bak");
-  yield* Effect4.tryPromise(() => fs5.mkdir(agentBackupDir, { recursive: true }));
+  yield* Effect5.tryPromise(() => fs6.mkdir(agentBackupDir, { recursive: true }));
   for (const agentId of linkedAgents) {
     const agentPath = path5.join(projectPath, `${agentId}.jsonl`);
     const agentBackupPath = path5.join(agentBackupDir, `${agentId}.jsonl`);
-    yield* Effect4.tryPromise(() => fs5.rename(agentPath, agentBackupPath).catch(() => {
+    yield* Effect5.tryPromise(() => fs6.rename(agentPath, agentBackupPath).catch(() => {
     }));
   }
   const todosResult = yield* deleteLinkedTodos(sessionId, linkedAgents);
   const backupPath = path5.join(backupDir, `${projectName}_${sessionId}.jsonl`);
-  yield* Effect4.tryPromise(() => fs5.rename(filePath, backupPath));
+  yield* Effect5.tryPromise(() => fs6.rename(filePath, backupPath));
   return {
     success: true,
     backupPath,
@@ -1015,15 +1034,15 @@ var deleteSession = (projectName, sessionId) => Effect4.gen(function* () {
     deletedTodos: todosResult.deletedCount
   };
 });
-var renameSession = (projectName, sessionId, newTitle) => Effect4.gen(function* () {
+var renameSession = (projectName, sessionId, newTitle) => Effect5.gen(function* () {
   const projectPath = path5.join(getSessionsDir(), projectName);
   const filePath = path5.join(projectPath, `${sessionId}.jsonl`);
-  const content = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
+  const content = yield* Effect5.tryPromise(() => fs6.readFile(filePath, "utf-8"));
   const lines = content.trim().split("\n").filter(Boolean);
   if (lines.length === 0) {
     return { success: false, error: "Empty session" };
   }
-  const messages = lines.map((line) => JSON.parse(line));
+  const messages = parseJsonlLines(lines, filePath);
   const sessionUuids = /* @__PURE__ */ new Set();
   for (const msg of messages) {
     if (msg.uuid && typeof msg.uuid === "string") {
@@ -1042,16 +1061,14 @@ var renameSession = (projectName, sessionId, newTitle) => Effect4.gen(function*
     messages.unshift(customTitleRecord);
   }
   const newContent = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  yield* Effect4.tryPromise(() => fs5.writeFile(filePath, newContent, "utf-8"));
-  const projectFiles = yield* Effect4.tryPromise(() => fs5.readdir(projectPath));
+  yield* Effect5.tryPromise(() => fs6.writeFile(filePath, newContent, "utf-8"));
+  const projectFiles = yield* Effect5.tryPromise(() => fs6.readdir(projectPath));
   const allJsonlFiles = projectFiles.filter((f) => f.endsWith(".jsonl"));
   const summariesTargetingThis = [];
   for (const file of allJsonlFiles) {
     const otherFilePath = path5.join(projectPath, file);
     try {
-      const otherContent = yield* Effect4.tryPromise(() => fs5.readFile(otherFilePath, "utf-8"));
-      const otherLines = otherContent.trim().split("\n").filter(Boolean);
-      const otherMessages = otherLines.map((l) => JSON.parse(l));
+      const otherMessages = yield* readJsonlFile(otherFilePath);
       for (let i = 0; i < otherMessages.length; i++) {
         const msg = otherMessages[i];
         if (msg.type === "summary" && typeof msg.leafUuid === "string" && sessionUuids.has(msg.leafUuid)) {
@@ -1070,19 +1087,15 @@ var renameSession = (projectName, sessionId, newTitle) => Effect4.gen(function*
     summariesTargetingThis.sort((a, b) => (a.timestamp ?? "").localeCompare(b.timestamp ?? ""));
     const firstSummary = summariesTargetingThis[0];
     const summaryFilePath = path5.join(projectPath, firstSummary.file);
-    const summaryContent = yield* Effect4.tryPromise(() => fs5.readFile(summaryFilePath, "utf-8"));
-    const summaryLines = summaryContent.trim().split("\n").filter(Boolean);
-    const summaryMessages = summaryLines.map((l) => JSON.parse(l));
+    const summaryMessages = yield* readJsonlFile(summaryFilePath);
     summaryMessages[firstSummary.idx] = {
       ...summaryMessages[firstSummary.idx],
       summary: newTitle
     };
     const newSummaryContent = summaryMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-    yield* Effect4.tryPromise(() => fs5.writeFile(summaryFilePath, newSummaryContent, "utf-8"));
+    yield* Effect5.tryPromise(() => fs6.writeFile(summaryFilePath, newSummaryContent, "utf-8"));
   } else {
-    const currentContent = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
-    const currentLines = currentContent.trim().split("\n").filter(Boolean);
-    const currentMessages = currentLines.map((l) => JSON.parse(l));
+    const currentMessages = yield* readJsonlFile(filePath);
     const firstUserIdx = currentMessages.findIndex((m) => m.type === "user");
     if (firstUserIdx >= 0) {
       const firstMsg = currentMessages[firstUserIdx];
@@ -1099,52 +1112,50 @@ var renameSession = (projectName, sessionId, newTitle) => Effect4.gen(function*
 
 ${cleanedText}`;
           const updatedContent = currentMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-          yield* Effect4.tryPromise(() => fs5.writeFile(filePath, updatedContent, "utf-8"));
+          yield* Effect5.tryPromise(() => fs6.writeFile(filePath, updatedContent, "utf-8"));
         }
       }
     }
   }
   return { success: true };
 });
-var moveSession = (sourceProject, sessionId, targetProject) => Effect4.gen(function* () {
+var moveSession = (sourceProject, sessionId, targetProject) => Effect5.gen(function* () {
   const sessionsDir = getSessionsDir();
   const sourcePath = path5.join(sessionsDir, sourceProject);
   const targetPath = path5.join(sessionsDir, targetProject);
   const sourceFile = path5.join(sourcePath, `${sessionId}.jsonl`);
   const targetFile = path5.join(targetPath, `${sessionId}.jsonl`);
-  const sourceExists = yield* Effect4.tryPromise(
-    () => fs5.access(sourceFile).then(() => true).catch(() => false)
+  const sourceExists = yield* Effect5.tryPromise(
+    () => fs6.access(sourceFile).then(() => true).catch(() => false)
   );
   if (!sourceExists) {
     return { success: false, error: "Source session not found" };
   }
-  const targetExists = yield* Effect4.tryPromise(
-    () => fs5.access(targetFile).then(() => true).catch(() => false)
+  const targetExists = yield* Effect5.tryPromise(
+    () => fs6.access(targetFile).then(() => true).catch(() => false)
   );
   if (targetExists) {
     return { success: false, error: "Session already exists in target project" };
   }
-  yield* Effect4.tryPromise(() => fs5.mkdir(targetPath, { recursive: true }));
+  yield* Effect5.tryPromise(() => fs6.mkdir(targetPath, { recursive: true }));
   const linkedAgents = yield* findLinkedAgents(sourceProject, sessionId);
-  yield* Effect4.tryPromise(() => fs5.rename(sourceFile, targetFile));
+  yield* Effect5.tryPromise(() => fs6.rename(sourceFile, targetFile));
   for (const agentId of linkedAgents) {
     const sourceAgentFile = path5.join(sourcePath, `${agentId}.jsonl`);
     const targetAgentFile = path5.join(targetPath, `${agentId}.jsonl`);
-    const agentExists = yield* Effect4.tryPromise(
-      () => fs5.access(sourceAgentFile).then(() => true).catch(() => false)
+    const agentExists = yield* Effect5.tryPromise(
+      () => fs6.access(sourceAgentFile).then(() => true).catch(() => false)
     );
     if (agentExists) {
-      yield* Effect4.tryPromise(() => fs5.rename(sourceAgentFile, targetAgentFile));
+      yield* Effect5.tryPromise(() => fs6.rename(sourceAgentFile, targetAgentFile));
     }
   }
   return { success: true };
 });
-var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect4.gen(function* () {
+var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect5.gen(function* () {
   const projectPath = path5.join(getSessionsDir(), projectName);
   const filePath = path5.join(projectPath, `${sessionId}.jsonl`);
-  const content = yield* Effect4.tryPromise(() => fs5.readFile(filePath, "utf-8"));
-  const lines = content.trim().split("\n").filter(Boolean);
-  const allMessages = lines.map((line) => JSON.parse(line));
+  const allMessages = yield* readJsonlFile(filePath);
   const splitIndex = allMessages.findIndex((m) => m.uuid === splitAtMessageUuid);
   if (splitIndex === -1) {
     return { success: false, error: "Message not found" };
@@ -1190,30 +1201,30 @@ var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect4.gen(f
     updatedMovedMessages.unshift(clonedSummary);
   }
   const keptContent = keptMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  yield* Effect4.tryPromise(() => fs5.writeFile(filePath, keptContent, "utf-8"));
+  yield* Effect5.tryPromise(() => fs6.writeFile(filePath, keptContent, "utf-8"));
   const newFilePath = path5.join(projectPath, `${newSessionId}.jsonl`);
   const newContent = updatedMovedMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  yield* Effect4.tryPromise(() => fs5.writeFile(newFilePath, newContent, "utf-8"));
-  const agentFiles = yield* Effect4.tryPromise(() => fs5.readdir(projectPath));
+  yield* Effect5.tryPromise(() => fs6.writeFile(newFilePath, newContent, "utf-8"));
+  const agentFiles = yield* Effect5.tryPromise(() => fs6.readdir(projectPath));
   const agentJsonlFiles = agentFiles.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
   for (const agentFile of agentJsonlFiles) {
     const agentPath = path5.join(projectPath, agentFile);
-    const agentContent = yield* Effect4.tryPromise(() => fs5.readFile(agentPath, "utf-8"));
+    const agentContent = yield* Effect5.tryPromise(() => fs6.readFile(agentPath, "utf-8"));
     const agentLines = agentContent.trim().split("\n").filter(Boolean);
     if (agentLines.length === 0) continue;
-    const firstAgentMsg = JSON.parse(agentLines[0]);
+    const agentMessages = parseJsonlLines(agentLines, agentPath);
+    const firstAgentMsg = agentMessages[0];
     if (firstAgentMsg.sessionId === sessionId) {
       const agentId = agentFile.replace("agent-", "").replace(".jsonl", "");
       const isRelatedToMoved = movedMessages.some(
         (msg) => msg.agentId === agentId
       );
       if (isRelatedToMoved) {
-        const updatedAgentMessages = agentLines.map((line) => {
-          const msg = JSON.parse(line);
-          return JSON.stringify({ ...msg, sessionId: newSessionId });
-        });
+        const updatedAgentMessages = agentMessages.map(
+          (msg) => JSON.stringify({ ...msg, sessionId: newSessionId })
+        );
         const updatedAgentContent = updatedAgentMessages.join("\n") + "\n";
-        yield* Effect4.tryPromise(() => fs5.writeFile(agentPath, updatedAgentContent, "utf-8"));
+        yield* Effect5.tryPromise(() => fs6.writeFile(agentPath, updatedAgentContent, "utf-8"));
       }
     }
   }
@@ -1227,8 +1238,8 @@ var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect4.gen(f
 });
 
 // src/session/tree.ts
-import { Effect as Effect5 } from "effect";
-import * as fs6 from "fs/promises";
+import { Effect as Effect6 } from "effect";
+import * as fs7 from "fs/promises";
 import * as path6 from "path";
 var sortSessions = (sessions, sort) => {
   return sessions.sort((a, b) => {
@@ -1268,12 +1279,12 @@ var sortSessions = (sessions, sort) => {
     return sort.order === "desc" ? -comparison : comparison;
   });
 };
-var loadSessionTreeDataInternal = (projectName, sessionId, summariesByTargetSession, fileMtime) => Effect5.gen(function* () {
+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* Effect5.tryPromise(() => fs6.readFile(filePath, "utf-8"));
+  const content = yield* Effect6.tryPromise(() => fs7.readFile(filePath, "utf-8"));
   const lines = content.trim().split("\n").filter(Boolean);
-  const messages = lines.map((line) => JSON.parse(line));
+  const messages = parseJsonlLines(lines, filePath);
   let summaries;
   if (summariesByTargetSession) {
     summaries = [...summariesByTargetSession.get(sessionId) ?? []].sort((a, b) => {
@@ -1289,26 +1300,24 @@ var loadSessionTreeDataInternal = (projectName, sessionId, summariesByTargetSess
         sessionUuids.add(msg.uuid);
       }
     }
-    const projectFiles = yield* Effect5.tryPromise(() => fs6.readdir(projectPath));
+    const projectFiles = yield* Effect6.tryPromise(() => fs7.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* Effect5.tryPromise(() => fs6.readFile(otherFilePath, "utf-8"));
+        const otherContent = yield* Effect6.tryPromise(() => fs7.readFile(otherFilePath, "utf-8"));
         const otherLines = otherContent.trim().split("\n").filter(Boolean);
-        for (const line of otherLines) {
-          try {
-            const msg = JSON.parse(line);
-            if (msg.type === "summary" && typeof msg.summary === "string" && typeof msg.leafUuid === "string" && sessionUuids.has(msg.leafUuid)) {
-              const targetMsg = messages.find((m) => m.uuid === msg.leafUuid);
-              summaries.push({
-                summary: msg.summary,
-                leafUuid: msg.leafUuid,
-                timestamp: targetMsg?.timestamp ?? msg.timestamp,
-                sourceFile: file
-              });
-            }
-          } catch {
+        for (let i = 0; i < otherLines.length; i++) {
+          const msg = tryParseJsonLine(otherLines[i], i + 1, otherFilePath);
+          if (!msg) continue;
+          if (msg.type === "summary" && typeof msg.summary === "string" && typeof msg.leafUuid === "string" && sessionUuids.has(msg.leafUuid)) {
+            const targetMsg = messages.find((m) => m.uuid === msg.leafUuid);
+            summaries.push({
+              summary: msg.summary,
+              leafUuid: msg.leafUuid,
+              timestamp: targetMsg?.timestamp ?? msg.timestamp,
+              sourceFile: file
+            });
           }
         }
       } catch {
@@ -1342,7 +1351,7 @@ var loadSessionTreeDataInternal = (projectName, sessionId, summariesByTargetSess
   for (const agentId of linkedAgentIds) {
     const agentPath = path6.join(projectPath, `${agentId}.jsonl`);
     try {
-      const agentContent = yield* Effect5.tryPromise(() => fs6.readFile(agentPath, "utf-8"));
+      const agentContent = yield* Effect6.tryPromise(() => fs7.readFile(agentPath, "utf-8"));
       const agentLines = agentContent.trim().split("\n").filter(Boolean);
       const agentMsgs = agentLines.map((l) => JSON.parse(l));
       const agentUserAssistant = agentMsgs.filter(
@@ -1390,22 +1399,22 @@ 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) => Effect5.gen(function* () {
+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* Effect5.tryPromise(() => fs6.readdir(projectPath));
+  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* Effect5.all(
+  yield* Effect6.all(
     sessionFiles.map(
-      (file) => Effect5.gen(function* () {
+      (file) => Effect6.gen(function* () {
         const filePath = path6.join(projectPath, file);
         try {
-          const stat4 = yield* Effect5.tryPromise(() => fs6.stat(filePath));
+          const stat4 = yield* Effect6.tryPromise(() => fs7.stat(filePath));
           fileMtimes.set(file.replace(".jsonl", ""), stat4.mtimeMs);
         } catch {
         }
@@ -1416,38 +1425,36 @@ var loadProjectTreeData = (projectName, sortOptions) => Effect5.gen(function* ()
   const globalUuidMap = /* @__PURE__ */ new Map();
   const allSummaries = [];
   const allJsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-  yield* Effect5.all(
+  yield* Effect6.all(
     allJsonlFiles.map(
-      (file) => Effect5.gen(function* () {
+      (file) => Effect6.gen(function* () {
         const filePath = path6.join(projectPath, file);
         const fileSessionId = file.replace(".jsonl", "");
         try {
-          const content = yield* Effect5.tryPromise(() => fs6.readFile(filePath, "utf-8"));
+          const content = yield* Effect6.tryPromise(() => fs7.readFile(filePath, "utf-8"));
           const lines = content.trim().split("\n").filter(Boolean);
-          for (const line of lines) {
-            try {
-              const msg = JSON.parse(line);
-              if (msg.uuid && typeof msg.uuid === "string") {
-                globalUuidMap.set(msg.uuid, {
-                  sessionId: fileSessionId,
-                  timestamp: msg.timestamp
-                });
-              }
-              if (msg.messageId && typeof msg.messageId === "string") {
-                globalUuidMap.set(msg.messageId, {
-                  sessionId: fileSessionId,
-                  timestamp: msg.snapshot?.timestamp
-                });
-              }
-              if (msg.type === "summary" && typeof msg.summary === "string") {
-                allSummaries.push({
-                  summary: msg.summary,
-                  leafUuid: msg.leafUuid,
-                  timestamp: msg.timestamp,
-                  sourceFile: file
-                });
-              }
-            } catch {
+          for (let i = 0; i < lines.length; i++) {
+            const msg = tryParseJsonLine(lines[i], i + 1, filePath);
+            if (!msg) continue;
+            if (msg.uuid && typeof msg.uuid === "string") {
+              globalUuidMap.set(msg.uuid, {
+                sessionId: fileSessionId,
+                timestamp: msg.timestamp
+              });
+            }
+            if (msg.messageId && typeof msg.messageId === "string") {
+              globalUuidMap.set(msg.messageId, {
+                sessionId: fileSessionId,
+                timestamp: msg.snapshot?.timestamp
+              });
+            }
+            if (msg.type === "summary" && typeof msg.summary === "string") {
+              allSummaries.push({
+                summary: msg.summary,
+                leafUuid: msg.leafUuid,
+                timestamp: msg.timestamp,
+                sourceFile: file
+              });
             }
           }
         } catch {
@@ -1475,7 +1482,7 @@ var loadProjectTreeData = (projectName, sortOptions) => Effect5.gen(function* ()
       }
     }
   }
-  const sessions = yield* Effect5.all(
+  const sessions = yield* Effect6.all(
     sessionFiles.map((file) => {
       const sessionId = file.replace(".jsonl", "");
       const mtime = fileMtimes.get(sessionId);
@@ -1500,10 +1507,10 @@ var loadProjectTreeData = (projectName, sortOptions) => Effect5.gen(function* ()
 });
 
 // src/session/analysis.ts
-import { Effect as Effect6 } from "effect";
-import * as fs7 from "fs/promises";
+import { Effect as Effect7 } from "effect";
+import * as fs8 from "fs/promises";
 import * as path7 from "path";
-var analyzeSession = (projectName, sessionId) => Effect6.gen(function* () {
+var analyzeSession = (projectName, sessionId) => Effect7.gen(function* () {
   const messages = yield* readSession(projectName, sessionId);
   let userMessages = 0;
   let assistantMessages = 0;
@@ -1634,13 +1641,13 @@ var analyzeSession = (projectName, sessionId) => Effect6.gen(function* () {
     milestones
   };
 });
-var compressSession = (projectName, sessionId, options = {}) => Effect6.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* Effect6.tryPromise(() => fs7.readFile(filePath, "utf-8"));
+  const content = yield* Effect7.tryPromise(() => fs8.readFile(filePath, "utf-8"));
   const originalSize = Buffer.byteLength(content, "utf-8");
   const lines = content.trim().split("\n").filter(Boolean);
-  const messages = lines.map((line) => JSON.parse(line));
+  const messages = parseJsonlLines(lines, filePath);
   let removedSnapshots = 0;
   let truncatedOutputs = 0;
   const snapshotIndices = [];
@@ -1680,7 +1687,7 @@ var compressSession = (projectName, sessionId, options = {}) => Effect6.gen(func
   }
   const newContent = filteredMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
   const compressedSize = Buffer.byteLength(newContent, "utf-8");
-  yield* Effect6.tryPromise(() => fs7.writeFile(filePath, newContent, "utf-8"));
+  yield* Effect7.tryPromise(() => fs8.writeFile(filePath, newContent, "utf-8"));
   return {
     success: true,
     originalSize,
@@ -1689,12 +1696,12 @@ var compressSession = (projectName, sessionId, options = {}) => Effect6.gen(func
     truncatedOutputs
   };
 });
-var extractProjectKnowledge = (projectName, sessionIds) => Effect6.gen(function* () {
+var extractProjectKnowledge = (projectName, sessionIds) => Effect7.gen(function* () {
   const sessionsDir = getSessionsDir();
   const projectDir = path7.join(sessionsDir, projectName);
   let targetSessionIds = sessionIds;
   if (!targetSessionIds) {
-    const files = yield* Effect6.tryPromise(() => fs7.readdir(projectDir));
+    const files = yield* Effect7.tryPromise(() => fs8.readdir(projectDir));
     targetSessionIds = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-")).map((f) => f.replace(".jsonl", ""));
   }
   const fileModifyCount = /* @__PURE__ */ new Map();
@@ -1768,7 +1775,7 @@ function truncateText(text, maxLen) {
   }
   return cleaned;
 }
-var summarizeSession = (projectName, sessionId, options = {}) => Effect6.gen(function* () {
+var summarizeSession = (projectName, sessionId, options = {}) => Effect7.gen(function* () {
   const { limit = 50, maxLength = 100 } = options;
   const messages = yield* readSession(projectName, sessionId);
   const lines = [];
@@ -1820,15 +1827,15 @@ var summarizeSession = (projectName, sessionId, options = {}) => Effect6.gen(fun
 });
 
 // src/session/cleanup.ts
-import { Effect as Effect7 } from "effect";
-import * as fs8 from "fs/promises";
+import { Effect as Effect8 } from "effect";
+import * as fs9 from "fs/promises";
 import * as path8 from "path";
-var cleanInvalidMessages = (projectName, sessionId) => Effect7.gen(function* () {
+var cleanInvalidMessages = (projectName, sessionId) => Effect8.gen(function* () {
   const filePath = path8.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
-  const content = yield* Effect7.tryPromise(() => fs8.readFile(filePath, "utf-8"));
+  const content = yield* Effect8.tryPromise(() => fs9.readFile(filePath, "utf-8"));
   const lines = content.trim().split("\n").filter(Boolean);
   if (lines.length === 0) return { removedCount: 0, remainingCount: 0 };
-  const messages = lines.map((line) => JSON.parse(line));
+  const messages = parseJsonlLines(lines, filePath);
   const invalidIndices = [];
   messages.forEach((msg, idx) => {
     if (isInvalidApiKeyMessage(msg)) {
@@ -1857,7 +1864,7 @@ var cleanInvalidMessages = (projectName, sessionId) => Effect7.gen(function* ()
     lastValidUuid = msg.uuid;
   }
   const newContent = filtered.length > 0 ? filtered.map((m) => JSON.stringify(m)).join("\n") + "\n" : "";
-  yield* Effect7.tryPromise(() => fs8.writeFile(filePath, newContent, "utf-8"));
+  yield* Effect8.tryPromise(() => fs9.writeFile(filePath, newContent, "utf-8"));
   const remainingUserAssistant = filtered.filter(
     (m) => m.type === "user" || m.type === "assistant"
   ).length;
@@ -1865,14 +1872,14 @@ var cleanInvalidMessages = (projectName, sessionId) => Effect7.gen(function* ()
   const remainingCount = remainingUserAssistant > 0 ? remainingUserAssistant : hasSummary ? 1 : 0;
   return { removedCount: invalidIndices.length, remainingCount };
 });
-var previewCleanup = (projectName) => Effect7.gen(function* () {
+var previewCleanup = (projectName) => Effect8.gen(function* () {
   const projects = yield* listProjects;
   const targetProjects = projectName ? projects.filter((p) => p.name === projectName) : projects;
   const orphanTodos = yield* findOrphanTodos();
   const orphanTodoCount = orphanTodos.length;
-  const results = yield* Effect7.all(
+  const results = yield* Effect8.all(
     targetProjects.map(
-      (project) => Effect7.gen(function* () {
+      (project) => Effect8.gen(function* () {
         const sessions = yield* listSessions(project.name);
         const emptySessions = sessions.filter((s) => s.messageCount === 0);
         const invalidSessions = sessions.filter(
@@ -1905,7 +1912,7 @@ var previewCleanup = (projectName) => Effect7.gen(function* () {
   }
   return results;
 });
-var clearSessions = (options) => Effect7.gen(function* () {
+var clearSessions = (options) => Effect8.gen(function* () {
   const {
     projectName,
     clearEmpty = true,
@@ -1924,7 +1931,7 @@ var clearSessions = (options) => Effect7.gen(function* () {
   if (clearInvalid) {
     for (const project of targetProjects) {
       const projectPath = path8.join(getSessionsDir(), project.name);
-      const files = yield* Effect7.tryPromise(() => fs8.readdir(projectPath));
+      const files = yield* Effect8.tryPromise(() => fs9.readdir(projectPath));
       const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
       for (const file of sessionFiles) {
         const sessionId = file.replace(".jsonl", "");
@@ -1980,72 +1987,96 @@ var clearSessions = (options) => Effect7.gen(function* () {
 });
 
 // src/session/search.ts
-import { Effect as Effect8 } from "effect";
-import * as fs9 from "fs/promises";
+import { Effect as Effect9, pipe as pipe2 } from "effect";
+import * as fs10 from "fs/promises";
 import * as path9 from "path";
-var searchSessions = (query, options = {}) => Effect8.gen(function* () {
+var extractSnippet = (text, matchIndex, queryLength) => {
+  const start = Math.max(0, matchIndex - 50);
+  const end = Math.min(text.length, matchIndex + queryLength + 50);
+  return (start > 0 ? "..." : "") + text.slice(start, end).trim() + (end < text.length ? "..." : "");
+};
+var findContentMatch = (lines, queryLower, filePath) => {
+  for (let i = 0; i < lines.length; i++) {
+    const msg = tryParseJsonLine(lines[i], i + 1, filePath);
+    if (!msg) continue;
+    if (msg.type !== "user" && msg.type !== "assistant") continue;
+    const text = extractTextContent(msg.message);
+    const textLower = text.toLowerCase();
+    const matchIndex = textLower.indexOf(queryLower);
+    if (matchIndex !== -1) {
+      return {
+        msg,
+        snippet: extractSnippet(text, matchIndex, queryLower.length)
+      };
+    }
+  }
+  return null;
+};
+var searchSessionContent = (projectName, sessionId, filePath, queryLower) => pipe2(
+  Effect9.tryPromise(() => fs10.readFile(filePath, "utf-8")),
+  Effect9.map((content) => {
+    const lines = content.trim().split("\n").filter(Boolean);
+    const match = findContentMatch(lines, queryLower, filePath);
+    if (!match) return null;
+    return {
+      sessionId,
+      projectName,
+      title: extractTitle(extractTextContent(match.msg.message)) || `Session ${sessionId.slice(0, 8)}`,
+      matchType: "content",
+      snippet: match.snippet,
+      messageUuid: match.msg.uuid,
+      timestamp: match.msg.timestamp
+    };
+  }),
+  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 sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+  const searchEffects = sessionFiles.map((file) => ({
+    sessionId: file.replace(".jsonl", ""),
+    filePath: path9.join(projectPath, file)
+  })).filter(({ sessionId }) => !alreadyFoundIds.has(`${project.name}:${sessionId}`)).map(
+    ({ sessionId, filePath }) => searchSessionContent(project.name, sessionId, filePath, queryLower)
+  );
+  const results = yield* Effect9.all(searchEffects, { concurrency: 10 });
+  return results.filter((r) => r !== null);
+});
+var searchSessions = (query, options = {}) => Effect9.gen(function* () {
   const { projectName, searchContent = false } = options;
-  const results = [];
   const queryLower = query.toLowerCase();
   const projects = yield* listProjects;
   const targetProjects = projectName ? projects.filter((p) => p.name === projectName) : projects;
-  for (const project of targetProjects) {
-    const sessions = yield* listSessions(project.name);
-    for (const session of sessions) {
-      const titleLower = (session.title ?? "").toLowerCase();
-      if (titleLower.includes(queryLower)) {
-        results.push({
-          sessionId: session.id,
-          projectName: project.name,
-          title: session.title ?? "Untitled",
-          matchType: "title",
-          timestamp: session.updatedAt
-        });
-      }
-    }
-  }
+  const titleSearchEffects = targetProjects.map(
+    (project) => pipe2(
+      listSessions(project.name),
+      Effect9.map(
+        (sessions) => sessions.filter((session) => (session.title ?? "").toLowerCase().includes(queryLower)).map(
+          (session) => ({
+            sessionId: session.id,
+            projectName: project.name,
+            title: session.title ?? "Untitled",
+            matchType: "title",
+            timestamp: session.updatedAt
+          })
+        )
+      )
+    )
+  );
+  const titleResultsNested = yield* Effect9.all(titleSearchEffects, { concurrency: 10 });
+  const titleResults = titleResultsNested.flat();
+  let contentResults = [];
   if (searchContent) {
-    for (const project of targetProjects) {
-      const projectPath = path9.join(getSessionsDir(), project.name);
-      const files = yield* Effect8.tryPromise(() => fs9.readdir(projectPath));
-      const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
-      for (const file of sessionFiles) {
-        const sessionId = file.replace(".jsonl", "");
-        if (results.some((r) => r.sessionId === sessionId && r.projectName === project.name)) {
-          continue;
-        }
-        const filePath = path9.join(projectPath, file);
-        const content = yield* Effect8.tryPromise(() => fs9.readFile(filePath, "utf-8"));
-        const lines = content.trim().split("\n").filter(Boolean);
-        for (const line of lines) {
-          try {
-            const msg = JSON.parse(line);
-            if (msg.type !== "user" && msg.type !== "assistant") continue;
-            const text = extractTextContent(msg.message);
-            const textLower = text.toLowerCase();
-            if (textLower.includes(queryLower)) {
-              const matchIndex = textLower.indexOf(queryLower);
-              const start = Math.max(0, matchIndex - 50);
-              const end = Math.min(text.length, matchIndex + query.length + 50);
-              const snippet = (start > 0 ? "..." : "") + text.slice(start, end).trim() + (end < text.length ? "..." : "");
-              results.push({
-                sessionId,
-                projectName: project.name,
-                title: extractTitle(extractTextContent(msg.message)) || `Session ${sessionId.slice(0, 8)}`,
-                matchType: "content",
-                snippet,
-                messageUuid: msg.uuid,
-                timestamp: msg.timestamp
-              });
-              break;
-            }
-          } catch {
-          }
-        }
-      }
-    }
+    const alreadyFoundIds = new Set(titleResults.map((r) => `${r.projectName}:${r.sessionId}`));
+    const contentSearchEffects = targetProjects.map(
+      (project) => searchProjectContent(project, queryLower, alreadyFoundIds)
+    );
+    const contentResultsNested = yield* Effect9.all(contentSearchEffects, { concurrency: 5 });
+    contentResults = contentResultsNested.flat();
   }
-  return results.sort((a, b) => {
+  const allResults = [...titleResults, ...contentResults];
+  return allResults.sort((a, b) => {
     const dateA = a.timestamp ? new Date(a.timestamp).getTime() : 0;
     const dateB = b.timestamp ? new Date(b.timestamp).getTime() : 0;
     return dateB - dateA;
@@ -2053,8 +2084,8 @@ var searchSessions = (query, options = {}) => Effect8.gen(function* () {
 });
 
 // src/session/files.ts
-import { Effect as Effect9 } from "effect";
-var getSessionFiles = (projectName, sessionId) => Effect9.gen(function* () {
+import { Effect as Effect10 } from "effect";
+var getSessionFiles = (projectName, sessionId) => Effect10.gen(function* () {
   const messages = yield* readSession(projectName, sessionId);
   const fileChanges = [];
   const seenFiles = /* @__PURE__ */ new Set();
@@ -2108,13 +2139,13 @@ var getSessionFiles = (projectName, sessionId) => Effect9.gen(function* () {
 });
 
 // src/session/index-file.ts
-import { Effect as Effect10 } from "effect";
-import * as fs10 from "fs/promises";
+import { Effect as Effect11 } from "effect";
+import * as fs11 from "fs/promises";
 import * as path10 from "path";
-var loadSessionsIndex = (projectName) => Effect10.gen(function* () {
+var loadSessionsIndex = (projectName) => Effect11.gen(function* () {
   const indexPath = path10.join(getSessionsDir(), projectName, "sessions-index.json");
   try {
-    const content = yield* Effect10.tryPromise(() => fs10.readFile(indexPath, "utf-8"));
+    const content = yield* Effect11.tryPromise(() => fs11.readFile(indexPath, "utf-8"));
     const index = JSON.parse(content);
     return index;
   } catch {
@@ -2141,10 +2172,10 @@ var sortIndexEntriesByModified = (entries) => {
     return modB - modA;
   });
 };
-var hasSessionsIndex = (projectName) => Effect10.gen(function* () {
+var hasSessionsIndex = (projectName) => Effect11.gen(function* () {
   const indexPath = path10.join(getSessionsDir(), projectName, "sessions-index.json");
   try {
-    yield* Effect10.tryPromise(() => fs10.access(indexPath));
+    yield* Effect11.tryPromise(() => fs11.access(indexPath));
     return true;
   } catch {
     return false;
@@ -2192,8 +2223,10 @@ export {
   maskHomePath,
   moveSession,
   parseCommandMessage,
+  parseJsonlLines,
   pathToFolderName,
   previewCleanup,
+  readJsonlFile,
   readSession,
   renameSession,
   restoreMessage,
@@ -2204,6 +2237,7 @@ export {
   sortProjects,
   splitSession,
   summarizeSession,
+  tryParseJsonLine,
   updateSessionSummary,
   validateChain,
   validateToolUseResult