cogpit-memory 0.1.4 → 0.1.7

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";
@@ -632,6 +952,9 @@ function extractSessionMetadata(messages) {
   return meta;
 }
 function parseSession(jsonlText) {
+  if (isCodexSessionText(jsonlText)) {
+    return parseCodexSession(jsonlText);
+  }
   const rawMessages = parseLines(jsonlText);
   const metadata = extractSessionMetadata(rawMessages);
   const turns = buildTurns(rawMessages);
@@ -640,7 +963,8 @@ function parseSession(jsonlText) {
     ...metadata,
     turns,
     stats,
-    rawMessages
+    rawMessages,
+    agentKind: "claude"
   };
 }
 function getUserMessageText(content) {
@@ -1143,6 +1467,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) {
@@ -1201,6 +1548,7 @@ async function searchSessions(query, opts, searchIndex) {
     try {
       index = new SearchIndex(DEFAULT_DB_PATH);
       ownedIndex = true;
+      index.updateStale(dirs.PROJECTS_DIR);
     } catch {
     }
   }
@@ -1274,6 +1622,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 {
         }
       }
@@ -1503,7 +1859,7 @@ async function rawScanSearch(query, sessionId, maxAgeMs, limit, caseSensitive, d
       sessionsSearched,
       results
     };
-  } catch (err) {
+  } catch {
     return {
       query,
       totalHits: 0,
@@ -1782,12 +2138,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 +2189,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 +2246,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 +2372,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 +2414,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 +2476,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 +2500,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 +2515,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 +2529,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 +2563,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"
   };
 }
 
@@ -2155,6 +2646,12 @@ function parseArgs(argv) {
           case "--limit":
             args.limit = parseInt(argv[++i], 10);
             break;
+          case "--session-limit":
+            args.sessionLimit = parseInt(argv[++i], 10);
+            break;
+          case "--hits-per-session":
+            args.hitsPerSession = parseInt(argv[++i], 10);
+            break;
           case "--case-sensitive":
             args.caseSensitive = true;
             break;
@@ -2236,6 +2733,15 @@ async function main() {
         limit: cmd.args.limit,
         caseSensitive: cmd.args.caseSensitive
       });
+      if (result && !("error" in result) && (cmd.args.sessionLimit || cmd.args.hitsPerSession)) {
+        const sl = cmd.args.sessionLimit ?? result.results.length;
+        const hpp = cmd.args.hitsPerSession ?? Infinity;
+        result.results = result.results.slice(0, sl).map((sr) => ({
+          ...sr,
+          hits: sr.hits.slice(0, hpp)
+        }));
+        result.returnedHits = result.results.reduce((n, sr) => n + sr.hits.length, 0);
+      }
       break;
     case "context":
       if (!cmd.args.sessionId) {
@@ -2288,6 +2794,8 @@ Commands:
     --session <id>            Scope to single session
     --max-age <5d>            Time window (default: 5d)
     --limit <20>              Max hits (default: 20)
+    --session-limit <N>       Cap unique sessions returned
+    --hits-per-session <N>    Max hits kept per session
     --case-sensitive          Case sensitive matching
 
   context <sessionId>         Session overview (L1)