cogpit-memory 0.1.0

package/dist/index.js

@@ -0,0 +1,2175 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_DB_PATH: () => DEFAULT_DB_PATH,
+  SearchIndex: () => SearchIndex,
+  currentSession: () => currentSession,
+  dirs: () => dirs,
+  getAgentOverview: () => getAgentOverview,
+  getAgentTurnDetail: () => getAgentTurnDetail,
+  getSessionOverview: () => getSessionOverview,
+  getTurnDetail: () => getTurnDetail,
+  getUserMessageImages: () => getUserMessageImages,
+  getUserMessageText: () => getUserMessageText,
+  indexRebuild: () => indexRebuild,
+  indexStats: () => indexStats,
+  listSessions: () => listSessions,
+  parseSession: () => parseSession,
+  parseSessionAppend: () => parseSessionAppend,
+  searchSessions: () => searchSessions
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/sqlite-node-shim.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var Database = import_better_sqlite3.default;
+
+// src/lib/search-index.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// src/lib/turnBuilder.ts
+function isUserMessage(msg) {
+  return msg.type === "user";
+}
+function isAssistantMessage(msg) {
+  return msg.type === "assistant";
+}
+function isProgressMessage(msg) {
+  return msg.type === "progress";
+}
+function isSystemMessage(msg) {
+  return msg.type === "system";
+}
+function isSummaryMessage(msg) {
+  return msg.type === "summary";
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function extractToolResultText(content) {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  return content.map((b) => {
+    if (b.type === "text") return b.text;
+    return "";
+  }).filter(Boolean).join("\n");
+}
+function mergeTokenUsage(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 buildCompactionSummary(turns, title) {
+  if (turns.length === 0) return title;
+  const toolCounts = {};
+  for (const turn of turns) {
+    for (const tc of turn.toolCalls) {
+      toolCounts[tc.name] = (toolCounts[tc.name] || 0) + 1;
+    }
+  }
+  const prompts = [];
+  for (const turn of turns) {
+    if (!turn.userMessage) continue;
+    const text = extractTextFromContent(
+      typeof turn.userMessage === "string" ? turn.userMessage : turn.userMessage
+    );
+    const firstLine = text.split("\n")[0].trim();
+    if (firstLine.length > 0) {
+      prompts.push(firstLine.length > 120 ? firstLine.slice(0, 117) + "..." : firstLine);
+    }
+  }
+  const topTools = Object.entries(toolCounts).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name, count]) => `${name} x${count}`).join(", ");
+  const parts = [`**${title}**`, `${turns.length} turns compacted`];
+  if (topTools) parts.push(`Tools: ${topTools}`);
+  if (prompts.length > 0) {
+    parts.push("Prompts:");
+    const shown = prompts.slice(0, 6);
+    for (const p of shown) parts.push(`- ${p}`);
+    if (prompts.length > 6) parts.push(`- ...and ${prompts.length - 6} more`);
+  }
+  return parts.join("\n");
+}
+function buildTurns(messages) {
+  const turns = [];
+  let current = null;
+  let pendingCompaction = null;
+  const pendingToolUses = /* @__PURE__ */ new Map();
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const subAgentMap = /* @__PURE__ */ new Map();
+  const agentBlockMap = /* @__PURE__ */ new Map();
+  const backgroundAgentParentIds = /* @__PURE__ */ new Set();
+  const taskMetaMap = /* @__PURE__ */ new Map();
+  function flushSubAgentMessages(parentId) {
+    if (!current) return;
+    const agentMsgs = subAgentMap.get(parentId);
+    if (!agentMsgs || agentMsgs.length === 0) return;
+    current.subAgentActivity.push(...agentMsgs);
+    subAgentMap.delete(parentId);
+    const kind = backgroundAgentParentIds.has(parentId) ? "background_agent" : "sub_agent";
+    const existingBlock = agentBlockMap.get(parentId);
+    if (existingBlock) {
+      existingBlock.messages.push(...agentMsgs);
+    } else {
+      const block = { kind, messages: [...agentMsgs] };
+      current.contentBlocks.push(block);
+      agentBlockMap.set(parentId, block);
+    }
+  }
+  function finalizeTurn() {
+    if (!current) return;
+    for (const tc of current.toolCalls) {
+      flushSubAgentMessages(tc.id);
+    }
+    for (const [parentId] of subAgentMap) {
+      flushSubAgentMessages(parentId);
+    }
+    turns.push(current);
+    current = null;
+    agentBlockMap.clear();
+  }
+  for (const msg of messages) {
+    if (isSummaryMessage(msg)) {
+      finalizeTurn();
+      pendingCompaction = buildCompactionSummary(
+        turns,
+        msg.summary ?? "Conversation compacted"
+      );
+      continue;
+    }
+    if (isUserMessage(msg) && !msg.isMeta) {
+      const content = msg.message.content;
+      if (typeof content !== "string" && Array.isArray(content)) {
+        const hasToolResult = content.some((b) => b.type === "tool_result");
+        if (hasToolResult && current) {
+          for (const block of content) {
+            if (block.type === "tool_result") {
+              const pending = pendingToolUses.get(block.tool_use_id);
+              if (pending) {
+                pending.turn.toolCalls[pending.index].result = extractToolResultText(block.content);
+                pending.turn.toolCalls[pending.index].isError = block.is_error;
+                pendingToolUses.delete(block.tool_use_id);
+              }
+            }
+          }
+          const toolUseResult = msg.toolUseResult;
+          if (toolUseResult?.agentId) {
+            const toolUseId = content.find((b) => b.type === "tool_result")?.tool_use_id ?? "";
+            const taskMeta = taskMetaMap.get(toolUseId);
+            const isBackground = backgroundAgentParentIds.has(toolUseId);
+            const resultText = [];
+            if (Array.isArray(toolUseResult.content)) {
+              for (const block of toolUseResult.content) {
+                if (block.type === "text") resultText.push(block.text);
+              }
+            }
+            const agentMsg = {
+              agentId: toolUseResult.agentId,
+              agentName: taskMeta?.name ?? null,
+              subagentType: taskMeta?.subagentType ?? null,
+              type: "assistant",
+              content: toolUseResult.content,
+              toolCalls: [],
+              thinking: [],
+              text: resultText,
+              timestamp: msg.timestamp ?? "",
+              tokenUsage: toolUseResult.usage ? {
+                input_tokens: toolUseResult.usage.input_tokens ?? 0,
+                output_tokens: toolUseResult.usage.output_tokens ?? 0,
+                cache_creation_input_tokens: toolUseResult.usage.cache_creation_input_tokens ?? 0,
+                cache_read_input_tokens: toolUseResult.usage.cache_read_input_tokens ?? 0
+              } : null,
+              model: null,
+              isBackground,
+              prompt: toolUseResult.prompt,
+              status: toolUseResult.status,
+              durationMs: toolUseResult.totalDurationMs,
+              toolUseCount: toolUseResult.totalToolUseCount
+            };
+            const existingBlock = agentBlockMap.get(toolUseId);
+            if (!existingBlock) {
+              current.subAgentActivity.push(agentMsg);
+              const kind = isBackground ? "background_agent" : "sub_agent";
+              const block = { kind, messages: [agentMsg] };
+              current.contentBlocks.push(block);
+              agentBlockMap.set(toolUseId, block);
+            }
+          }
+          continue;
+        }
+      }
+      finalizeTurn();
+      current = {
+        id: msg.uuid ?? crypto.randomUUID(),
+        userMessage: msg.message.content,
+        contentBlocks: [],
+        thinking: [],
+        assistantText: [],
+        toolCalls: [],
+        subAgentActivity: [],
+        timestamp: msg.timestamp ?? "",
+        durationMs: null,
+        tokenUsage: null,
+        model: null
+      };
+      if (pendingCompaction) {
+        current.compactionSummary = pendingCompaction;
+        pendingCompaction = null;
+      }
+      continue;
+    }
+    if (isAssistantMessage(msg)) {
+      let flushToolCalls2 = function() {
+        if (msgToolCalls.length > 0) {
+          activeTurn.contentBlocks.push({ kind: "tool_calls", toolCalls: [...msgToolCalls], timestamp: msgTs });
+          msgToolCalls.length = 0;
+        }
+      }, flushThinking2 = function() {
+        if (msgThinking.length > 0) {
+          const last = activeTurn.contentBlocks[activeTurn.contentBlocks.length - 1];
+          if (last && last.kind === "thinking") {
+            last.blocks.push(...msgThinking);
+          } else {
+            activeTurn.contentBlocks.push({ kind: "thinking", blocks: [...msgThinking], timestamp: msgTs });
+          }
+          msgThinking.length = 0;
+        }
+      };
+      var flushToolCalls = flushToolCalls2, flushThinking = flushThinking2;
+      if (!current) {
+        current = {
+          id: msg.uuid ?? crypto.randomUUID(),
+          userMessage: null,
+          contentBlocks: [],
+          thinking: [],
+          assistantText: [],
+          toolCalls: [],
+          subAgentActivity: [],
+          timestamp: msg.timestamp ?? "",
+          durationMs: null,
+          tokenUsage: null,
+          model: null
+        };
+      }
+      current.model = msg.message.model;
+      const msgId = msg.message.id;
+      if (!seenMessageIds.has(msgId)) {
+        seenMessageIds.add(msgId);
+        current.tokenUsage = mergeTokenUsage(current.tokenUsage, msg.message.usage);
+      }
+      const msgTs = msg.timestamp ?? "";
+      const msgThinking = [];
+      const msgToolCalls = [];
+      const activeTurn = current;
+      for (const block of msg.message.content) {
+        if (block.type === "thinking") {
+          flushToolCalls2();
+          const tb = block;
+          current.thinking.push(tb);
+          msgThinking.push(tb);
+        } else if (block.type === "text") {
+          flushToolCalls2();
+          flushThinking2();
+          const thinkingRegex = /<thinking>([\s\S]*?)<\/thinking>/g;
+          let remaining = block.text;
+          let match;
+          while ((match = thinkingRegex.exec(block.text)) !== null) {
+            const thinkingText = match[1].trim();
+            if (thinkingText) {
+              const tb = { type: "thinking", thinking: thinkingText, signature: "" };
+              current.thinking.push(tb);
+              current.contentBlocks.push({ kind: "thinking", blocks: [tb], timestamp: msgTs });
+            }
+            remaining = remaining.replace(match[0], "");
+          }
+          remaining = remaining.trim();
+          if (remaining) {
+            current.assistantText.push(remaining);
+            const last = current.contentBlocks[current.contentBlocks.length - 1];
+            if (last && last.kind === "text") {
+              last.text.push(remaining);
+            } else {
+              current.contentBlocks.push({ kind: "text", text: [remaining], timestamp: msgTs });
+            }
+          }
+        } else if (block.type === "tool_use") {
+          flushThinking2();
+          const tc = {
+            id: block.id,
+            name: block.name,
+            input: block.input,
+            result: null,
+            isError: false,
+            timestamp: msg.timestamp ?? ""
+          };
+          const idx = current.toolCalls.length;
+          current.toolCalls.push(tc);
+          msgToolCalls.push(tc);
+          pendingToolUses.set(block.id, { turn: current, index: idx });
+          if (block.name === "Task" || block.name === "Agent") {
+            const input = block.input;
+            if (input.run_in_background === true) {
+              backgroundAgentParentIds.add(block.id);
+            }
+            taskMetaMap.set(block.id, {
+              name: input.name ?? null,
+              subagentType: input.subagent_type ?? null
+            });
+          }
+        }
+      }
+      flushThinking2();
+      flushToolCalls2();
+      continue;
+    }
+    if (isProgressMessage(msg) && msg.data.type === "agent_progress") {
+      const data = msg.data;
+      const parentId = msg.parentToolUseID ?? "";
+      let subAgentUsage = null;
+      if (data.message.type === "assistant") {
+        const innerMsg = data.message.message;
+        const msgId = innerMsg.id;
+        const usage = innerMsg.usage;
+        if (usage && msgId && !seenMessageIds.has(msgId)) {
+          seenMessageIds.add(msgId);
+          subAgentUsage = {
+            input_tokens: usage.input_tokens ?? 0,
+            output_tokens: usage.output_tokens ?? 0,
+            cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0,
+            cache_read_input_tokens: usage.cache_read_input_tokens ?? 0
+          };
+        }
+      }
+      const innerModel = data.message.type === "assistant" ? data.message.message.model ?? null : null;
+      const taskMeta = taskMetaMap.get(parentId);
+      const agentMsg = {
+        agentId: data.agentId,
+        agentName: taskMeta?.name ?? null,
+        subagentType: taskMeta?.subagentType ?? null,
+        type: data.message.type,
+        content: data.message.message.content,
+        toolCalls: [],
+        thinking: [],
+        text: [],
+        timestamp: data.message.timestamp ?? msg.timestamp ?? "",
+        tokenUsage: subAgentUsage,
+        model: innerModel,
+        isBackground: backgroundAgentParentIds.has(parentId)
+      };
+      if (data.message.type === "assistant") {
+        const innerContent = data.message.message.content;
+        if (Array.isArray(innerContent)) {
+          for (const block of innerContent) {
+            if (block.type === "thinking") {
+              agentMsg.thinking.push(block.thinking);
+            } else if (block.type === "text") {
+              agentMsg.text.push(block.text);
+            } else if (block.type === "tool_use") {
+              agentMsg.toolCalls.push({
+                id: block.id,
+                name: block.name,
+                input: block.input,
+                result: null,
+                isError: false,
+                timestamp: data.message.timestamp ?? msg.timestamp ?? ""
+              });
+            }
+          }
+        }
+      } else if (data.message.type === "user") {
+        const innerContent = data.message.message.content;
+        if (Array.isArray(innerContent)) {
+          for (const block of innerContent) {
+            if (block.type === "tool_result") {
+              const existing = subAgentMap.get(parentId);
+              if (existing) {
+                for (const prev of existing) {
+                  const match = prev.toolCalls.find(
+                    (tc) => tc.id === block.tool_use_id
+                  );
+                  if (match) {
+                    match.result = extractToolResultText(block.content);
+                    match.isError = block.is_error;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      let agentMsgs = subAgentMap.get(parentId);
+      if (!agentMsgs) {
+        agentMsgs = [];
+        subAgentMap.set(parentId, agentMsgs);
+      }
+      agentMsgs.push(agentMsg);
+      if (current) {
+        flushSubAgentMessages(parentId);
+      }
+      continue;
+    }
+    if (isSystemMessage(msg) && msg.subtype === "turn_duration" && current) {
+      current.durationMs = msg.durationMs ?? null;
+      continue;
+    }
+  }
+  finalizeTurn();
+  return turns;
+}
+
+// src/lib/pricingTiers.ts
+var EXTENDED_CONTEXT_THRESHOLD = 2e5;
+var TIER_HAIKU_35 = { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08, webSearch: 0.01 };
+var TIER_HAIKU_45 = { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1, webSearch: 0.01 };
+var TIER_SONNET_LEGACY = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3, webSearch: 0.01 };
+var TIER_SONNET_LATEST = { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5, webSearch: 0.01 };
+var TIER_OPUS_LEGACY = { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5, webSearch: 0.01 };
+var TIER_SONNET_LEGACY_EXT = { input: 6, output: 22.5, cacheWrite: 7.5, cacheRead: 0.6, webSearch: 0.01 };
+var TIER_EXTENDED = { input: 10, output: 37.5, cacheWrite: 12.5, cacheRead: 1, webSearch: 0.01 };
+var MODEL_TIERS = [
+  // Haiku
+  { match: "haiku-4-5", tier: TIER_HAIKU_45 },
+  { match: "haiku-4-0", tier: TIER_HAIKU_35 },
+  { match: "3-5-haiku", tier: TIER_HAIKU_35 },
+  // Sonnet latest (4.5+)
+  { match: "sonnet-4-6", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
+  { match: "sonnet-4-5", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
+  // Sonnet legacy (3.5, 3.7, 4.0)
+  { match: "sonnet-4-0", tier: TIER_SONNET_LEGACY, extendedTier: TIER_SONNET_LEGACY_EXT },
+  { match: "3-7-sonnet", tier: TIER_SONNET_LEGACY, extendedTier: TIER_SONNET_LEGACY_EXT },
+  { match: "3-5-sonnet", tier: TIER_SONNET_LEGACY, extendedTier: TIER_SONNET_LEGACY_EXT },
+  // Opus latest (4.5+) — same tier as sonnet latest
+  { match: "opus-4-6", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
+  { match: "opus-4-5", tier: TIER_SONNET_LATEST, extendedTier: TIER_EXTENDED },
+  // Opus legacy (4.0, 4.1)
+  { match: "opus-4-1", tier: TIER_OPUS_LEGACY },
+  { match: "opus-4-0", tier: TIER_OPUS_LEGACY }
+];
+var DEFAULT_TIER = TIER_SONNET_LATEST;
+var DEFAULT_EXTENDED_TIER = TIER_EXTENDED;
+var FAMILY_FALLBACKS = [
+  { match: "haiku", tier: TIER_HAIKU_45 },
+  { match: "sonnet", tier: TIER_SONNET_LATEST },
+  { match: "opus", tier: TIER_SONNET_LATEST }
+];
+function resolveTier(model, totalInputTokens) {
+  const isExtended = (totalInputTokens ?? 0) > EXTENDED_CONTEXT_THRESHOLD;
+  for (const entry of MODEL_TIERS) {
+    if (model.includes(entry.match)) {
+      return isExtended && entry.extendedTier ? entry.extendedTier : entry.tier;
+    }
+  }
+  for (const entry of FAMILY_FALLBACKS) {
+    if (model.includes(entry.match)) return entry.tier;
+  }
+  return isExtended ? DEFAULT_EXTENDED_TIER : DEFAULT_TIER;
+}
+
+// src/lib/token-costs.ts
+var CHARS_PER_TOKEN = 4;
+function calculateCost(c) {
+  const totalInput = c.inputTokens + c.cacheWriteTokens + c.cacheReadTokens;
+  const p = resolveTier(c.model ?? "", totalInput);
+  return c.inputTokens / 1e6 * p.input + c.outputTokens / 1e6 * p.output + c.cacheWriteTokens / 1e6 * p.cacheWrite + c.cacheReadTokens / 1e6 * p.cacheRead + (c.webSearchRequests ?? 0) * p.webSearch;
+}
+function charsToTokens(chars) {
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function totalLength(strings) {
+  let n = 0;
+  for (const s of strings) n += s.length;
+  return n;
+}
+function totalToolInputLength(toolCalls) {
+  let n = 0;
+  for (const tc of toolCalls) n += JSON.stringify(tc.input).length;
+  return n;
+}
+function estimateThinkingTokens(turn) {
+  return charsToTokens(totalLength(turn.thinking.map((b) => b.thinking)));
+}
+function estimateVisibleOutputTokens(turn) {
+  return charsToTokens(totalLength(turn.assistantText) + totalToolInputLength(turn.toolCalls));
+}
+function estimateTotalOutputTokens(turn) {
+  const estimated = estimateThinkingTokens(turn) + estimateVisibleOutputTokens(turn);
+  return Math.max(estimated, turn.tokenUsage?.output_tokens ?? 0);
+}
+function estimateSubAgentOutput(sa) {
+  const chars = totalLength(sa.thinking) + totalLength(sa.text) + totalToolInputLength(sa.toolCalls);
+  return Math.max(charsToTokens(chars), sa.tokenUsage?.output_tokens ?? 0);
+}
+function calculateTurnCostEstimated(turn) {
+  if (!turn.tokenUsage) return 0;
+  const u = turn.tokenUsage;
+  return calculateCost({
+    model: turn.model,
+    inputTokens: u.input_tokens,
+    outputTokens: estimateTotalOutputTokens(turn),
+    cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
+    cacheReadTokens: u.cache_read_input_tokens ?? 0
+  });
+}
+function calculateSubAgentCostEstimated(sa) {
+  if (!sa.tokenUsage) return 0;
+  const u = sa.tokenUsage;
+  return calculateCost({
+    model: sa.model,
+    inputTokens: u.input_tokens,
+    outputTokens: estimateSubAgentOutput(sa),
+    cacheWriteTokens: u.cache_creation_input_tokens ?? 0,
+    cacheReadTokens: u.cache_read_input_tokens ?? 0
+  });
+}
+
+// src/lib/sessionStats.ts
+function countToolCalls(toolCalls, counts) {
+  let errors = 0;
+  for (const tc of toolCalls) {
+    counts[tc.name] = (counts[tc.name] ?? 0) + 1;
+    if (tc.isError) errors++;
+  }
+  return errors;
+}
+function addUsageToStats(stats, usage, estimatedOutput, cost) {
+  stats.totalInputTokens += usage.input_tokens;
+  stats.totalOutputTokens += estimatedOutput;
+  stats.totalCacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+  stats.totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+  stats.totalCostUSD += cost;
+}
+function computeStats(turns) {
+  const stats = {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheCreationTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCostUSD: 0,
+    toolCallCounts: {},
+    errorCount: 0,
+    totalDurationMs: 0,
+    turnCount: turns.length
+  };
+  for (const turn of turns) {
+    if (turn.tokenUsage) {
+      addUsageToStats(stats, turn.tokenUsage, estimateTotalOutputTokens(turn), calculateTurnCostEstimated(turn));
+    }
+    if (turn.durationMs) stats.totalDurationMs += turn.durationMs;
+    stats.errorCount += countToolCalls(turn.toolCalls, stats.toolCallCounts);
+    for (const sa of turn.subAgentActivity) {
+      stats.errorCount += countToolCalls(sa.toolCalls, stats.toolCallCounts);
+      if (sa.tokenUsage) {
+        addUsageToStats(stats, sa.tokenUsage, estimateSubAgentOutput(sa), calculateSubAgentCostEstimated(sa));
+      }
+    }
+  }
+  return stats;
+}
+
+// src/lib/parser.ts
+function isAssistantMessage2(msg) {
+  return msg.type === "assistant";
+}
+function extractTextFromContent2(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function parseLines(jsonlText) {
+  const messages = [];
+  for (const line of jsonlText.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      messages.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return messages;
+}
+function extractSessionMetadata(messages) {
+  const meta = { sessionId: "", version: "", gitBranch: "", cwd: "", slug: "", model: "", branchedFrom: void 0 };
+  for (const msg of messages) {
+    if (msg.sessionId && !meta.sessionId) meta.sessionId = msg.sessionId;
+    if (msg.version && !meta.version) meta.version = msg.version;
+    if (msg.gitBranch && !meta.gitBranch) meta.gitBranch = msg.gitBranch;
+    if (msg.cwd && !meta.cwd) meta.cwd = msg.cwd;
+    if (msg.slug && !meta.slug) meta.slug = msg.slug;
+    if (msg.branchedFrom && !meta.branchedFrom) {
+      meta.branchedFrom = msg.branchedFrom;
+    }
+    if (isAssistantMessage2(msg) && msg.message.model && !meta.model) {
+      meta.model = msg.message.model;
+    }
+    if (meta.sessionId && meta.version && meta.gitBranch && meta.cwd && meta.model) break;
+  }
+  return meta;
+}
+function parseSession(jsonlText) {
+  const rawMessages = parseLines(jsonlText);
+  const metadata = extractSessionMetadata(rawMessages);
+  const turns = buildTurns(rawMessages);
+  const stats = computeStats(turns);
+  return {
+    ...metadata,
+    turns,
+    stats,
+    rawMessages
+  };
+}
+function parseSessionAppend(existing, newJsonlText) {
+  const newMessages = parseLines(newJsonlText);
+  if (newMessages.length === 0) return existing;
+  const allRawMessages = [...existing.rawMessages, ...newMessages];
+  let lastTurnStartIdx = existing.rawMessages.length;
+  let turnsToKeep = existing.turns.length > 0 ? existing.turns.length - 1 : 0;
+  if (existing.turns.length > 0) {
+    let userMsgCount = 0;
+    for (let i = existing.rawMessages.length - 1; i >= 0; i--) {
+      const msg = existing.rawMessages[i];
+      if (msg.type === "user" && !msg.isMeta) {
+        const content = msg.message?.content;
+        if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) {
+          continue;
+        }
+        userMsgCount++;
+        if (userMsgCount === 1) {
+          lastTurnStartIdx = i;
+          break;
+        }
+      }
+    }
+    const progressParentIds = /* @__PURE__ */ new Set();
+    for (const msg of newMessages) {
+      if (msg.type === "progress") {
+        const parentId = msg.parentToolUseID;
+        if (parentId) progressParentIds.add(parentId);
+      }
+    }
+    if (progressParentIds.size > 0) {
+      for (let t = existing.turns.length - 2; t >= 0; t--) {
+        const turn = existing.turns[t];
+        const ownsProgressParent = turn.toolCalls.some((tc) => progressParentIds.has(tc.id));
+        if (ownsProgressParent) {
+          turnsToKeep = t;
+          let found = 0;
+          for (let i = 0; i < existing.rawMessages.length; i++) {
+            const msg = existing.rawMessages[i];
+            if (msg.type === "user" && !msg.isMeta) {
+              const content = msg.message?.content;
+              if (Array.isArray(content) && content.some((b) => b.type === "tool_result")) {
+                continue;
+              }
+              if (found === t) {
+                lastTurnStartIdx = i;
+                break;
+              }
+              found++;
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  const keptTurns = existing.turns.slice(0, turnsToKeep);
+  const tailMessages = allRawMessages.slice(lastTurnStartIdx);
+  const tailTurns = buildTurns(tailMessages);
+  const allTurns = [...keptTurns, ...tailTurns];
+  const stats = computeStats(allTurns);
+  return {
+    sessionId: existing.sessionId,
+    version: existing.version,
+    gitBranch: existing.gitBranch,
+    cwd: existing.cwd,
+    slug: existing.slug,
+    model: existing.model || (allTurns.length > 0 ? allTurns[allTurns.length - 1].model || "" : ""),
+    turns: allTurns,
+    stats,
+    rawMessages: allRawMessages,
+    branchedFrom: existing.branchedFrom
+  };
+}
+function getUserMessageText(content) {
+  if (content === null) return "";
+  if (typeof content === "string") return content;
+  return extractTextFromContent2(content);
+}
+function getUserMessageImages(content) {
+  if (content === null || typeof content === "string") return [];
+  return content.filter((b) => b.type === "image");
+}
+
+// src/lib/search-index.ts
+var SearchIndex = class {
+  db;
+  dbPath;
+  projectsDir = null;
+  _watcherRunning = false;
+  _lastFullBuild = null;
+  _lastUpdate = null;
+  watcher = null;
+  debounceTimers = /* @__PURE__ */ new Map();
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = new Database(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA synchronous = NORMAL");
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`CREATE TABLE IF NOT EXISTS indexed_files (
+      file_path TEXT PRIMARY KEY,
+      mtime_ms REAL NOT NULL,
+      session_id TEXT NOT NULL,
+      is_subagent INTEGER NOT NULL DEFAULT 0,
+      parent_session_id TEXT
+    )`);
+    const ftsExists = this.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='search_content'"
+    ).get();
+    if (!ftsExists) {
+      this.db.exec(`CREATE VIRTUAL TABLE search_content USING fts5(
+        session_id,
+        source_file,
+        location,
+        content,
+        tokenize = 'trigram'
+      )`);
+    }
+  }
+  getStats() {
+    const { count: indexedFiles } = this.db.prepare("SELECT COUNT(*) as count FROM indexed_files").get();
+    const { count: indexedSessions } = this.db.prepare("SELECT COUNT(*) as count FROM indexed_files WHERE is_subagent = 0").get();
+    const { count: indexedSubagents } = this.db.prepare("SELECT COUNT(*) as count FROM indexed_files WHERE is_subagent = 1").get();
+    const { count: totalRows } = this.db.prepare("SELECT COUNT(*) as count FROM search_content").get();
+    let dbSizeBytes = 0;
+    try {
+      dbSizeBytes = (0, import_node_fs.statSync)(this.dbPath).size;
+    } catch {
+    }
+    return {
+      dbPath: this.dbPath,
+      dbSizeBytes,
+      dbSizeMB: Math.round(dbSizeBytes / 1024 / 1024 * 10) / 10,
+      indexedFiles,
+      indexedSessions,
+      indexedSubagents,
+      totalRows,
+      watcherRunning: this._watcherRunning,
+      lastFullBuild: this._lastFullBuild,
+      lastUpdate: this._lastUpdate
+    };
+  }
+  /**
+   * Parse a JSONL file and insert all searchable content into the FTS5 index.
+   * Idempotent: deletes old data for the file before re-indexing.
+   * All inserts run in a single transaction for performance.
+   */
+  indexFile(filePath, sessionId, mtimeMs, opts) {
+    if (!sessionId) {
+      sessionId = (0, import_node_path.basename)(filePath, ".jsonl");
+    }
+    if (mtimeMs == null) {
+      mtimeMs = (0, import_node_fs.statSync)(filePath).mtimeMs;
+    }
+    const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+    const session = parseSession(content);
+    const isSubagent = opts?.isSubagent ? 1 : 0;
+    const parentSessionId = opts?.parentSessionId ?? null;
+    const insert = this.db.prepare(
+      "INSERT INTO search_content (session_id, source_file, location, content) VALUES (?, ?, ?, ?)"
+    );
+    const deleteContent = this.db.prepare(
+      "DELETE FROM search_content WHERE source_file = ?"
+    );
+    const deleteFile = this.db.prepare(
+      "DELETE FROM indexed_files WHERE file_path = ?"
+    );
+    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(() => {
+      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);
+        }
+      }
+      insertFile.run(filePath, mtimeMs, sessionId, isSubagent, parentSessionId);
+    });
+    txn();
+    this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /**
+   * Query the FTS5 index and return structured search results.
+   *
+   * - FTS5 trigram tokenizer is case-insensitive by default.
+   * - When `caseSensitive` is true, a post-filter checks the original query
+   *   against the snippet text (exact case match).
+   * - When `maxAgeMs` is provided, only files whose mtime in `indexed_files`
+   *   falls within the window are included (join on source_file).
+   * - `sessionId` restricts results to a single session.
+   * - `limit` defaults to 200 and is clamped to a max of 200.
+   */
+  search(query, opts) {
+    const limit = Math.min(Math.max(1, opts?.limit ?? 200), 200);
+    const sessionId = opts?.sessionId;
+    const maxAgeMs = opts?.maxAgeMs;
+    const caseSensitive = opts?.caseSensitive ?? false;
+    const ftsQuery = `"${query.replace(/"/g, '""')}"`;
+    let sql = `
+      SELECT sc.session_id, sc.location,
+             snippet(search_content, 3, '', '', '...', 40) as snippet
+      FROM search_content sc
+    `;
+    const params = [];
+    const conditions = ["sc.content MATCH ?"];
+    params.push(ftsQuery);
+    if (maxAgeMs != null) {
+      sql += " JOIN indexed_files fi ON fi.file_path = sc.source_file";
+      conditions.push("fi.mtime_ms >= ?");
+      params.push(Date.now() - maxAgeMs);
+    }
+    if (sessionId) {
+      conditions.push("sc.session_id = ?");
+      params.push(sessionId);
+    }
+    sql += " WHERE " + conditions.join(" AND ");
+    sql += " ORDER BY sc.rowid DESC";
+    sql += " LIMIT ?";
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params);
+    let hits = rows.map((row) => ({
+      sessionId: row.session_id,
+      location: row.location,
+      snippet: row.snippet,
+      matchCount: 1
+      // FTS5 trigram doesn't expose per-row match count; 1 = "at least one match"
+    }));
+    if (caseSensitive) {
+      hits = hits.filter((h) => h.snippet.includes(query));
+    }
+    return hits;
+  }
+  /**
+   * Count total matching rows and distinct sessions for a query (without LIMIT).
+   * Used by the route to report accurate totalHits and sessionsSearched.
+   */
+  countMatches(query, opts) {
+    const ftsQuery = `"${query.replace(/"/g, '""')}"`;
+    let sql = `
+      SELECT COUNT(*) as total,
+             COUNT(DISTINCT sc.session_id) as sessions
+      FROM search_content sc
+    `;
+    const params = [];
+    const conditions = ["sc.content MATCH ?"];
+    params.push(ftsQuery);
+    if (opts?.maxAgeMs != null) {
+      sql += " JOIN indexed_files fi ON fi.file_path = sc.source_file";
+      conditions.push("fi.mtime_ms >= ?");
+      params.push(Date.now() - opts.maxAgeMs);
+    }
+    if (opts?.sessionId) {
+      conditions.push("sc.session_id = ?");
+      params.push(opts.sessionId);
+    }
+    sql += " WHERE " + conditions.join(" AND ");
+    const row = this.db.prepare(sql).get(...params);
+    return { totalHits: row.total, sessionsSearched: row.sessions };
+  }
+  /**
+   * Clear all indexed data and re-index every JSONL file under `projectsDir`.
+   * Structure: projectsDir/{projectName}/{sessionId}.jsonl
+   * Subagents:  projectsDir/{projectName}/{sessionId}/subagents/agent-{id}.jsonl
+   *
+   * 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._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.
+   */
+  updateStale(projectsDir) {
+    this.projectsDir = projectsDir;
+    const getIndexed = this.db.prepare(
+      "SELECT mtime_ms FROM indexed_files WHERE file_path = ?"
+    );
+    const filesToIndex = [];
+    this.discoverFiles(projectsDir, (filePath, sessionId, mtimeMs, isSubagent, parentSessionId) => {
+      const existing = getIndexed.get(filePath);
+      if (!existing || existing.mtime_ms < mtimeMs) {
+        filesToIndex.push({ path: filePath, sessionId, mtimeMs, isSubagent, parentSessionId });
+      }
+    });
+    for (const file of filesToIndex) {
+      try {
+        this.indexFile(file.path, file.sessionId, file.mtimeMs, {
+          isSubagent: file.isSubagent,
+          parentSessionId: file.parentSessionId
+        });
+      } catch {
+      }
+    }
+    if (filesToIndex.length > 0) {
+      this._lastUpdate = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  /**
+   * Re-run buildFull using the previously stored projectsDir.
+   * No-op if projectsDir was never set.
+   */
+  rebuild() {
+    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.
+   *
+   * Directory structure:
+   *   projectsDir/
+   *     {projectName}/
+   *       {sessionId}.jsonl              <- session file
+   *       {sessionId}/subagents/
+   *         agent-{agentId}.jsonl        <- subagent file (recursive)
+   *
+   * Skips the "memory" directory.
+   */
+  discoverFiles(projectsDir, callback) {
+    let entries;
+    try {
+      entries = (0, import_node_fs.readdirSync)(projectsDir);
+    } 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;
+      }
+      let files;
+      try {
+        files = (0, import_node_fs.readdirSync)(projectDir);
+      } 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");
+        try {
+          const s = (0, import_node_fs.statSync)(filePath);
+          callback(filePath, sessionId, s.mtimeMs, false, null);
+        } catch {
+          continue;
+        }
+        this.discoverSubagents(filePath, sessionId, callback, 0, 4);
+      }
+    }
+  }
+  /**
+   * Recursively discover subagent JSONL files under the subagents directory
+   * that corresponds to `parentPath`.
+   *
+   * For a parent at `/path/to/session-1.jsonl`, looks for subagents at
+   * `/path/to/session-1/subagents/agent-*.jsonl`.
+   *
+   * Recurses up to `maxDepth` levels (default 4).
+   */
+  discoverSubagents(parentPath, parentSessionId, callback, depth, maxDepth) {
+    if (depth >= maxDepth) return;
+    const subDir = parentPath.replace(/\.jsonl$/, "") + "/subagents";
+    let files;
+    try {
+      files = (0, import_node_fs.readdirSync)(subDir);
+    } catch {
+      return;
+    }
+    for (const file of files) {
+      if (!file.startsWith("agent-") || !file.endsWith(".jsonl")) continue;
+      const filePath = (0, import_node_path.join)(subDir, file);
+      try {
+        const s = (0, import_node_fs.statSync)(filePath);
+        callback(filePath, parentSessionId, s.mtimeMs, true, parentSessionId);
+      } catch {
+        continue;
+      }
+      this.discoverSubagents(filePath, parentSessionId, callback, depth + 1, maxDepth);
+    }
+  }
+  /**
+   * Start watching `projectsDir` for JSONL file changes.
+   * Runs `updateStale()` immediately for an initial sync, then sets up
+   * `fs.watch` with `{ recursive: true }` (macOS-compatible) to detect
+   * subsequent file changes and trigger debounced re-indexing.
+   */
+  startWatching(projectsDir) {
+    this.projectsDir = projectsDir;
+    this.updateStale(projectsDir);
+    try {
+      this.watcher = (0, import_node_fs.watch)(projectsDir, { recursive: true }, (_event, filename) => {
+        if (!filename || !filename.endsWith(".jsonl")) return;
+        this.debouncedReindex((0, import_node_path.join)(projectsDir, filename));
+      });
+      this._watcherRunning = true;
+    } catch (err) {
+      console.warn("[search-index] fs.watch failed (recursive may not be supported):", err);
+      this._watcherRunning = false;
+    }
+  }
+  /**
+   * Stop the file watcher and clear any pending debounce timers.
+   * Safe to call even when not watching (no-op).
+   */
+  stopWatching() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+    this._watcherRunning = false;
+  }
+  /**
+   * Private helper: debounce re-indexing of a single file.
+   * Waits 2 seconds after the last change event for a given file path
+   * before actually calling `indexFile()`. This coalesces rapid writes
+   * (e.g. streaming JSONL appends) into a single index operation.
+   */
+  debouncedReindex(filePath) {
+    const existing = this.debounceTimers.get(filePath);
+    if (existing) clearTimeout(existing);
+    this.debounceTimers.set(
+      filePath,
+      setTimeout(() => {
+        this.debounceTimers.delete(filePath);
+        try {
+          const s = (0, import_node_fs.statSync)(filePath);
+          const parts = filePath.split("/");
+          const fileName = parts[parts.length - 1];
+          const isSubagent = parts.includes("subagents");
+          let sessionId;
+          let parentSessionId = null;
+          if (isSubagent) {
+            const subagentsIdx = parts.lastIndexOf("subagents");
+            const parentDir = parts[subagentsIdx - 1];
+            sessionId = parentDir;
+            parentSessionId = parentDir;
+          } else {
+            sessionId = (0, import_node_path.basename)(fileName, ".jsonl");
+          }
+          this.indexFile(filePath, sessionId, s.mtimeMs, {
+            isSubagent,
+            parentSessionId
+          });
+        } catch {
+        }
+      }, 2e3)
+    );
+  }
+  close() {
+    this.stopWatching();
+    this.db.close();
+  }
+};
+
+// src/lib/dirs.ts
+var import_node_path2 = require("node:path");
+var import_node_os = require("node:os");
+var dirs = {
+  PROJECTS_DIR: (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "projects"),
+  TEAMS_DIR: (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "teams"),
+  TASKS_DIR: (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "tasks")
+};
+var DEFAULT_DB_PATH = (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "cogpit-memory", "search-index.db");
+
+// src/commands/search.ts
+var import_node_fs2 = require("node:fs");
+var import_promises2 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
+
+// src/lib/response.ts
+function parseMaxAge(raw) {
+  const match = raw.match(/^(\d+)([dhm])$/);
+  if (!match) return 5 * 24 * 60 * 60 * 1e3;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "d":
+      return value * 24 * 60 * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    default:
+      return 5 * 24 * 60 * 60 * 1e3;
+  }
+}
+
+// src/lib/helpers.ts
+var import_promises = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+var import_node_os2 = require("node:os");
+async function findJsonlPath(sessionId) {
+  const targetFile = `${sessionId}.jsonl`;
+  try {
+    const entries = await (0, import_promises.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name === "memory") continue;
+      const projectDir = (0, import_node_path3.join)(dirs.PROJECTS_DIR, entry.name);
+      try {
+        const files = await (0, import_promises.readdir)(projectDir);
+        if (files.includes(targetFile)) {
+          return (0, import_node_path3.join)(projectDir, targetFile);
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function matchSubagentToMember(leadSessionId, subagentFileName, members) {
+  const entries = await (0, import_promises.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === "memory") continue;
+    const filePath = (0, import_node_path3.join)(
+      dirs.PROJECTS_DIR,
+      entry.name,
+      leadSessionId,
+      "subagents",
+      subagentFileName
+    );
+    try {
+      const fh = await (0, import_promises.open)(filePath, "r");
+      try {
+        const buf = Buffer.alloc(16384);
+        const { bytesRead } = await fh.read(buf, 0, 16384, 0);
+        const firstLine = buf.subarray(0, bytesRead).toString("utf-8").split("\n")[0] || "";
+        for (const member of members) {
+          if (member.agentType === "team-lead") continue;
+          const prompt = member.prompt || "";
+          const snippet = prompt.slice(0, 120);
+          const terms = [
+            member.name,
+            member.name.replace(/-/g, " "),
+            ...snippet ? [snippet, snippet.replace(/"/g, '\\"')] : []
+          ];
+          if (terms.some((t) => firstLine.includes(t))) {
+            return member.name;
+          }
+        }
+      } finally {
+        await fh.close();
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+var HOME_PREFIX = (0, import_node_os2.homedir)().replace(/\//g, "-").replace(/^-/, "").toLowerCase();
+
+// src/commands/search.ts
+async function searchSessions(query, opts, searchIndex) {
+  if (!query || query.length < 2) {
+    return { error: "Query must be at least 2 characters" };
+  }
+  const limit = Math.min(Math.max(1, opts.limit ?? 20), 200);
+  const caseSensitive = opts.caseSensitive ?? false;
+  const maxAgeMs = parseMaxAge(opts.maxAge ?? "5d");
+  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)) {
+    try {
+      index = new SearchIndex(DEFAULT_DB_PATH);
+      ownedIndex = true;
+    } catch {
+    }
+  }
+  if (index) {
+    try {
+      const hits = index.search(query, {
+        limit,
+        sessionId: opts.sessionId,
+        maxAgeMs,
+        caseSensitive
+      });
+      const grouped = /* @__PURE__ */ new Map();
+      for (const hit of hits) {
+        let sessionHits = grouped.get(hit.sessionId);
+        if (!sessionHits) {
+          sessionHits = [];
+          grouped.set(hit.sessionId, sessionHits);
+        }
+        sessionHits.push({
+          location: hit.location,
+          snippet: hit.snippet,
+          matchCount: hit.matchCount
+        });
+      }
+      const results = [];
+      for (const [sid, sessionHits] of grouped) {
+        results.push({ sessionId: sid, hits: sessionHits });
+      }
+      let totalHits = hits.length;
+      let sessionsSearched = grouped.size;
+      if (hits.length >= limit) {
+        const counts = index.countMatches(query, {
+          sessionId: opts.sessionId,
+          maxAgeMs
+        });
+        totalHits = counts.totalHits;
+        sessionsSearched = counts.sessionsSearched;
+      }
+      if (ownedIndex) index.close();
+      return {
+        query,
+        totalHits,
+        returnedHits: hits.length,
+        sessionsSearched,
+        results
+      };
+    } catch {
+      if (ownedIndex) index.close();
+    }
+  }
+  return rawScanSearch(query, opts.sessionId ?? null, maxAgeMs, limit, caseSensitive, depth);
+}
+var SNIPPET_WINDOW = 150;
+function generateSnippet(text, matchIdx, queryLen) {
+  if (matchIdx === -1) return text.slice(0, SNIPPET_WINDOW);
+  const halfWindow = Math.floor((SNIPPET_WINDOW - queryLen) / 2);
+  const start = Math.max(0, matchIdx - halfWindow);
+  const end = Math.min(text.length, start + SNIPPET_WINDOW);
+  const adjustedStart = Math.max(0, end - SNIPPET_WINDOW);
+  let snippet = text.slice(adjustedStart, end);
+  if (adjustedStart > 0) snippet = "..." + snippet;
+  if (end < text.length) snippet = snippet + "...";
+  return snippet;
+}
+function countMatches(haystack, needle) {
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+function searchField(text, location, query, caseSensitive, extras) {
+  if (!text) return null;
+  const haystack = caseSensitive ? text : text.toLowerCase();
+  const needle = caseSensitive ? query : query.toLowerCase();
+  const idx = haystack.indexOf(needle);
+  if (idx === -1) return null;
+  return {
+    location,
+    snippet: generateSnippet(text, idx, query.length),
+    matchCount: countMatches(haystack, needle),
+    ...extras?.toolName && { toolName: extras.toolName },
+    ...extras?.agentName && { agentName: extras.agentName }
+  };
+}
+async function discoverSingleSession(sessionId) {
+  const jsonlPath = await findJsonlPath(sessionId);
+  if (!jsonlPath) return [];
+  const s = await (0, import_promises2.stat)(jsonlPath);
+  return [{ path: jsonlPath, mtimeMs: s.mtimeMs }];
+}
+async function discoverAllSessions(maxAgeMs) {
+  const cutoff = Date.now() - maxAgeMs;
+  let entries;
+  try {
+    entries = await (0, import_promises2.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const projectDirs = entries.filter((e) => e.isDirectory() && e.name !== "memory").map((e) => (0, import_node_path4.join)(dirs.PROJECTS_DIR, e.name));
+  const nested = await Promise.all(
+    projectDirs.map(async (projectDir) => {
+      try {
+        const files = await (0, import_promises2.readdir)(projectDir);
+        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+        const statResults = await Promise.all(
+          jsonlFiles.map(async (f) => {
+            const filePath = (0, import_node_path4.join)(projectDir, f);
+            try {
+              const s = await (0, import_promises2.stat)(filePath);
+              return s.mtimeMs >= cutoff ? { path: filePath, mtimeMs: s.mtimeMs } : null;
+            } catch {
+              return null;
+            }
+          })
+        );
+        return statResults.filter((r) => r !== null);
+      } catch {
+        return [];
+      }
+    })
+  );
+  const results = nested.flat();
+  results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return results;
+}
+async function rawTextMatch(filePath, query, caseSensitive) {
+  try {
+    const content = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const haystack = caseSensitive ? content : content.toLowerCase();
+    const needle = caseSensitive ? query : query.toLowerCase();
+    if (haystack.includes(needle)) return content;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function walkSession(session, query, caseSensitive, locationPrefix = "") {
+  const hits = [];
+  for (let i = 0; i < session.turns.length; i++) {
+    const turn = session.turns[i];
+    const prefix = `${locationPrefix}turn/${i}`;
+    const userText = getUserMessageText(turn.userMessage);
+    const userHit = searchField(userText || null, `${prefix}/userMessage`, query, caseSensitive);
+    if (userHit) hits.push(userHit);
+    const assistantText = turn.assistantText.length > 0 ? turn.assistantText.join("\n\n") : null;
+    const assistantHit = searchField(assistantText, `${prefix}/assistantMessage`, query, caseSensitive);
+    if (assistantHit) hits.push(assistantHit);
+    for (const tb of turn.thinking) {
+      if (!tb.thinking) continue;
+      const thinkHit = searchField(tb.thinking, `${prefix}/thinking`, query, caseSensitive);
+      if (thinkHit) {
+        hits.push(thinkHit);
+        break;
+      }
+    }
+    for (const tc of turn.toolCalls) {
+      const inputStr = JSON.stringify(tc.input);
+      const inputHit = searchField(inputStr, `${prefix}/toolCall/${tc.id}/input`, query, caseSensitive, { toolName: tc.name });
+      if (inputHit) hits.push(inputHit);
+      const resultHit = searchField(tc.result, `${prefix}/toolCall/${tc.id}/result`, query, caseSensitive, { toolName: tc.name });
+      if (resultHit) hits.push(resultHit);
+    }
+    for (const sa of turn.subAgentActivity) {
+      const saPrefix = `${locationPrefix}agent/${sa.agentId}/`;
+      const saText = sa.text.length > 0 ? sa.text.join("\n\n") : null;
+      const saTextHit = searchField(saText, `${saPrefix}assistantMessage`, query, caseSensitive, {
+        agentName: sa.agentName ?? void 0
+      });
+      if (saTextHit) hits.push(saTextHit);
+      for (const t of sa.thinking) {
+        const tHit = searchField(t, `${saPrefix}thinking`, query, caseSensitive, { agentName: sa.agentName ?? void 0 });
+        if (tHit) {
+          hits.push(tHit);
+          break;
+        }
+      }
+      for (const tc of sa.toolCalls) {
+        const inputStr = JSON.stringify(tc.input);
+        const inputHit = searchField(inputStr, `${saPrefix}toolCall/${tc.id}/input`, query, caseSensitive, {
+          toolName: tc.name,
+          agentName: sa.agentName ?? void 0
+        });
+        if (inputHit) hits.push(inputHit);
+        const resultHit = searchField(tc.result, `${saPrefix}toolCall/${tc.id}/result`, query, caseSensitive, {
+          toolName: tc.name,
+          agentName: sa.agentName ?? void 0
+        });
+        if (resultHit) hits.push(resultHit);
+      }
+    }
+    if (turn.compactionSummary) {
+      const compHit = searchField(turn.compactionSummary, `${prefix}/compactionSummary`, query, caseSensitive);
+      if (compHit) hits.push(compHit);
+    }
+  }
+  return hits;
+}
+async function walkSubagentFiles(parentJsonlPath, query, caseSensitive, currentDepth, maxDepth) {
+  if (currentDepth >= maxDepth) return [];
+  const subDir = parentJsonlPath.replace(/\.jsonl$/, "") + "/subagents";
+  let files;
+  try {
+    files = await (0, import_promises2.readdir)(subDir);
+  } catch {
+    return [];
+  }
+  const agentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl")).map((f) => ({
+    agentId: f.slice("agent-".length, -".jsonl".length),
+    filePath: (0, import_node_path4.join)(subDir, f)
+  }));
+  const matched = await Promise.all(
+    agentFiles.map(async ({ agentId, filePath }) => ({
+      agentId,
+      filePath,
+      rawContent: await rawTextMatch(filePath, query, caseSensitive)
+    }))
+  );
+  const hitArrays = await Promise.all(
+    matched.filter((m) => m.rawContent).map(async ({ agentId, filePath, rawContent }) => {
+      const subSession = parseSession(rawContent);
+      const subHits = walkSession(subSession, query, caseSensitive, `agent/${agentId}/`);
+      const nestedHits = await walkSubagentFiles(filePath, query, caseSensitive, currentDepth + 1, maxDepth);
+      return [...subHits, ...nestedHits];
+    })
+  );
+  return hitArrays.flat();
+}
+async function rawScanSearch(query, sessionId, maxAgeMs, limit, caseSensitive, depth) {
+  try {
+    const files = sessionId ? await discoverSingleSession(sessionId) : await discoverAllSessions(maxAgeMs);
+    let totalHits = 0;
+    let returnedHits = 0;
+    const results = [];
+    let sessionsSearched = 0;
+    for (const file of files) {
+      if (returnedHits >= limit) break;
+      const rawContent = await rawTextMatch(file.path, query, caseSensitive);
+      sessionsSearched++;
+      if (!rawContent) continue;
+      const session = parseSession(rawContent);
+      const sessionHits = walkSession(session, query, caseSensitive);
+      const subagentHits = await walkSubagentFiles(file.path, query, caseSensitive, 0, depth);
+      const allHits = [...sessionHits, ...subagentHits];
+      if (allHits.length === 0) continue;
+      totalHits += allHits.length;
+      const sessionResult = {
+        sessionId: session.sessionId || (0, import_node_path4.basename)(file.path, ".jsonl"),
+        hits: []
+      };
+      for (const hit of allHits) {
+        if (returnedHits < limit) {
+          sessionResult.hits.push(hit);
+          returnedHits++;
+        }
+      }
+      if (sessionResult.hits.length > 0) {
+        results.push(sessionResult);
+      }
+    }
+    return {
+      query,
+      totalHits,
+      returnedHits,
+      sessionsSearched,
+      results
+    };
+  } catch (err) {
+    return {
+      query,
+      totalHits: 0,
+      returnedHits: 0,
+      sessionsSearched: 0,
+      results: []
+    };
+  }
+}
+
+// src/commands/context.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+var RESULT_TRUNCATE_LIMIT = 1e4;
+var L1_RESPONSE_LIMIT = 15e4;
+function extractUserMessageText(userMessage) {
+  if (userMessage === null) return null;
+  if (typeof userMessage === "string") return userMessage;
+  const parts = [];
+  for (const block of userMessage) {
+    if (block.type === "text") parts.push(block.text);
+    else if (block.type === "image") parts.push("[image attached]");
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function truncateResult(result) {
+  if (result === null) return { result: null, resultTruncated: false };
+  if (result.length <= RESULT_TRUNCATE_LIMIT) return { result, resultTruncated: false };
+  return { result: result.slice(0, RESULT_TRUNCATE_LIMIT), resultTruncated: true };
+}
+function mapSubAgentSummary(msg) {
+  return {
+    agentId: msg.agentId,
+    name: msg.agentName ?? null,
+    type: msg.subagentType ?? null,
+    status: msg.status ?? null,
+    durationMs: msg.durationMs ?? null,
+    toolUseCount: msg.toolUseCount ?? null,
+    isBackground: msg.isBackground
+  };
+}
+function mapSubAgentDetail(msg) {
+  return {
+    ...mapSubAgentSummary(msg),
+    prompt: msg.prompt ?? null,
+    resultText: msg.text.join("\n\n") || null
+  };
+}
+function mapSessionToOverview(session) {
+  const turns = session.turns.map((turn, i) => mapTurnToSummary(turn, i));
+  const compacted = session.turns.some((t) => t.compactionSummary != null);
+  const overview = {
+    sessionId: session.sessionId,
+    cwd: session.cwd,
+    model: session.model,
+    branchedFrom: session.branchedFrom ?? null,
+    compacted,
+    turns,
+    stats: {
+      totalTurns: session.stats.turnCount,
+      totalToolCalls: Object.values(session.stats.toolCallCounts).reduce((a, b) => a + b, 0),
+      totalTokens: {
+        input: session.stats.totalInputTokens,
+        output: session.stats.totalOutputTokens
+      }
+    }
+  };
+  let serialized = JSON.stringify(overview);
+  if (serialized.length > L1_RESPONSE_LIMIT) {
+    const entries = [];
+    for (const t of overview.turns) {
+      if (t.assistantMessage) entries.push({ turn: t, field: "assistantMessage", len: t.assistantMessage.length });
+      if (t.userMessage) entries.push({ turn: t, field: "userMessage", len: t.userMessage.length });
+    }
+    entries.sort((a, b) => b.len - a.len);
+    for (const entry of entries) {
+      const current = entry.turn[entry.field];
+      if (current && current.length > 200) {
+        entry.turn[entry.field] = current.slice(0, 200) + "... [truncated, use L2 for full text]";
+        serialized = JSON.stringify(overview);
+        if (serialized.length <= L1_RESPONSE_LIMIT) break;
+      }
+    }
+  }
+  return overview;
+}
+function mapTurnToSummary(turn, turnIndex) {
+  const toolSummary = {};
+  for (const tc of turn.toolCalls) {
+    toolSummary[tc.name] = (toolSummary[tc.name] ?? 0) + 1;
+  }
+  const agentById = /* @__PURE__ */ new Map();
+  for (const msg of turn.subAgentActivity) {
+    agentById.set(msg.agentId, msg);
+  }
+  const subAgents = [...agentById.values()].map(mapSubAgentSummary);
+  return {
+    turnIndex,
+    userMessage: extractUserMessageText(turn.userMessage),
+    assistantMessage: turn.assistantText.length > 0 ? turn.assistantText.join("\n\n") : null,
+    toolSummary,
+    subAgents,
+    hasThinking: turn.thinking.length > 0,
+    isError: turn.toolCalls.some((tc) => tc.isError),
+    compactionSummary: turn.compactionSummary ?? null
+  };
+}
+function mapTurnToDetail(session, turnIndex) {
+  const turn = session.turns[turnIndex];
+  const contentBlocks = turn.contentBlocks.map((block) => mapContentBlock(block));
+  return {
+    sessionId: session.sessionId,
+    turnIndex,
+    userMessage: extractUserMessageText(turn.userMessage),
+    contentBlocks,
+    tokenUsage: turn.tokenUsage ? { input: turn.tokenUsage.input_tokens, output: turn.tokenUsage.output_tokens } : null,
+    model: turn.model,
+    durationMs: turn.durationMs
+  };
+}
+function mapContentBlock(block) {
+  switch (block.kind) {
+    case "thinking": {
+      const text = block.blocks.filter((b) => b.thinking.length > 0).map((b) => b.thinking).join("\n\n");
+      return { kind: "thinking", text, timestamp: block.timestamp ?? null };
+    }
+    case "text":
+      return { kind: "text", text: block.text.join("\n\n"), timestamp: block.timestamp ?? null };
+    case "tool_calls":
+      return {
+        kind: "tool_calls",
+        toolCalls: block.toolCalls.map((tc) => {
+          const { result, resultTruncated } = truncateResult(tc.result);
+          return { id: tc.id, name: tc.name, input: tc.input, result, resultTruncated, isError: tc.isError };
+        }),
+        timestamp: block.timestamp ?? null
+      };
+    case "sub_agent":
+    case "background_agent":
+      return {
+        kind: block.kind,
+        agents: block.messages.map(mapSubAgentDetail),
+        timestamp: block.timestamp ?? null
+      };
+  }
+}
+async function findSubagentFile(parentJsonlPath, agentId) {
+  const subagentsDir = parentJsonlPath.replace(/\.jsonl$/, "") + "/subagents";
+  try {
+    const files = await (0, import_promises3.readdir)(subagentsDir);
+    for (const f of files) {
+      if (!f.startsWith("agent-") || !f.endsWith(".jsonl")) continue;
+      const fileAgentId = f.replace("agent-", "").replace(".jsonl", "");
+      if (fileAgentId === agentId) {
+        return { filePath: (0, import_node_path5.join)(subagentsDir, f), fileName: f };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function findTeamContext(sessionId, subagentFileName) {
+  try {
+    const teamEntries = await (0, import_promises3.readdir)(dirs.TEAMS_DIR, { withFileTypes: true });
+    for (const entry of teamEntries) {
+      if (!entry.isDirectory()) continue;
+      const configPath = (0, import_node_path5.join)(dirs.TEAMS_DIR, entry.name, "config.json");
+      try {
+        const raw = await (0, import_promises3.readFile)(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        if (config.leadSessionId !== sessionId) continue;
+        const members = config.members ?? [];
+        const memberName = await matchSubagentToMember(sessionId, subagentFileName, members);
+        if (!memberName) continue;
+        let currentTask = null;
+        try {
+          const taskDir = (0, import_node_path5.join)(dirs.TASKS_DIR, entry.name);
+          const taskFiles = await (0, import_promises3.readdir)(taskDir);
+          for (const tf of taskFiles) {
+            if (!tf.endsWith(".json")) continue;
+            const taskRaw = await (0, import_promises3.readFile)((0, import_node_path5.join)(taskDir, tf), "utf-8");
+            const task = JSON.parse(taskRaw);
+            if (task.owner === memberName && task.status === "in_progress") {
+              currentTask = { id: task.id, subject: task.subject, status: task.status };
+              break;
+            }
+          }
+        } catch {
+        }
+        return { teamName: entry.name, role: memberName, currentTask };
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function findParentToolCallId(session, agentId) {
+  for (const turn of session.turns) {
+    for (const msg of turn.subAgentActivity) {
+      if (msg.agentId === agentId) {
+        for (const tc of turn.toolCalls) {
+          if (tc.name === "Task" || tc.name === "Agent") {
+            return tc.id;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function findAgentMetadata(session, agentId) {
+  for (const turn of session.turns) {
+    for (const msg of turn.subAgentActivity) {
+      if (msg.agentId === agentId) {
+        return {
+          name: msg.agentName,
+          type: msg.subagentType,
+          isBackground: msg.isBackground
+        };
+      }
+    }
+  }
+  return { name: null, type: null, isBackground: false };
+}
+async function getSessionOverview(sessionId) {
+  const jsonlPath = await findJsonlPath(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
+  const session = parseSession(content);
+  return mapSessionToOverview(session);
+}
+async function getTurnDetail(sessionId, turnIndex) {
+  const jsonlPath = await findJsonlPath(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
+  const session = parseSession(content);
+  if (turnIndex < 0 || turnIndex >= session.turns.length) return { error: "Turn not found" };
+  return mapTurnToDetail(session, turnIndex);
+}
+async function getAgentOverview(sessionId, agentId) {
+  const jsonlPath = await findJsonlPath(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
+  const session = parseSession(content);
+  const subagentFile = await findSubagentFile(jsonlPath, agentId);
+  if (!subagentFile) return { error: "Agent not found" };
+  const subagentContent = await (0, import_promises3.readFile)(subagentFile.filePath, "utf-8");
+  const subagentSession = parseSession(subagentContent);
+  const metadata = findAgentMetadata(session, agentId);
+  const parentToolCallId = findParentToolCallId(session, agentId);
+  const teamContext = await findTeamContext(sessionId, subagentFile.fileName);
+  return {
+    sessionId,
+    agentId,
+    name: metadata.name,
+    type: metadata.type,
+    parentToolCallId,
+    isBackground: metadata.isBackground,
+    teamContext,
+    overview: mapSessionToOverview(subagentSession)
+  };
+}
+async function getAgentTurnDetail(sessionId, agentId, turnIndex) {
+  const jsonlPath = await findJsonlPath(sessionId);
+  if (!jsonlPath) return { error: "Session not found" };
+  const content = await (0, import_promises3.readFile)(jsonlPath, "utf-8");
+  const subagentFile = await findSubagentFile(jsonlPath, agentId);
+  if (!subagentFile) return { error: "Agent not found" };
+  const subagentContent = await (0, import_promises3.readFile)(subagentFile.filePath, "utf-8");
+  const subagentSession = parseSession(subagentContent);
+  if (turnIndex < 0 || turnIndex >= subagentSession.turns.length) return { error: "Turn not found" };
+  return mapTurnToDetail(subagentSession, turnIndex);
+}
+
+// src/commands/sessions.ts
+var import_promises5 = require("node:fs/promises");
+var import_node_path6 = require("node:path");
+
+// src/lib/metadata.ts
+var import_promises4 = require("node:fs/promises");
+
+// src/lib/sessionStatus.ts
+function deriveSessionStatus(rawMessages) {
+  let pendingEnqueues = 0;
+  function result(status, toolName) {
+    const info = { status, pendingQueue: Math.max(0, pendingEnqueues) };
+    if (toolName) info.toolName = toolName;
+    return info;
+  }
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const msg = rawMessages[i];
+    if (msg.type === "queue-operation") {
+      const op = msg.operation;
+      if (op === "enqueue") pendingEnqueues++;
+      else if (op === "dequeue" || op === "remove") pendingEnqueues--;
+      continue;
+    }
+    if (msg.type === "assistant") {
+      const message = msg.message;
+      const stopReason = message?.stop_reason;
+      if (stopReason === "end_turn") {
+        let hasActivity = false;
+        for (let j = i - 1; j >= 0; j--) {
+          const m = rawMessages[j];
+          if (m.type === "user" && !m.isMeta) {
+            hasActivity = true;
+            break;
+          }
+        }
+        return result(hasActivity ? "completed" : "idle");
+      }
+      if (stopReason === "tool_use") {
+        const content = message?.content;
+        const toolUseBlock = content?.findLast?.((b) => b.type === "tool_use");
+        return result("tool_use", toolUseBlock?.name);
+      }
+      return result("thinking");
+    }
+    if (msg.type === "user") {
+      const isMeta = msg.isMeta;
+      if (isMeta) continue;
+      return result("processing");
+    }
+    if (msg.type === "summary") return result("compacting");
+  }
+  return { status: "idle" };
+}
+
+// src/lib/metadata.ts
+async function getSessionMeta(filePath) {
+  let lines;
+  let isPartialRead = false;
+  const fileStat = await (0, import_promises4.stat)(filePath);
+  if (fileStat.size > 65536) {
+    const fh = await (0, import_promises4.open)(filePath, "r");
+    try {
+      const buf = Buffer.alloc(32768);
+      const { bytesRead } = await fh.read(buf, 0, 32768, 0);
+      const text = buf.subarray(0, bytesRead).toString("utf-8");
+      const lastNewline = text.lastIndexOf("\n");
+      lines = (lastNewline > 0 ? text.slice(0, lastNewline) : text).split("\n").filter(Boolean);
+      isPartialRead = true;
+    } finally {
+      await fh.close();
+    }
+  } else {
+    const content = await (0, import_promises4.readFile)(filePath, "utf-8");
+    lines = content.split("\n").filter(Boolean);
+  }
+  let sessionId = "";
+  let version = "";
+  let gitBranch = "";
+  let model = "";
+  let slug = "";
+  let cwd = "";
+  let firstUserMessage = "";
+  let lastUserMessage = "";
+  let timestamp = "";
+  let turnCount = 0;
+  let branchedFrom;
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.sessionId && !sessionId) sessionId = obj.sessionId;
+      if (obj.version && !version) version = obj.version;
+      if (obj.gitBranch && !gitBranch) gitBranch = obj.gitBranch;
+      if (obj.slug && !slug) slug = obj.slug;
+      if (obj.cwd && !cwd) cwd = obj.cwd;
+      if (obj.branchedFrom && !branchedFrom) branchedFrom = obj.branchedFrom;
+      if (obj.type === "assistant" && obj.message?.model && !model) {
+        model = obj.message.model;
+      }
+      if (obj.type === "user" && !obj.isMeta && !timestamp) {
+        timestamp = obj.timestamp || "";
+      }
+      if (obj.type === "user" && !obj.isMeta) {
+        const c = obj.message?.content;
+        let extracted = "";
+        if (typeof c === "string") {
+          const cleaned = c.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, "").trim();
+          if (cleaned && cleaned.length > 5) extracted = cleaned.slice(0, 120);
+        } else if (Array.isArray(c)) {
+          for (const block of c) {
+            if (block.type === "text") {
+              const cleaned = block.text.replace(/<[^>]+>[\s\S]*?<\/[^>]+>/g, "").trim();
+              if (cleaned && cleaned.length > 5) {
+                extracted = cleaned.slice(0, 120);
+                break;
+              }
+            }
+          }
+        }
+        if (extracted) {
+          if (!firstUserMessage) firstUserMessage = extracted;
+          lastUserMessage = extracted;
+        }
+        turnCount++;
+      }
+    } catch {
+    }
+  }
+  return {
+    sessionId,
+    version,
+    gitBranch,
+    model,
+    slug,
+    cwd,
+    firstUserMessage,
+    lastUserMessage,
+    timestamp,
+    turnCount,
+    lineCount: isPartialRead ? Math.round(fileStat.size / (32768 / lines.length)) : lines.length,
+    branchedFrom
+  };
+}
+async function getSessionStatus(filePath) {
+  const CHUNK = 4096;
+  const MAX_CHUNKS = 64;
+  try {
+    const fileStat = await (0, import_promises4.stat)(filePath);
+    if (fileStat.size === 0) return { status: "idle" };
+    const fh = await (0, import_promises4.open)(filePath, "r");
+    try {
+      const meaningful = [];
+      let cursor = fileStat.size;
+      let leftover = "";
+      for (let chunk = 0; chunk < MAX_CHUNKS && cursor > 0; chunk++) {
+        const readSize = Math.min(CHUNK, cursor);
+        cursor -= readSize;
+        const buf = Buffer.alloc(readSize);
+        const { bytesRead } = await fh.read(buf, 0, readSize, cursor);
+        const text = buf.subarray(0, bytesRead).toString("utf-8") + leftover;
+        const lines = text.split("\n");
+        leftover = cursor > 0 ? lines[0] : "";
+        const startIdx = cursor > 0 ? 1 : 0;
+        for (let i = lines.length - 1; i >= startIdx; i--) {
+          const line = lines[i];
+          if (!line) continue;
+          let obj;
+          try {
+            obj = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          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";
+            const canDerive = obj.type === "assistant" && !isEndTurn || obj.type === "user" && !obj.isMeta;
+            if (canDerive) return deriveSessionStatus(meaningful);
+          }
+        }
+      }
+      return meaningful.length > 0 ? deriveSessionStatus(meaningful) : { status: "idle" };
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return { status: "idle" };
+  }
+}
+
+// src/commands/sessions.ts
+async function listSessions(opts = {}) {
+  const limit = Math.min(Math.max(1, opts.limit ?? 20), 100);
+  const maxAgeMs = parseMaxAge(opts.maxAge ?? "7d");
+  const cutoff = Date.now() - maxAgeMs;
+  let entries;
+  try {
+    entries = await (0, import_promises5.readdir)(dirs.PROJECTS_DIR, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const projectDirs = entries.filter((e) => e.isDirectory() && e.name !== "memory").map((e) => (0, import_node_path6.join)(dirs.PROJECTS_DIR, e.name));
+  const nested = await Promise.all(
+    projectDirs.map(async (projectDir) => {
+      try {
+        const files = await (0, import_promises5.readdir)(projectDir);
+        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+        const statResults = await Promise.all(
+          jsonlFiles.map(async (f) => {
+            const filePath = (0, import_node_path6.join)(projectDir, f);
+            try {
+              const s = await (0, import_promises5.stat)(filePath);
+              return s.mtimeMs >= cutoff ? { path: filePath, mtimeMs: s.mtimeMs } : null;
+            } catch {
+              return null;
+            }
+          })
+        );
+        return statResults.filter((r) => r !== null);
+      } catch {
+        return [];
+      }
+    })
+  );
+  const allFiles = nested.flat();
+  allFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const results = [];
+  for (const file of allFiles) {
+    if (results.length >= limit) break;
+    try {
+      const [meta, statusInfo] = await Promise.all([
+        getSessionMeta(file.path),
+        getSessionStatus(file.path)
+      ]);
+      if (opts.cwd && meta.cwd !== opts.cwd) continue;
+      results.push({
+        sessionId: meta.sessionId,
+        timestamp: meta.timestamp,
+        model: meta.model,
+        cwd: meta.cwd,
+        gitBranch: meta.gitBranch,
+        slug: meta.slug,
+        firstMessage: meta.firstUserMessage,
+        lastMessage: meta.lastUserMessage,
+        turnCount: meta.turnCount,
+        status: statusInfo.status,
+        mtime: file.mtimeMs
+      });
+    } catch {
+    }
+  }
+  return results;
+}
+async function currentSession(cwd) {
+  const projectDirName = cwd.replace(/[/.]/g, "-");
+  const projectDir = (0, import_node_path6.join)(dirs.PROJECTS_DIR, projectDirName);
+  let files;
+  try {
+    files = await (0, import_promises5.readdir)(projectDir);
+  } catch {
+    return null;
+  }
+  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);
+      try {
+        const s = await (0, import_promises5.stat)(filePath);
+        return { path: filePath, mtimeMs: s.mtimeMs };
+      } catch {
+        return null;
+      }
+    })
+  );
+  const valid = statResults.filter((r) => r !== null);
+  valid.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const latest = valid[0];
+  if (!latest) return null;
+  const [meta, statusInfo] = await Promise.all([
+    getSessionMeta(latest.path),
+    getSessionStatus(latest.path)
+  ]);
+  return {
+    sessionId: meta.sessionId,
+    timestamp: meta.timestamp,
+    model: meta.model,
+    cwd: meta.cwd,
+    gitBranch: meta.gitBranch,
+    slug: meta.slug,
+    firstMessage: meta.firstUserMessage,
+    lastMessage: meta.lastUserMessage,
+    turnCount: meta.turnCount,
+    status: statusInfo.status,
+    mtime: latest.mtimeMs
+  };
+}
+
+// src/commands/index-cmd.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path7 = require("node:path");
+async function indexStats(dbPath) {
+  const path = dbPath ?? DEFAULT_DB_PATH;
+  if (!(0, import_node_fs3.existsSync)(path)) {
+    return { error: `Database not found at ${path}. Run 'cogpit-memory index rebuild' to create it.` };
+  }
+  const index = new SearchIndex(path);
+  const stats = index.getStats();
+  index.close();
+  return stats;
+}
+async function indexRebuild(dbPath) {
+  const path = dbPath ?? DEFAULT_DB_PATH;
+  (0, import_node_fs3.mkdirSync)((0, import_node_path7.dirname)(path), { recursive: true });
+  const index = new SearchIndex(path);
+  index.buildFull(dirs.PROJECTS_DIR);
+  const stats = index.getStats();
+  index.close();
+  return { status: "rebuilt", stats };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DB_PATH,
+  SearchIndex,
+  currentSession,
+  dirs,
+  getAgentOverview,
+  getAgentTurnDetail,
+  getSessionOverview,
+  getTurnDetail,
+  getUserMessageImages,
+  getUserMessageText,
+  indexRebuild,
+  indexStats,
+  listSessions,
+  parseSession,
+  parseSessionAppend,
+  searchSessions
+});