cogpit-memory 0.1.5 → 0.1.8

package/dist/cli.js

@@ -64,6 +64,9 @@ function isSystemMessage(msg) {
 function isSummaryMessage(msg) {
   return msg.type === "summary";
 }
+function isCompactBoundary(msg) {
+  return msg.type === "system" && msg.subtype === "compact_boundary";
+}
 function extractTextFromContent(content) {
   if (typeof content === "string") return content;
   return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
@@ -143,7 +146,7 @@ function buildTurns(messages) {
       agentBlockMap.set(parentId, block);
     }
   }
-  function finalizeTurn() {
+  function finalizeTurn2() {
     if (!current) return;
     for (const tc of current.toolCalls) {
       flushSubAgentMessages(tc.id);
@@ -157,13 +160,21 @@ function buildTurns(messages) {
   }
   for (const msg of messages) {
     if (isSummaryMessage(msg)) {
-      finalizeTurn();
+      finalizeTurn2();
       pendingCompaction = buildCompactionSummary(
         turns,
         msg.summary ?? "Conversation compacted"
       );
       continue;
     }
+    if (isCompactBoundary(msg)) {
+      finalizeTurn2();
+      pendingCompaction = buildCompactionSummary(
+        turns,
+        msg.content ?? "Conversation compacted"
+      );
+      continue;
+    }
     if (isUserMessage(msg) && !msg.isMeta) {
       const content = msg.message.content;
       if (typeof content !== "string" && Array.isArray(content)) {
@@ -225,7 +236,7 @@ function buildTurns(messages) {
           continue;
         }
       }
-      finalizeTurn();
+      finalizeTurn2();
       current = {
         id: msg.uuid ?? crypto.randomUUID(),
         userMessage: msg.message.content,
@@ -440,7 +451,7 @@ function buildTurns(messages) {
       continue;
     }
   }
-  finalizeTurn();
+  finalizeTurn2();
   return turns;
 }
 
@@ -593,6 +604,315 @@ function computeStats(turns) {
   return stats;
 }
 
+// src/lib/codex.ts
+var SKIP_PROMPT_PREFIXES = [
+  "<environment_context>",
+  "<permissions instructions>",
+  "<collaboration_mode>",
+  "<skills_instructions>"
+];
+function randomTurnId(prefix) {
+  return globalThis.crypto?.randomUUID?.() ?? `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function safeParseLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isCodexRecord(record) {
+  if (!record || typeof record.type !== "string") return false;
+  return record.type === "session_meta" || record.type === "turn_context" || record.type === "event_msg" || record.type === "response_item";
+}
+function extractMessageText(payload, blockType) {
+  const content = payload?.content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => isObject(block) && block.type === blockType && typeof block.text === "string").map((block) => block.text).join("\n").trim();
+}
+function normalizePromptText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  if (SKIP_PROMPT_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) return "";
+  return trimmed;
+}
+function mergeTokenUsage2(existing, incoming) {
+  if (!existing) return { ...incoming };
+  return {
+    input_tokens: existing.input_tokens + incoming.input_tokens,
+    output_tokens: existing.output_tokens + incoming.output_tokens,
+    cache_creation_input_tokens: (existing.cache_creation_input_tokens ?? 0) + (incoming.cache_creation_input_tokens ?? 0),
+    cache_read_input_tokens: (existing.cache_read_input_tokens ?? 0) + (incoming.cache_read_input_tokens ?? 0)
+  };
+}
+function parseTokenUsage(value) {
+  if (!isObject(value)) return null;
+  const inputTokens = typeof value.input_tokens === "number" ? value.input_tokens : 0;
+  const outputTokens = typeof value.output_tokens === "number" ? value.output_tokens : 0;
+  const cacheCreation = typeof value.cache_creation_input_tokens === "number" ? value.cache_creation_input_tokens : 0;
+  const cacheRead = typeof value.cache_read_input_tokens === "number" ? value.cache_read_input_tokens : 0;
+  if (inputTokens === 0 && outputTokens === 0 && cacheCreation === 0 && cacheRead === 0) return null;
+  return {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    cache_creation_input_tokens: cacheCreation,
+    cache_read_input_tokens: cacheRead
+  };
+}
+function appendAssistantText(turn, text, timestamp) {
+  if (!text) return;
+  turn.assistantText.push(text);
+  const last = turn.contentBlocks[turn.contentBlocks.length - 1];
+  if (last && last.kind === "text") {
+    last.text.push(text);
+    return;
+  }
+  turn.contentBlocks.push({ kind: "text", text: [text], timestamp });
+}
+function appendThinking(turn, text, timestamp) {
+  if (!text) return;
+  const block = { type: "thinking", thinking: text, signature: "" };
+  turn.thinking.push(block);
+  const last = turn.contentBlocks[turn.contentBlocks.length - 1];
+  if (last && last.kind === "thinking") {
+    last.blocks.push(block);
+    return;
+  }
+  turn.contentBlocks.push({ kind: "thinking", blocks: [block], timestamp });
+}
+function appendToolCall(turn, toolCall, timestamp) {
+  turn.toolCalls.push(toolCall);
+  const last = turn.contentBlocks[turn.contentBlocks.length - 1];
+  if (last && last.kind === "tool_calls" && last.timestamp === timestamp) {
+    last.toolCalls.push(toolCall);
+    return;
+  }
+  turn.contentBlocks.push({ kind: "tool_calls", toolCalls: [toolCall], timestamp });
+}
+function finalizeTurn(turns, current, lastTimestamp) {
+  if (!current) return null;
+  const hasContent = current.userMessage !== null || current.assistantText.length > 0 || current.toolCalls.length > 0 || current.thinking.length > 0;
+  if (!hasContent) return null;
+  if (current.timestamp && lastTimestamp) {
+    const start = new Date(current.timestamp).getTime();
+    const end = new Date(lastTimestamp).getTime();
+    if (Number.isFinite(start) && Number.isFinite(end) && end >= start) {
+      current.durationMs = end - start;
+    }
+  }
+  turns.push(current);
+  return null;
+}
+function parseToolInput(argumentsText) {
+  if (typeof argumentsText !== "string" || !argumentsText.trim()) return {};
+  try {
+    const parsed = JSON.parse(argumentsText);
+    return isObject(parsed) ? parsed : { value: parsed };
+  } catch {
+    return { raw: argumentsText };
+  }
+}
+function inferToolError(output) {
+  if (!output) return false;
+  const exitMatch = output.match(/Process exited with code (\d+)/);
+  if (exitMatch) return exitMatch[1] !== "0";
+  return /\b(error|failed|exception)\b/i.test(output);
+}
+function createTurn(turnId, timestamp, model) {
+  return {
+    id: turnId || randomTurnId("codex-turn"),
+    userMessage: null,
+    contentBlocks: [],
+    thinking: [],
+    assistantText: [],
+    toolCalls: [],
+    subAgentActivity: [],
+    timestamp,
+    durationMs: null,
+    tokenUsage: null,
+    model
+  };
+}
+function extractPromptFromRecord(record) {
+  if (record.type === "event_msg" && isObject(record.payload) && record.payload.type === "user_message" && typeof record.payload.message === "string") {
+    return normalizePromptText(record.payload.message);
+  }
+  if (record.type === "response_item" && isObject(record.payload) && record.payload.type === "message" && record.payload.role === "user") {
+    return normalizePromptText(extractMessageText(record.payload, "input_text"));
+  }
+  return "";
+}
+function extractMetadataFromRecords(records) {
+  let sessionId = "";
+  let version = "";
+  let gitBranch = "";
+  let cwd = "";
+  let model = "";
+  let branchedFrom;
+  let firstUserMessage = "";
+  let lastUserMessage = "";
+  let timestamp = "";
+  let lastTimestamp = "";
+  let turnCount = 0;
+  let previousPrompt = "";
+  for (const record of records) {
+    if (!isObject(record.payload)) continue;
+    if (record.type === "session_meta") {
+      sessionId ||= typeof record.payload.id === "string" ? record.payload.id : "";
+      version ||= typeof record.payload.cli_version === "string" ? record.payload.cli_version : "";
+      cwd ||= typeof record.payload.cwd === "string" ? record.payload.cwd : "";
+      if (!branchedFrom && isObject(record.payload.branchedFrom)) {
+        const sourceId = typeof record.payload.branchedFrom.sessionId === "string" ? record.payload.branchedFrom.sessionId : "";
+        if (sourceId) {
+          branchedFrom = {
+            sessionId: sourceId,
+            turnIndex: typeof record.payload.branchedFrom.turnIndex === "number" ? record.payload.branchedFrom.turnIndex : null
+          };
+        }
+      }
+      const git = isObject(record.payload.git) ? record.payload.git : null;
+      gitBranch ||= git && typeof git.branch === "string" ? git.branch : "";
+    }
+    if (record.type === "turn_context") {
+      model ||= typeof record.payload.model === "string" ? record.payload.model : "";
+      cwd ||= typeof record.payload.cwd === "string" ? record.payload.cwd : "";
+    }
+    const prompt = extractPromptFromRecord(record);
+    if (!prompt) continue;
+    if (prompt === previousPrompt) continue;
+    if (!firstUserMessage) firstUserMessage = prompt;
+    lastUserMessage = prompt;
+    previousPrompt = prompt;
+    turnCount++;
+    if (!timestamp) timestamp = record.timestamp ?? "";
+    lastTimestamp = record.timestamp ?? lastTimestamp;
+  }
+  if (lastTimestamp === "") lastTimestamp = timestamp;
+  return {
+    sessionId,
+    version,
+    gitBranch,
+    cwd,
+    model,
+    slug: "",
+    branchedFrom,
+    firstUserMessage,
+    lastUserMessage,
+    timestamp,
+    lastTimestamp,
+    turnCount
+  };
+}
+function isCodexSessionText(jsonlText) {
+  for (const line of jsonlText.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    return isCodexRecord(safeParseLine(trimmed));
+  }
+  return false;
+}
+function extractCodexMetadataFromLines(lines) {
+  const records = lines.map(safeParseLine).filter(isCodexRecord);
+  return extractMetadataFromRecords(records);
+}
+function parseCodexSession(jsonlText) {
+  const records = jsonlText.split("\n").map((line) => line.trim()).filter(Boolean).map(safeParseLine).filter(isCodexRecord);
+  const metadata = extractMetadataFromRecords(records);
+  const turns = [];
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  let current = null;
+  let currentTurnId = null;
+  let currentModel = metadata.model || null;
+  let lastTurnTimestamp = "";
+  for (const record of records) {
+    const payload = isObject(record.payload) ? record.payload : void 0;
+    const timestamp = record.timestamp ?? "";
+    if (record.type === "turn_context") {
+      current = finalizeTurn(turns, current, lastTurnTimestamp);
+      currentTurnId = typeof payload?.turn_id === "string" ? payload.turn_id : null;
+      currentModel = typeof payload?.model === "string" ? payload.model : currentModel;
+      lastTurnTimestamp = timestamp;
+      continue;
+    }
+    if (record.type === "event_msg" && payload?.type === "user_message" && typeof payload.message === "string") {
+      if (current && (current.assistantText.length > 0 || current.toolCalls.length > 0 || current.thinking.length > 0)) {
+        current = finalizeTurn(turns, current, lastTurnTimestamp);
+      }
+      current ??= createTurn(currentTurnId, timestamp, currentModel);
+      current.userMessage = payload.message;
+      current.timestamp = current.timestamp || timestamp;
+      lastTurnTimestamp = timestamp;
+      continue;
+    }
+    current ??= createTurn(currentTurnId, timestamp, currentModel);
+    if (!current.model && currentModel) current.model = currentModel;
+    if (!current.timestamp) current.timestamp = timestamp;
+    if (timestamp) lastTurnTimestamp = timestamp;
+    if (record.type === "event_msg" && payload?.type === "token_count") {
+      const info = isObject(payload.info) ? payload.info : null;
+      const lastUsage = info ? parseTokenUsage(info.last_token_usage) : null;
+      if (lastUsage) {
+        current.tokenUsage = mergeTokenUsage2(current.tokenUsage, lastUsage);
+      }
+      continue;
+    }
+    if (record.type !== "response_item" || !payload) continue;
+    if (payload.type === "reasoning") {
+      const summary = Array.isArray(payload.summary) ? payload.summary.filter((item) => typeof item === "string").join("\n") : "";
+      appendThinking(current, summary.trim(), timestamp);
+      continue;
+    }
+    if (payload.type === "message" && payload.role === "assistant") {
+      appendAssistantText(current, extractMessageText(payload, "output_text"), timestamp);
+      continue;
+    }
+    if (payload.type === "message" && payload.role === "user" && current.userMessage === null) {
+      const text = normalizePromptText(extractMessageText(payload, "input_text"));
+      if (text) current.userMessage = text;
+      continue;
+    }
+    if (payload.type === "function_call" && typeof payload.call_id === "string") {
+      const toolCall = {
+        id: payload.call_id,
+        name: typeof payload.name === "string" ? payload.name : "tool",
+        input: parseToolInput(payload.arguments),
+        result: null,
+        isError: false,
+        timestamp
+      };
+      pendingToolCalls.set(toolCall.id, toolCall);
+      appendToolCall(current, toolCall, timestamp);
+      continue;
+    }
+    if (payload.type === "function_call_output" && typeof payload.call_id === "string") {
+      const toolCall = pendingToolCalls.get(payload.call_id);
+      if (!toolCall) continue;
+      const output = typeof payload.output === "string" ? payload.output : null;
+      toolCall.result = output;
+      toolCall.isError = inferToolError(output);
+      pendingToolCalls.delete(payload.call_id);
+      continue;
+    }
+  }
+  finalizeTurn(turns, current, lastTurnTimestamp);
+  return {
+    sessionId: metadata.sessionId,
+    version: metadata.version,
+    gitBranch: metadata.gitBranch,
+    cwd: metadata.cwd,
+    slug: metadata.slug,
+    model: metadata.model,
+    turns,
+    stats: computeStats(turns),
+    rawMessages: records,
+    branchedFrom: metadata.branchedFrom,
+    agentKind: "codex"
+  };
+}
+
 // src/lib/parser.ts
 function isAssistantMessage2(msg) {
   return msg.type === "assistant";
@@ -631,16 +951,20 @@ function extractSessionMetadata(messages) {
   }
   return meta;
 }
-function parseSession(jsonlText) {
+function parseSession(jsonlText, opts) {
+  if (isCodexSessionText(jsonlText)) {
+    return parseCodexSession(jsonlText);
+  }
   const rawMessages = parseLines(jsonlText);
   const metadata = extractSessionMetadata(rawMessages);
   const turns = buildTurns(rawMessages);
-  const stats = computeStats(turns);
+  const stats = opts?.skipStats ? { totalInputTokens: 0, totalOutputTokens: 0, totalCacheCreationTokens: 0, totalCacheReadTokens: 0, totalCostUSD: 0, toolCallCounts: {}, errorCount: 0, totalDurationMs: 0, turnCount: turns.length } : computeStats(turns);
   return {
     ...metadata,
     turns,
     stats,
-    rawMessages
+    rawMessages: opts?.skipStats ? [] : rawMessages,
+    agentKind: "claude"
   };
 }
 function getUserMessageText(content) {
@@ -650,6 +974,10 @@ function getUserMessageText(content) {
 }
 
 // src/lib/search-index.ts
+var MAX_CONTENT_LEN = 4096;
+function truncContent(text) {
+  return text.length > MAX_CONTENT_LEN ? text.slice(0, MAX_CONTENT_LEN) : text;
+}
 var SearchIndex = class {
   db;
   dbPath;
@@ -683,7 +1011,7 @@ var SearchIndex = class {
         source_file,
         location,
         content,
-        tokenize = 'trigram'
+        tokenize = 'unicode61'
       )`);
     }
   }
@@ -710,6 +1038,60 @@ var SearchIndex = class {
       lastUpdate: this._lastUpdate
     };
   }
+  /**
+   * Insert all searchable content from a parsed session into the FTS5 index.
+   * Shared by both `indexFile` (single-file) and `buildFull` (batch).
+   */
+  insertSessionContent(insert, sessionId, filePath, session) {
+    for (let i = 0; i < session.turns.length; i++) {
+      const turn = session.turns[i];
+      const prefix = `turn/${i}`;
+      const userText = getUserMessageText(turn.userMessage);
+      if (userText.trim()) {
+        insert.run(sessionId, filePath, `${prefix}/userMessage`, truncContent(userText));
+      }
+      const assistantJoined = turn.assistantText.join("\n\n").trim();
+      if (assistantJoined) {
+        insert.run(sessionId, filePath, `${prefix}/assistantMessage`, truncContent(assistantJoined));
+      }
+      const thinkingText = turn.thinking.filter((t) => t.thinking && t.thinking.length > 0).map((t) => t.thinking).join("\n\n").trim();
+      if (thinkingText) {
+        insert.run(sessionId, filePath, `${prefix}/thinking`, truncContent(thinkingText));
+      }
+      for (const tc of turn.toolCalls) {
+        const inputStr = JSON.stringify(tc.input);
+        if (inputStr && inputStr !== "{}") {
+          insert.run(sessionId, filePath, `${prefix}/toolCall/${tc.id}/input`, truncContent(inputStr));
+        }
+        if (tc.result) {
+          insert.run(sessionId, filePath, `${prefix}/toolCall/${tc.id}/result`, truncContent(tc.result));
+        }
+      }
+      for (const sa of turn.subAgentActivity) {
+        const saPrefix = `agent/${sa.agentId}`;
+        const saText = sa.text.join("\n\n").trim();
+        if (saText) {
+          insert.run(sessionId, filePath, `${saPrefix}/assistantMessage`, truncContent(saText));
+        }
+        const saThinking = sa.thinking.filter((t) => t.length > 0).join("\n\n").trim();
+        if (saThinking) {
+          insert.run(sessionId, filePath, `${saPrefix}/thinking`, truncContent(saThinking));
+        }
+        for (const tc of sa.toolCalls) {
+          const inputStr = JSON.stringify(tc.input);
+          if (inputStr && inputStr !== "{}") {
+            insert.run(sessionId, filePath, `${saPrefix}/toolCall/${tc.id}/input`, truncContent(inputStr));
+          }
+          if (tc.result) {
+            insert.run(sessionId, filePath, `${saPrefix}/toolCall/${tc.id}/result`, truncContent(tc.result));
+          }
+        }
+      }
+      if (turn.compactionSummary) {
+        insert.run(sessionId, filePath, `${prefix}/compactionSummary`, truncContent(turn.compactionSummary));
+      }
+    }
+  }
   /**
    * Parse a JSONL file and insert all searchable content into the FTS5 index.
    * Idempotent: deletes old data for the file before re-indexing.
@@ -723,7 +1105,7 @@ var SearchIndex = class {
       mtimeMs = (0, import_node_fs.statSync)(filePath).mtimeMs;
     }
     const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
-    const session = parseSession(content);
+    const session = parseSession(content, { skipStats: true });
     const isSubagent = opts?.isSubagent ? 1 : 0;
     const parentSessionId = opts?.parentSessionId ?? null;
     const insert = this.db.prepare(
@@ -741,54 +1123,7 @@ var SearchIndex = class {
     const txn = this.db.transaction(() => {
       deleteContent.run(filePath);
       deleteFile.run(filePath);
-      for (let i = 0; i < session.turns.length; i++) {
-        const turn = session.turns[i];
-        const prefix = `turn/${i}`;
-        const userText = getUserMessageText(turn.userMessage);
-        if (userText.trim()) {
-          insert.run(sessionId, filePath, `${prefix}/userMessage`, userText);
-        }
-        const assistantJoined = turn.assistantText.join("\n\n").trim();
-        if (assistantJoined) {
-          insert.run(sessionId, filePath, `${prefix}/assistantMessage`, assistantJoined);
-        }
-        const thinkingText = turn.thinking.filter((t) => t.thinking && t.thinking.length > 0).map((t) => t.thinking).join("\n\n").trim();
-        if (thinkingText) {
-          insert.run(sessionId, filePath, `${prefix}/thinking`, thinkingText);
-        }
-        for (const tc of turn.toolCalls) {
-          const inputStr = JSON.stringify(tc.input);
-          if (inputStr && inputStr !== "{}") {
-            insert.run(sessionId, filePath, `${prefix}/toolCall/${tc.id}/input`, inputStr);
-          }
-          if (tc.result) {
-            insert.run(sessionId, filePath, `${prefix}/toolCall/${tc.id}/result`, tc.result);
-          }
-        }
-        for (const sa of turn.subAgentActivity) {
-          const saPrefix = `agent/${sa.agentId}`;
-          const saText = sa.text.join("\n\n").trim();
-          if (saText) {
-            insert.run(sessionId, filePath, `${saPrefix}/assistantMessage`, saText);
-          }
-          const saThinking = sa.thinking.filter((t) => t.length > 0).join("\n\n").trim();
-          if (saThinking) {
-            insert.run(sessionId, filePath, `${saPrefix}/thinking`, saThinking);
-          }
-          for (const tc of sa.toolCalls) {
-            const inputStr = JSON.stringify(tc.input);
-            if (inputStr && inputStr !== "{}") {
-              insert.run(sessionId, filePath, `${saPrefix}/toolCall/${tc.id}/input`, inputStr);
-            }
-            if (tc.result) {
-              insert.run(sessionId, filePath, `${saPrefix}/toolCall/${tc.id}/result`, tc.result);
-            }
-          }
-        }
-        if (turn.compactionSummary) {
-          insert.run(sessionId, filePath, `${prefix}/compactionSummary`, turn.compactionSummary);
-        }
-      }
+      this.insertSessionContent(insert, sessionId, filePath, session);
       insertFile.run(filePath, mtimeMs, sessionId, isSubagent, parentSessionId);
     });
     txn();
@@ -839,7 +1174,7 @@ var SearchIndex = class {
       location: row.location,
       snippet: row.snippet,
       matchCount: 1
-      // FTS5 trigram doesn't expose per-row match count; 1 = "at least one match"
+      // FTS5 doesn't expose per-row match count; 1 = "at least one match"
     }));
     if (caseSensitive) {
       hits = hits.filter((h) => h.snippet.includes(query));
@@ -878,19 +1213,67 @@ var SearchIndex = class {
    * Structure: projectsDir/{projectName}/{sessionId}.jsonl
    * Subagents:  projectsDir/{projectName}/{sessionId}/subagents/agent-{id}.jsonl
    *
+   * Optimized: discovers all files first, then processes them in a single
+   * SQLite transaction with pre-prepared statements. This avoids the overhead
+   * of 3000+ individual transactions (each forcing a disk sync).
+   *
    * Stores `projectsDir` as a class field so `rebuild()` can reuse it.
    */
   buildFull(projectsDir) {
     this.projectsDir = projectsDir;
-    this.db.exec("DELETE FROM search_content");
-    this.db.exec("DELETE FROM indexed_files");
-    this.indexProjectsDir(projectsDir);
+    this.db.close();
+    try {
+      (0, import_node_fs.unlinkSync)(this.dbPath);
+    } catch {
+    }
+    try {
+      (0, import_node_fs.unlinkSync)(this.dbPath + "-wal");
+    } catch {
+    }
+    try {
+      (0, import_node_fs.unlinkSync)(this.dbPath + "-shm");
+    } catch {
+    }
+    this.db = new Database(this.dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA synchronous = OFF");
+    this.db.exec("PRAGMA cache_size = -64000");
+    this.db.exec("PRAGMA temp_store = MEMORY");
+    this.db.exec("PRAGMA mmap_size = 268435456");
+    this.initSchema();
+    const files = [];
+    this.discoverFiles(projectsDir, (filePath, sessionId, mtimeMs, isSubagent, parentSessionId) => {
+      files.push({ path: filePath, sessionId, mtimeMs, isSubagent, parentSessionId });
+    });
+    const insert = this.db.prepare(
+      "INSERT INTO search_content (session_id, source_file, location, content) VALUES (?, ?, ?, ?)"
+    );
+    const insertFile = this.db.prepare(
+      "INSERT OR REPLACE INTO indexed_files (file_path, mtime_ms, session_id, is_subagent, parent_session_id) VALUES (?, ?, ?, ?, ?)"
+    );
+    const txn = this.db.transaction(() => {
+      for (const file of files) {
+        try {
+          const content = (0, import_node_fs.readFileSync)(file.path, "utf-8");
+          const session = parseSession(content, { skipStats: true });
+          this.insertSessionContent(insert, file.sessionId, file.path, session);
+          insertFile.run(file.path, file.mtimeMs, file.sessionId, file.isSubagent ? 1 : 0, file.parentSessionId);
+        } catch {
+        }
+      }
+    });
+    txn();
+    this.db.exec("PRAGMA synchronous = NORMAL");
     this._lastFullBuild = (/* @__PURE__ */ new Date()).toISOString();
     this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
   }
   /**
    * Incrementally re-index only files whose mtime has changed since last index.
    * New files (not in indexed_files) are always indexed.
+   *
+   * WARNING: This walks ALL files under projectsDir and stats each one.
+   * On large session stores (3000+ files) this can take minutes.
+   * Prefer `updateRecent()` for CLI search paths.
    */
   updateStale(projectsDir) {
     this.projectsDir = projectsDir;
@@ -917,6 +1300,45 @@ var SearchIndex = class {
       this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
     }
   }
+  /**
+   * Lightweight incremental update for CLI search paths.
+   *
+   * Instead of stat-ing every file, only discovers files modified after the
+   * most recent mtime in the index. Caps re-indexing to `maxFiles` to prevent
+   * blocking on large backlogs (run `index rebuild` for a full catch-up).
+   */
+  updateRecent(projectsDir, maxFiles = 50) {
+    this.projectsDir = projectsDir;
+    const row = this.db.prepare(
+      "SELECT MAX(mtime_ms) as max_mtime FROM indexed_files"
+    ).get();
+    const highWater = row?.max_mtime ?? 0;
+    const getIndexed = this.db.prepare(
+      "SELECT mtime_ms FROM indexed_files WHERE file_path = ?"
+    );
+    const filesToIndex = [];
+    this.discoverFiles(projectsDir, (filePath, sessionId, mtimeMs, isSubagent, parentSessionId) => {
+      if (mtimeMs <= highWater) {
+        const existing = getIndexed.get(filePath);
+        if (existing && existing.mtime_ms >= mtimeMs) return;
+      }
+      filesToIndex.push({ path: filePath, sessionId, mtimeMs, isSubagent, parentSessionId });
+    });
+    filesToIndex.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const batch = filesToIndex.slice(0, maxFiles);
+    for (const file of batch) {
+      try {
+        this.indexFile(file.path, file.sessionId, file.mtimeMs, {
+          isSubagent: file.isSubagent,
+          parentSessionId: file.parentSessionId
+        });
+      } catch {
+      }
+    }
+    if (batch.length > 0) {
+      this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
   /**
    * Re-run buildFull using the previously stored projectsDir.
    * No-op if projectsDir was never set.
@@ -925,18 +1347,6 @@ var SearchIndex = class {
     if (!this.projectsDir) return;
     this.buildFull(this.projectsDir);
   }
-  /**
-   * Walk all project directories under `projectsDir` and index every discovered
-   * JSONL file (both sessions and subagents).
-   */
-  indexProjectsDir(projectsDir) {
-    this.discoverFiles(projectsDir, (filePath, sessionId, mtimeMs, isSubagent, parentSessionId) => {
-      try {
-        this.indexFile(filePath, sessionId, mtimeMs, { isSubagent, parentSessionId });
-      } catch {
-      }
-    });
-  }
   /**
    * Walk the projects directory tree and invoke `callback` for every JSONL file.
    *
@@ -952,29 +1362,23 @@ var SearchIndex = class {
   discoverFiles(projectsDir, callback) {
     let entries;
     try {
-      entries = (0, import_node_fs.readdirSync)(projectsDir);
+      entries = (0, import_node_fs.readdirSync)(projectsDir, { withFileTypes: true });
     } catch {
       return;
     }
-    for (const projectName of entries) {
-      if (projectName === "memory") continue;
-      const projectDir = (0, import_node_path.join)(projectsDir, projectName);
-      try {
-        const s = (0, import_node_fs.statSync)(projectDir);
-        if (!s.isDirectory()) continue;
-      } catch {
-        continue;
-      }
+    for (const entry of entries) {
+      if (entry.name === "memory" || !entry.isDirectory()) continue;
+      const projectDir = (0, import_node_path.join)(projectsDir, entry.name);
       let files;
       try {
-        files = (0, import_node_fs.readdirSync)(projectDir);
+        files = (0, import_node_fs.readdirSync)(projectDir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const file of files) {
-        if (!file.endsWith(".jsonl")) continue;
-        const filePath = (0, import_node_path.join)(projectDir, file);
-        const sessionId = (0, import_node_path.basename)(file, ".jsonl");
+        if (!file.name.endsWith(".jsonl") || !file.isFile()) continue;
+        const filePath = (0, import_node_path.join)(projectDir, file.name);
+        const sessionId = (0, import_node_path.basename)(file.name, ".jsonl");
         try {
           const s = (0, import_node_fs.statSync)(filePath);
           callback(filePath, sessionId, s.mtimeMs, false, null);
@@ -1143,6 +1547,29 @@ async function findJsonlPath(sessionId) {
     }
   } catch {
   }
+  const codexRoot = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".codex", "sessions");
+  const walk = async (dir, depth) => {
+    if (depth > 4) return null;
+    let entries;
+    try {
+      entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      const filePath = (0, import_node_path3.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        const match = await walk(filePath, depth + 1);
+        if (match) return match;
+        continue;
+      }
+      if (!entry.name.endsWith(".jsonl")) continue;
+      if (entry.name.endsWith(`${sessionId}.jsonl`)) return filePath;
+    }
+    return null;
+  };
+  const codexMatch = await walk(codexRoot, 0);
+  if (codexMatch) return codexMatch;
   return null;
 }
 async function matchSubagentToMember(leadSessionId, subagentFileName, members) {
@@ -1197,10 +1624,19 @@ async function searchSessions(query, opts, searchIndex) {
   const depth = Math.min(Math.max(1, opts.depth ?? 4), 4);
   let index = searchIndex ?? null;
   let ownedIndex = false;
-  if (!index && (0, import_node_fs2.existsSync)(DEFAULT_DB_PATH)) {
+  if (!index && searchIndex === void 0) {
     try {
+      const dbExists = (0, import_node_fs2.existsSync)(DEFAULT_DB_PATH);
+      if (!dbExists) {
+        (0, import_node_fs2.mkdirSync)((0, import_node_path4.dirname)(DEFAULT_DB_PATH), { recursive: true });
+      }
       index = new SearchIndex(DEFAULT_DB_PATH);
       ownedIndex = true;
+      if (!dbExists) {
+        index.buildFull(dirs.PROJECTS_DIR);
+      } else {
+        index.updateRecent(dirs.PROJECTS_DIR);
+      }
     } catch {
     }
   }
@@ -1274,6 +1710,14 @@ async function cwdFromFilePath(filePath) {
             cwdCache.set(filePath, obj.cwd);
             return obj.cwd;
           }
+          if (obj.type === "session_meta" && obj.payload?.cwd) {
+            cwdCache.set(filePath, obj.payload.cwd);
+            return obj.payload.cwd;
+          }
+          if (obj.type === "turn_context" && obj.payload?.cwd) {
+            cwdCache.set(filePath, obj.payload.cwd);
+            return obj.payload.cwd;
+          }
         } catch {
         }
       }
@@ -1782,12 +2226,17 @@ async function getAgentTurnDetail(sessionId, agentId, turnIndex) {
 // src/commands/sessions.ts
 var import_promises5 = require("node:fs/promises");
 var import_node_path6 = require("node:path");
+var import_node_os3 = require("node:os");
 
 // src/lib/metadata.ts
 var import_promises4 = require("node:fs/promises");
 
 // src/lib/sessionStatus.ts
 function deriveSessionStatus(rawMessages) {
+  const firstType = rawMessages[0]?.type;
+  if (firstType === "session_meta" || firstType === "turn_context" || firstType === "event_msg" || firstType === "response_item") {
+    return deriveCodexSessionStatus(rawMessages);
+  }
   let pendingEnqueues = 0;
   function result(status, toolName) {
     const info = { status, pendingQueue: Math.max(0, pendingEnqueues) };
@@ -1828,7 +2277,38 @@ function deriveSessionStatus(rawMessages) {
       if (isMeta) continue;
       return result("processing");
     }
-    if (msg.type === "summary") return result("compacting");
+    if (msg.type === "summary") continue;
+    if (msg.type === "system" && msg.subtype === "compact_boundary") continue;
+  }
+  return { status: "idle" };
+}
+function deriveCodexSessionStatus(rawMessages) {
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const msg = rawMessages[i];
+    if (msg.type === "event_msg") {
+      const payload = msg.payload;
+      switch (payload?.type) {
+        case "task_complete":
+          return { status: "completed" };
+        case "task_started":
+          return { status: "processing" };
+        case "agent_message":
+          return { status: "thinking" };
+        case "token_count":
+          continue;
+      }
+    }
+    if (msg.type === "response_item") {
+      const payload = msg.payload;
+      if (!payload) continue;
+      if (payload.type === "function_call") {
+        return { status: "tool_use", toolName: payload.name };
+      }
+      if (payload.type === "message") {
+        if (payload.role === "assistant") return { status: "thinking" };
+        if (payload.role === "user") return { status: "processing" };
+      }
+    }
   }
   return { status: "idle" };
 }
@@ -1854,6 +2334,36 @@ async function getSessionMeta(filePath) {
     const content = await (0, import_promises4.readFile)(filePath, "utf-8");
     lines = content.split("\n").filter(Boolean);
   }
+  let firstParsed = null;
+  if (lines.length > 0) {
+    try {
+      firstParsed = JSON.parse(lines[0]);
+    } catch {
+      firstParsed = null;
+    }
+  }
+  const isCodex = firstParsed?.type === "session_meta" || firstParsed?.type === "turn_context";
+  if (isCodex) {
+    if (isPartialRead) {
+      const content = await (0, import_promises4.readFile)(filePath, "utf-8");
+      lines = content.split("\n").filter(Boolean);
+    }
+    const meta = extractCodexMetadataFromLines(lines);
+    return {
+      sessionId: meta.sessionId,
+      version: meta.version,
+      gitBranch: meta.gitBranch,
+      model: meta.model,
+      slug: meta.slug,
+      cwd: meta.cwd,
+      firstUserMessage: meta.firstUserMessage,
+      lastUserMessage: meta.lastUserMessage,
+      timestamp: meta.timestamp,
+      turnCount: meta.turnCount,
+      lineCount: lines.length,
+      branchedFrom: meta.branchedFrom
+    };
+  }
   let sessionId = "";
   let version = "";
   let gitBranch = "";
@@ -1950,6 +2460,30 @@ async function getSessionStatus(filePath) {
           } catch {
             continue;
           }
+          if (obj.type === "event_msg") {
+            const payload = obj.payload;
+            switch (payload?.type) {
+              case "task_complete":
+                return { status: "completed" };
+              case "task_started":
+                return { status: "processing" };
+              case "agent_message":
+                return { status: "thinking" };
+              case "token_count":
+                continue;
+            }
+          }
+          if (obj.type === "response_item") {
+            const payload = obj.payload;
+            if (payload?.type === "function_call") {
+              return { status: "tool_use", toolName: payload.name };
+            }
+            if (payload?.type === "message") {
+              const role = payload.role;
+              if (role === "assistant") return { status: "thinking" };
+              if (role === "user") return { status: "processing" };
+            }
+          }
           if (obj.type === "assistant" || obj.type === "user" || obj.type === "queue-operation") {
             meaningful.unshift(obj);
             const isEndTurn = obj.type === "assistant" && obj.message?.stop_reason === "end_turn";
@@ -1968,6 +2502,35 @@ async function getSessionStatus(filePath) {
 }
 
 // src/commands/sessions.ts
+var CODEX_SESSIONS_DIR = (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".codex", "sessions");
+async function listCodexSessionFiles(cutoff) {
+  const walk = async (dir, depth) => {
+    if (depth > 4) return [];
+    let entries;
+    try {
+      entries = await (0, import_promises5.readdir)(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+      const filePath = (0, import_node_path6.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await walk(filePath, depth + 1));
+        continue;
+      }
+      if (!entry.name.endsWith(".jsonl")) continue;
+      try {
+        const s = await (0, import_promises5.stat)(filePath);
+        if (s.mtimeMs >= cutoff) results.push({ path: filePath, mtimeMs: s.mtimeMs });
+      } catch {
+        continue;
+      }
+    }
+    return results;
+  };
+  return walk(CODEX_SESSIONS_DIR, 0);
+}
 async function listSessions(opts = {}) {
   const limit = Math.min(Math.max(1, opts.limit ?? 20), 100);
   const maxAgeMs = parseMaxAge(opts.maxAge ?? "7d");
@@ -2001,7 +2564,8 @@ async function listSessions(opts = {}) {
       }
     })
   );
-  const allFiles = nested.flat();
+  const codexFiles = await listCodexSessionFiles(cutoff);
+  const allFiles = [...nested.flat(), ...codexFiles];
   allFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
   const results = [];
   for (const file of allFiles) {
@@ -2024,7 +2588,8 @@ async function listSessions(opts = {}) {
         lastMessage: meta.lastUserMessage,
         turnCount: meta.turnCount,
         status: statusInfo.status,
-        mtime: file.mtimeMs
+        mtime: file.mtimeMs,
+        source: file.path.startsWith(CODEX_SESSIONS_DIR + "/") ? "codex" : "claude"
       });
     } catch {
     }
@@ -2038,10 +2603,9 @@ async function currentSession(cwd) {
   try {
     files = await (0, import_promises5.readdir)(projectDir);
   } catch {
-    return null;
+    files = [];
   }
   const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-  if (jsonlFiles.length === 0) return null;
   const statResults = await Promise.all(
     jsonlFiles.map(async (f) => {
       const filePath = (0, import_node_path6.join)(projectDir, f);
@@ -2053,7 +2617,21 @@ async function currentSession(cwd) {
       }
     })
   );
-  const valid = statResults.filter((r) => r !== null);
+  const codexCandidates = await listCodexSessionFiles(0);
+  const codexMatches = [];
+  for (const file of codexCandidates) {
+    try {
+      const meta2 = await getSessionMeta(file.path);
+      if (meta2.cwd === cwd) codexMatches.push(file);
+    } catch {
+      continue;
+    }
+  }
+  const valid = [
+    ...statResults.filter((r) => r !== null),
+    ...codexMatches
+  ];
+  if (valid.length === 0) return null;
   valid.sort((a, b) => b.mtimeMs - a.mtimeMs);
   const latest = valid[0];
   if (!latest) return null;
@@ -2073,7 +2651,8 @@ async function currentSession(cwd) {
     lastMessage: meta.lastUserMessage,
     turnCount: meta.turnCount,
     status: statusInfo.status,
-    mtime: latest.mtimeMs
+    mtime: latest.mtimeMs,
+    source: latest.path.startsWith(CODEX_SESSIONS_DIR + "/") ? "codex" : "claude"
   };
 }