codesesh 0.19.0 → 1.0.0

package/dist/{chunk-G2BTNW3C.js → chunk-BEF6LLRG.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../core/dist/chunk-B67H5WZJ.mjs
+// ../core/dist/chunk-TXYCGCSU.mjs
 function toRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -253,14 +253,20 @@ function mergeSortedSessions(shards) {
   }
   return merged;
 }
-function referenceKey(reference) {
-  return `${reference.agentName.trim().toLowerCase()}\0${reference.sessionId}`;
+function getSessionRouteKey(agentName, sessionId) {
+  return formatSessionReference({ agentName, sessionId });
 }
 function sessionKey(session) {
-  return `${getSessionAgentKey(session)}\0${session.id}`;
+  return getSessionRouteKey(getSessionAgentKey(session), session.id);
+}
+function parentKey(session) {
+  return session.parent_reference ? formatSessionReference(session.parent_reference) : null;
+}
+function activityTime(session) {
+  return session.time_updated ?? session.time_created;
 }
 function hasActivityInWindow(session, from, to) {
-  const activity = session.time_updated ?? session.time_created;
+  const activity = activityTime(session);
   return (from == null || activity >= from) && (to == null || activity <= to);
 }
 function isChildSession(session) {
@@ -269,20 +275,129 @@ function isChildSession(session) {
 function getRootSessions(sessions) {
   return sessions.filter((session) => !session.parent_reference);
 }
+function ownStats(session) {
+  const stats = session.stats;
+  const cost = stats.total_cost ?? 0;
+  return {
+    messageCount: stats.message_count,
+    inputTokens: stats.total_input_tokens,
+    outputTokens: stats.total_output_tokens,
+    cacheReadTokens: stats.total_cache_read_tokens ?? 0,
+    cacheCreateTokens: stats.total_cache_create_tokens ?? 0,
+    totalTokens: stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens,
+    cost,
+    costSource: cost > 0 ? stats.cost_source ?? "recorded" : void 0
+  };
+}
+function addStats(target, source) {
+  target.messageCount += source.messageCount;
+  target.inputTokens += source.inputTokens;
+  target.outputTokens += source.outputTokens;
+  target.cacheReadTokens += source.cacheReadTokens;
+  target.cacheCreateTokens += source.cacheCreateTokens;
+  target.totalTokens += source.totalTokens;
+  target.cost += source.cost;
+  if (source.costSource === "estimated") target.costSource = "estimated";
+}
+function rollUpSubtree(entry) {
+  const order = [];
+  const pending2 = [entry];
+  while (pending2.length > 0) {
+    const node = pending2.pop();
+    order.push(node);
+    for (const child of node.children) pending2.push(child);
+  }
+  for (let index = order.length - 1; index >= 0; index -= 1) {
+    const node = order[index];
+    const stats = node.inclusiveStats;
+    let descendants = 0;
+    for (const child of node.children) {
+      descendants += 1 + child.descendantCount;
+      addStats(stats, child.inclusiveStats);
+    }
+    if (stats.cost > 0 && stats.costSource == null) stats.costSource = "recorded";
+    node.descendantCount = descendants;
+  }
+}
+function buildSessionTree(sessions) {
+  const byRouteKey = /* @__PURE__ */ new Map();
+  const nodes = sessions.map((session) => ({
+    session,
+    children: [],
+    descendantCount: 0,
+    inclusiveStats: ownStats(session)
+  }));
+  for (const node of nodes) {
+    const key = sessionKey(node.session);
+    if (!byRouteKey.has(key)) byRouteKey.set(key, node);
+  }
+  const chainTerminates = /* @__PURE__ */ new Map();
+  function reachesRoot(startKey) {
+    const path2 = [];
+    const onPath = /* @__PURE__ */ new Set();
+    let key = startKey;
+    let terminates = true;
+    while (key != null) {
+      const memo = chainTerminates.get(key);
+      if (memo != null) {
+        terminates = memo;
+        break;
+      }
+      if (onPath.has(key)) {
+        terminates = false;
+        break;
+      }
+      onPath.add(key);
+      path2.push(key);
+      const parent = parentKey(byRouteKey.get(key).session);
+      key = parent != null && byRouteKey.has(parent) ? parent : null;
+    }
+    for (const visited of path2) chainTerminates.set(visited, terminates);
+    return terminates;
+  }
+  const mountStates = /* @__PURE__ */ new Map();
+  const roots = [];
+  const orphans = [];
+  const entries = [];
+  for (const node of nodes) {
+    const key = sessionKey(node.session);
+    const parent = parentKey(node.session);
+    const state = parent == null ? "root" : byRouteKey.has(parent) && reachesRoot(key) ? "mounted-child" : "orphan";
+    mountStates.set(key, state);
+    if (state === "mounted-child") {
+      byRouteKey.get(parent).children.push(node);
+      continue;
+    }
+    (state === "root" ? roots : orphans).push(node);
+    entries.push(node);
+  }
+  for (const entry of entries) rollUpSubtree(entry);
+  return {
+    roots,
+    orphans,
+    entries,
+    byRouteKey,
+    mountStateOf(session) {
+      return mountStates.get(sessionKey(session)) ?? (session.parent_reference ? "orphan" : "root");
+    }
+  };
+}
 function filterSessionTreeByActivityWindow(sessions, from, to) {
   if (from == null && to == null) return sessions;
   const available = new Set(sessions.map(sessionKey));
   const childrenByParent = /* @__PURE__ */ new Map();
+  const pending2 = [];
   for (const session of sessions) {
-    const parent = session.parent_reference;
-    if (!parent || !available.has(referenceKey(parent))) continue;
-    const parentKey = referenceKey(parent);
-    const children = childrenByParent.get(parentKey);
-    if (children) children.push(sessionKey(session));
-    else childrenByParent.set(parentKey, [sessionKey(session)]);
+    const parent = parentKey(session);
+    if (parent != null && available.has(parent)) {
+      const children = childrenByParent.get(parent);
+      if (children) children.push(sessionKey(session));
+      else childrenByParent.set(parent, [sessionKey(session)]);
+      continue;
+    }
+    if (hasActivityInWindow(session, from, to)) pending2.push(sessionKey(session));
   }
   const visible = /* @__PURE__ */ new Set();
-  const pending2 = getRootSessions(sessions).filter((session) => hasActivityInWindow(session, from, to)).map(sessionKey);
   while (pending2.length > 0) {
     const key = pending2.pop();
     if (visible.has(key)) continue;
@@ -339,9 +454,15 @@ var SAMPLE_DASHBOARD_DATA = {
     messages: 12,
     tokens: 6e3,
     cost: 0.042,
+    costRecorded: 0.042,
+    costEstimated: 0,
+    cacheReadTokens: 3e3,
     cost_source: "recorded",
-    latestActivity: 17000036e5
+    latestActivity: 17000036e5,
+    latestActivityProject: "example/project",
+    latestActivityAgent: "claudecode"
   },
+  scopeCounts: { projects: 1, agents: 1 },
   perAgent: [
     {
       name: "claudecode",
@@ -349,14 +470,38 @@ var SAMPLE_DASHBOARD_DATA = {
       icon: "claude",
       sessions: 1,
       messages: 12,
-      tokens: 6e3
+      tokens: 6e3,
+      cost: 0.042
     }
   ],
-  dailyActivity: [{ date: "2023-11-14", sessions: 1, messages: 12 }],
-  dailyTokenActivity: [
-    { date: "2023-11-14", input: 700, output: 1800, cache_read: 3e3, cache_create: 500 }
+  dailyActivity: [
+    {
+      date: "2023-11-14",
+      sessions: 1,
+      messages: 12,
+      cost: 0.042,
+      input: 700,
+      output: 1800,
+      cache_read: 3e3,
+      cache_create: 500
+    }
   ],
   modelDistribution: [{ model: "claude-5-sonnet", tokens: 6e3, sessions: 1 }],
+  perProject: [
+    {
+      identityKind: "git_remote",
+      identityKey: "github.com/example/project",
+      displayName: "example/project",
+      sessions: 1,
+      messages: 12,
+      tokens: 6e3,
+      cost: 0.042,
+      cost_source: "recorded",
+      agents: ["claudecode"],
+      sparkline: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.042]
+    }
+  ],
+  projectRollup: { projects: 0, sessions: 0, tokens: 0, cost: 0 },
   recentSessions: [
     {
       reference: { agentName: "claudecode", sessionId: SAMPLE_SESSION_HEAD.id },
@@ -364,6 +509,7 @@ var SAMPLE_DASHBOARD_DATA = {
     }
   ],
   recentFileActivities: [],
+  modelCost: null,
   window: { from: 16999e8, to: 17000036e5, days: 1 }
 };
 
@@ -409,19 +555,21 @@ import { existsSync as existsSync11 } from "fs";
 import { basename as basename8, join as join12 } from "path";
 import { homedir as homedir4, platform as platform3 } from "os";
 import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync7, statSync as statSync8 } from "fs";
+import { dirname as dirname6, join as join14 } from "path";
 import { availableParallelism } from "os";
 import { Worker } from "worker_threads";
-import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
 import { spawnSync } from "child_process";
 import * as os from "os";
 import * as path from "path";
 import { resolve as resolve2, sep } from "path";
-import { existsSync as existsSync14, rmSync as rmSync2, unlinkSync } from "fs";
-import { existsSync as existsSync13 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, rmSync as rmSync2, unlinkSync } from "fs";
+import { existsSync as existsSync14 } from "fs";
+import { join as join15 } from "path";
 import { homedir as homedir6 } from "os";
 import { homedir as homedir7, platform as platform4 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var registrations = [];
 function registerAgent(reg) {
   registrations.push(reg);
@@ -480,9 +628,9 @@ function filteredSession(reason) {
 function getParsedSession(result) {
   return result.status === "parsed" ? result.data : null;
 }
-function matchesScanWindow(activityTime, options) {
-  if (options?.from != null && activityTime < options.from) return false;
-  if (options?.to != null && activityTime > options.to) return false;
+function matchesScanWindow(activityTime2, options) {
+  if (options?.from != null && activityTime2 < options.from) return false;
+  if (options?.to != null && activityTime2 > options.to) return false;
   return true;
 }
 function readCachedMeta(meta, sessionId) {
@@ -2491,7 +2639,7 @@ function runSchemaMigrations(db, options) {
         migration.migrate(db);
         setUserVersion(db, migration.version);
       });
-      apply();
+      apply.immediate();
       currentVersion = migration.version;
       getCoreDiagnostics()?.info?.("sqlite.migration.completed", {
         label: options.backupLabel,
@@ -2545,10 +2693,10 @@ function openDb(dbPath) {
     const db = DatabaseConstructor(dbPath);
     restrictPrivateDatabase(dbPath);
     try {
+      db.pragma("busy_timeout = 5000");
       db.pragma("journal_mode = WAL");
       db.pragma("synchronous = NORMAL");
       db.pragma("foreign_keys = ON");
-      db.pragma("busy_timeout = 5000");
     } catch {
     }
     return db;
@@ -5506,13 +5654,13 @@ var CodexAgent = class extends SingleFileSessionSource {
     const planMatch = fullText.match(PROPOSED_PLAN_PATTERN);
     if (planMatch) {
       const planText2 = planMatch[1].trim();
-      const planPart = {
+      const planPart2 = {
         type: "plan",
         text: planText2,
         approval_status: "success",
         time_created: timestampMs
       };
-      pendingPlan = planPart;
+      pendingPlan = planPart2;
     }
     const displayText = cleanInternalText(fullText.replace(PROPOSED_PLAN_PATTERN, ""));
     if (!displayText) return pendingPlan;
@@ -7081,6 +7229,726 @@ var ZCodeAgent = class extends OpenCodeSqliteAgent {
     });
   }
 };
+var HEAD_INDEX_VERSION4 = "grok-head-v1";
+var PARSER_VERSION3 = "grok-parser-v1";
+var SUMMARY_FILE = "summary.json";
+var UPDATES_FILE = "updates.jsonl";
+var ACP_UPDATE_METHOD = "session/update";
+var XAI_UPDATE_METHOD = "_x.ai/session/update";
+var USD_TICKS_PER_USD = 1e10;
+var GROK_TOOL_TITLE_MAP = {
+  get_command_or_subagent_output: "task",
+  grep: "grep",
+  list_dir: "list",
+  read_file: "read",
+  run_terminal_command: "bash",
+  search_replace: "edit",
+  todo_write: "todo",
+  web_fetch: "web fetch"
+};
+function resolveGrokDataRoot() {
+  return resolveHomePath("GROK_HOME", ".grok");
+}
+function safeCount(value) {
+  const number = asNumber(value);
+  return number !== void 0 && Number.isSafeInteger(number) && number >= 0 ? number : 0;
+}
+function addCount(total, value) {
+  return Math.min(Number.MAX_SAFE_INTEGER, total + value);
+}
+function timestampFromIso(value) {
+  const text = asString(value);
+  if (!text) return null;
+  const timestamp = Date.parse(text);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+function readJsonRecord(filePath) {
+  try {
+    return asRecord(JSON.parse(readFileSync7(filePath, "utf8"))) ?? null;
+  } catch {
+    return null;
+  }
+}
+function parseSummary(source) {
+  const summary = readJsonRecord(source.file);
+  const info = asRecord(summary?.info);
+  const id = asString(info?.id)?.trim();
+  const cwd = asString(info?.cwd)?.trim();
+  if (!id || !cwd) return null;
+  const createdAt = timestampFromIso(summary?.created_at) ?? source.stat.mtimeMs;
+  const updatedAt = timestampFromIso(summary?.last_active_at) ?? timestampFromIso(summary?.updated_at) ?? createdAt;
+  const generatedTitle = asString(summary?.generated_title)?.trim();
+  const sessionSummary = asString(summary?.session_summary)?.trim();
+  const parentSessionId = asString(summary?.parent_session_id)?.trim() || null;
+  return {
+    id,
+    cwd,
+    title: generatedTitle || sessionSummary || null,
+    createdAt,
+    updatedAt,
+    messageCount: safeCount(summary?.num_chat_messages),
+    currentModel: asString(summary?.current_model_id)?.trim() || null,
+    parentSessionId: parentSessionId === id ? null : parentSessionId
+  };
+}
+function optionalFileFingerprint(filePath) {
+  try {
+    const stat = statSync8(filePath);
+    return [stat.mtimeMs, stat.size];
+  } catch {
+    return null;
+  }
+}
+function unpackUpdate(record, fallbackTimestampMs) {
+  const method = asString(record.method) ?? ACP_UPDATE_METHOD;
+  const params = asRecord(record.params) ?? record;
+  const update = asRecord(params.update);
+  if (!update) return null;
+  const paramsMeta = asRecord(params._meta);
+  const agentTimestampMs = asNumber(paramsMeta?.agentTimestampMs);
+  const envelopeTimestamp = asNumber(record.timestamp);
+  const timestampMs = agentTimestampMs !== void 0 && Number.isSafeInteger(agentTimestampMs) && agentTimestampMs >= 0 ? agentTimestampMs : envelopeTimestamp !== void 0 && Number.isSafeInteger(envelopeTimestamp) && envelopeTimestamp >= 0 && envelopeTimestamp <= Number.MAX_SAFE_INTEGER / 1e3 ? envelopeTimestamp * 1e3 : fallbackTimestampMs;
+  return { method, params, update, timestampMs };
+}
+function isHostTurn(update) {
+  return asRecord(update._meta)?.hostTurn === true;
+}
+function updateType(update) {
+  return asString(update.update.sessionUpdate) ?? "";
+}
+function parseUsage(update) {
+  const usage = asRecord(update.usage);
+  if (!usage) return null;
+  const input = safeCount(usage.inputTokens);
+  const output = safeCount(usage.outputTokens);
+  const reasoning = safeCount(usage.reasoningTokens);
+  const cacheRead = safeCount(usage.cachedReadTokens);
+  const cacheCreate = safeCount(usage.cacheCreationTokens);
+  const totalTokens = safeCount(usage.totalTokens) || addCount(input, output);
+  const isIncomplete = usage.usageIsIncomplete === true || usage.costIsPartial === true;
+  const costTicks = safeCount(usage.costUsdTicks);
+  const cost = !isIncomplete && costTicks > 0 ? costTicks / USD_TICKS_PER_USD : null;
+  const modelUsage = {};
+  const modelUsageRecord = asRecord(usage.modelUsage);
+  if (modelUsageRecord) {
+    for (const [model, rawUsage] of Object.entries(modelUsageRecord)) {
+      const modelRecord = asRecord(rawUsage);
+      if (!modelRecord) continue;
+      const modelTotal = safeCount(modelRecord.totalTokens) || addCount(safeCount(modelRecord.inputTokens), safeCount(modelRecord.outputTokens));
+      if (modelTotal > 0) modelUsage[model] = modelTotal;
+    }
+  }
+  const models = Object.keys(modelUsage);
+  return {
+    tokens: {
+      input,
+      output,
+      reasoning: reasoning || void 0,
+      cache_read: cacheRead || void 0,
+      cache_create: cacheCreate || void 0
+    },
+    totalTokens,
+    cost,
+    modelUsage,
+    primaryModel: models.length === 1 ? models[0] : null
+  };
+}
+function textFromContentBlock(value) {
+  const content = asRecord(value);
+  if (!content) return "";
+  if (content.type === "text") return asString(content.text) ?? "";
+  const resource = asRecord(content.resource);
+  return asString(resource?.text) ?? "";
+}
+function messagePartFromContentBlock(value, timestampMs) {
+  const content = asRecord(value);
+  if (!content) return null;
+  if (content.type === "text") {
+    const text2 = asString(content.text) ?? "";
+    return text2 ? { type: "text", text: text2, time_created: timestampMs } : null;
+  }
+  if (content.type === "image") {
+    const data = asString(content.data);
+    const url = asString(content.uri) ?? asString(content.url);
+    const mimeType = asString(content.mimeType) ?? asString(content.mime_type);
+    if (data && mimeType) {
+      return { type: "image", data, mime_type: mimeType, url, time_created: timestampMs };
+    }
+    if (url) return { type: "image", url, mime_type: mimeType, time_created: timestampMs };
+  }
+  const text = textFromContentBlock(content);
+  return text ? { type: "text", text, time_created: timestampMs } : null;
+}
+var GrokMessageCounter = class {
+  firstUserText = null;
+  messageCount = 0;
+  activeAssistant = false;
+  activeAssistantPromptId = null;
+  activeUser = false;
+  activeUserPromptIndex = null;
+  process(envelope) {
+    if (envelope.method === XAI_UPDATE_METHOD) return;
+    switch (updateType(envelope)) {
+      case "user_message_chunk":
+        this.appendUser(envelope);
+        break;
+      case "agent_thought_chunk":
+      case "agent_message_chunk":
+        if (cleanInternalText(textFromContentBlock(envelope.update.content))) {
+          this.appendAssistant(envelope);
+        }
+        break;
+      case "tool_call":
+        if (asString(envelope.update.toolCallId)?.trim()) this.appendAssistant(envelope);
+        break;
+      case "plan":
+        if (planPart(envelope.update, envelope.timestampMs)) this.appendAssistant(envelope);
+        break;
+    }
+  }
+  appendUser(envelope) {
+    if (isHostTurn(envelope.update)) return;
+    const part = messagePartFromContentBlock(envelope.update.content, envelope.timestampMs);
+    if (!part) return;
+    if (part.type === "text" && !cleanInternalText(part.text)) return;
+    const promptIndexValue = asNumber(asRecord(envelope.update._meta)?.promptIndex);
+    const promptIndex = promptIndexValue !== void 0 && Number.isSafeInteger(promptIndexValue) ? promptIndexValue : null;
+    const canReuse = this.activeUser && (promptIndex === null || this.activeUserPromptIndex === null || promptIndex === this.activeUserPromptIndex);
+    if (!canReuse) this.messageCount += 1;
+    if (this.firstUserText === null && part.type === "text") {
+      this.firstUserText = cleanInternalText(part.text) || null;
+    }
+    this.activeUser = true;
+    this.activeUserPromptIndex = promptIndex;
+    this.activeAssistant = false;
+    this.activeAssistantPromptId = null;
+  }
+  appendAssistant(envelope) {
+    const promptId = asString(asRecord(envelope.params._meta)?.promptId)?.trim() || null;
+    if (promptId && this.activeAssistantPromptId && promptId !== this.activeAssistantPromptId) {
+      this.activeAssistant = false;
+    }
+    if (promptId) this.activeAssistantPromptId = promptId;
+    this.activeUser = false;
+    this.activeUserPromptIndex = null;
+    if (!this.activeAssistant) this.messageCount += 1;
+    this.activeAssistant = true;
+  }
+};
+function scanCanonicalMessages(updatesPath, fallbackTimestampMs) {
+  const rewindIndex = new RewindIndex();
+  let recordIndex = 0;
+  for (const record of readJsonlFile(updatesPath)) {
+    rewindIndex.process(record, recordIndex, fallbackTimestampMs);
+    recordIndex += 1;
+  }
+  const survivingIndexes = new Set(rewindIndex.survivingRecordIndexes);
+  const counter = new GrokMessageCounter();
+  recordIndex = 0;
+  for (const record of readJsonlFile(updatesPath)) {
+    if (survivingIndexes.has(recordIndex)) {
+      const envelope = unpackUpdate(record, fallbackTimestampMs);
+      if (envelope) counter.process(envelope);
+    }
+    recordIndex += 1;
+  }
+  return counter;
+}
+function scanHeadData(updatesPath, fallbackTimestampMs) {
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheCreateTokens = 0;
+  let totalTokens = 0;
+  let totalCost = 0;
+  let hasUnknownCost = false;
+  let hasRewinds = false;
+  const modelUsage = {};
+  let messageCounter = new GrokMessageCounter();
+  if (updatesPath && existsSync12(updatesPath)) {
+    for (const line of readJsonlFileLines(updatesPath)) {
+      const affectsMessages = line.includes('"user_message_chunk"') || line.includes('"agent_thought_chunk"') || line.includes('"agent_message_chunk"') || line.includes('"tool_call"') || line.includes('"plan"');
+      const isTurnCompleted = line.includes('"turn_completed"');
+      const isRewind = line.includes('"rewind_marker"');
+      if (!affectsMessages && !isTurnCompleted && !isRewind) continue;
+      let record;
+      try {
+        record = asRecord(JSON.parse(line)) ?? {};
+      } catch {
+        continue;
+      }
+      const envelope = unpackUpdate(record, fallbackTimestampMs);
+      if (!envelope) continue;
+      const type = updateType(envelope);
+      if (affectsMessages) messageCounter.process(envelope);
+      if (envelope.method === XAI_UPDATE_METHOD && type === "rewind_marker") {
+        hasRewinds = true;
+      }
+      if (envelope.method !== XAI_UPDATE_METHOD || type !== "turn_completed") continue;
+      const usage = parseUsage(envelope.update);
+      if (!usage) continue;
+      totalInputTokens = addCount(totalInputTokens, usage.tokens.input ?? 0);
+      totalOutputTokens = addCount(totalOutputTokens, usage.tokens.output ?? 0);
+      totalCacheReadTokens = addCount(totalCacheReadTokens, usage.tokens.cache_read ?? 0);
+      totalCacheCreateTokens = addCount(totalCacheCreateTokens, usage.tokens.cache_create ?? 0);
+      totalTokens = addCount(totalTokens, usage.totalTokens);
+      if (usage.cost === null && usage.totalTokens > 0) hasUnknownCost = true;
+      else totalCost += usage.cost ?? 0;
+      for (const [model, tokens] of Object.entries(usage.modelUsage)) {
+        modelUsage[model] = addCount(modelUsage[model] ?? 0, tokens);
+      }
+    }
+    if (hasRewinds) messageCounter = scanCanonicalMessages(updatesPath, fallbackTimestampMs);
+  }
+  return {
+    firstUserText: messageCounter.firstUserText,
+    visibleMessageCount: messageCounter.messageCount,
+    stats: {
+      total_input_tokens: totalInputTokens,
+      total_output_tokens: totalOutputTokens,
+      total_cache_read_tokens: totalCacheReadTokens || void 0,
+      total_cache_create_tokens: totalCacheCreateTokens || void 0,
+      total_tokens: totalTokens || addCount(totalInputTokens, totalOutputTokens),
+      total_cost: totalCost,
+      cost_source: totalCost > 0 && !hasUnknownCost ? "recorded" : void 0
+    },
+    modelUsage
+  };
+}
+function toolTitle(toolName) {
+  return GROK_TOOL_TITLE_MAP[toolName] ?? toolName;
+}
+function toolStatus(value) {
+  switch (asString(value)?.toLowerCase()) {
+    case "completed":
+      return "completed";
+    case "failed":
+      return "error";
+    case "in_progress":
+    case "pending":
+      return "running";
+    default:
+      return null;
+  }
+}
+function toolOutput(update) {
+  if (update.rawOutput !== void 0 && update.rawOutput !== null) return update.rawOutput;
+  const content = asArray(update.content);
+  if (!content) return void 0;
+  const texts = content.flatMap((item) => {
+    const wrapper = asRecord(item);
+    const block = wrapper?.type === "content" ? wrapper.content : item;
+    const text = textFromContentBlock(block);
+    return text ? [text] : [];
+  });
+  if (texts.length === 0) return content;
+  return texts.join("\n");
+}
+function planPart(update, timestampMs) {
+  const entries = asArray(update.entries)?.flatMap((value) => {
+    const entry = asRecord(value);
+    const content = cleanInternalText(asString(entry?.content) ?? "");
+    if (!entry || !content) return [];
+    return [{ content, status: asString(entry.status) ?? "pending" }];
+  });
+  if (!entries || entries.length === 0) return null;
+  const text = entries.map(({ content, status }) => `- [${status === "completed" ? "x" : " "}] ${content}`).join("\n");
+  return {
+    type: "plan",
+    text,
+    approval_status: entries.every(({ status }) => status === "completed") ? "success" : "fail",
+    time_created: timestampMs
+  };
+}
+var GrokTranscriptReducer = class {
+  constructor(sessionId, currentModel, fallbackTimestampMs) {
+    this.sessionId = sessionId;
+    this.fallbackTimestampMs = fallbackTimestampMs;
+    this.currentModel = currentModel;
+  }
+  sessionId;
+  fallbackTimestampMs;
+  builder = new TranscriptBuilder();
+  activeAssistant = null;
+  activeAssistantPromptId = null;
+  activeUser = null;
+  activeUserPromptIndex = null;
+  latestPlan = null;
+  currentMode = null;
+  currentModel;
+  process(record) {
+    const envelope = unpackUpdate(record, this.fallbackTimestampMs);
+    if (!envelope) return;
+    if (envelope.method === XAI_UPDATE_METHOD) {
+      this.processXaiUpdate(envelope);
+      return;
+    }
+    this.processAcpUpdate(envelope);
+  }
+  finish(stats) {
+    return this.builder.finish(stats);
+  }
+  processAcpUpdate(envelope) {
+    switch (updateType(envelope)) {
+      case "user_message_chunk":
+        this.appendUserChunk(envelope);
+        break;
+      case "agent_thought_chunk":
+        this.appendAssistantText(envelope, "reasoning");
+        break;
+      case "agent_message_chunk":
+        this.appendAssistantText(envelope, "text");
+        break;
+      case "tool_call":
+        this.appendToolCall(envelope);
+        break;
+      case "tool_call_update":
+        this.updateToolCall(envelope);
+        break;
+      case "plan":
+        this.updatePlan(envelope);
+        break;
+      case "current_mode_update":
+        this.currentMode = asString(envelope.update.currentModeId)?.trim() || null;
+        break;
+    }
+  }
+  processXaiUpdate(envelope) {
+    switch (updateType(envelope)) {
+      case "turn_completed": {
+        const usage = parseUsage(envelope.update);
+        if (!usage) return;
+        this.builder.attachUsageToLatestAssistant(usage.tokens, {
+          model: usage.primaryModel ?? this.currentModel,
+          cost: usage.cost ?? void 0,
+          costSource: usage.cost === null ? void 0 : "recorded"
+        });
+        return;
+      }
+      case "model_changed":
+        this.currentModel = asString(envelope.update.model_id)?.trim() || this.currentModel;
+        return;
+      case "model_auto_switched":
+        this.currentModel = asString(envelope.update.new_model_id)?.trim() || this.currentModel;
+        return;
+      case "subagent_spawned": {
+        const childSessionId = asString(envelope.update.child_session_id)?.trim();
+        if (childSessionId && this.activeAssistant && !this.activeAssistant.subagent_id) {
+          this.activeAssistant.subagent_id = childSessionId;
+        }
+      }
+    }
+  }
+  appendUserChunk(envelope) {
+    if (isHostTurn(envelope.update)) return;
+    const part = messagePartFromContentBlock(envelope.update.content, envelope.timestampMs);
+    if (!part) return;
+    const promptIndexValue = asNumber(asRecord(envelope.update._meta)?.promptIndex);
+    const promptIndex = promptIndexValue !== void 0 && Number.isSafeInteger(promptIndexValue) ? promptIndexValue : null;
+    const canReuse = this.activeUser !== null && (promptIndex === null || this.activeUserPromptIndex === null || promptIndex === this.activeUserPromptIndex);
+    if (canReuse) {
+      const tail = this.activeUser.parts.at(-1);
+      if (tail?.type === "text" && part.type === "text") tail.text += part.text;
+      else this.activeUser.parts.push(part);
+    } else {
+      const eventId = asString(asRecord(envelope.params._meta)?.eventId);
+      this.activeUser = this.builder.appendMessage({
+        id: eventId || `${this.sessionId}-user-${envelope.timestampMs}`,
+        role: "user",
+        timestampMs: envelope.timestampMs,
+        parts: [part]
+      });
+    }
+    this.activeUserPromptIndex = promptIndex;
+    this.activeAssistant = null;
+    this.activeAssistantPromptId = null;
+    this.latestPlan = null;
+  }
+  prepareAssistant(envelope) {
+    const promptId = asString(asRecord(envelope.params._meta)?.promptId)?.trim() || null;
+    if (promptId && this.activeAssistantPromptId && promptId !== this.activeAssistantPromptId) {
+      this.builder.beginTurn();
+      this.activeAssistant = null;
+      this.latestPlan = null;
+    }
+    if (promptId) this.activeAssistantPromptId = promptId;
+    this.activeUser = null;
+    this.activeUserPromptIndex = null;
+  }
+  assistantInput(envelope) {
+    const paramsMeta = asRecord(envelope.params._meta);
+    return {
+      id: asString(paramsMeta?.promptId) || asString(paramsMeta?.eventId) || `${this.sessionId}-assistant-${envelope.timestampMs}`,
+      timestampMs: envelope.timestampMs,
+      agent: "grok",
+      mode: this.currentMode,
+      model: this.currentModel,
+      provider: "xai"
+    };
+  }
+  appendAssistantText(envelope, type) {
+    const text = textFromContentBlock(envelope.update.content);
+    if (!text) return;
+    this.prepareAssistant(envelope);
+    const tail = this.activeAssistant?.parts.at(-1);
+    if (tail?.type === type) {
+      tail.text += text;
+      return;
+    }
+    this.activeAssistant = this.builder.appendAssistantPart(
+      { type, text, time_created: envelope.timestampMs },
+      this.assistantInput(envelope),
+      { grouping: "current" }
+    );
+  }
+  appendToolCall(envelope) {
+    const callId = asString(envelope.update.toolCallId)?.trim();
+    const updateMeta = asRecord(envelope.update._meta);
+    const nativeTool = asRecord(updateMeta?.["x.ai/tool"]);
+    const name = asString(nativeTool?.name)?.trim() || asString(envelope.update.title)?.trim() || "tool";
+    if (!callId) return;
+    this.prepareAssistant(envelope);
+    const metadata = {
+      kind: asString(nativeTool?.kind) ?? asString(envelope.update.kind),
+      locations: envelope.update.locations
+    };
+    const part = {
+      type: "tool",
+      tool: name,
+      title: toolTitle(name),
+      callID: callId,
+      state: {
+        status: toolStatus(envelope.update.status) ?? "running",
+        input: envelope.update.rawInput,
+        output: null,
+        metadata
+      },
+      time_created: envelope.timestampMs
+    };
+    this.activeAssistant = this.builder.appendToolCall(part, this.assistantInput(envelope), {
+      markModeAsTool: true,
+      target: "current"
+    });
+  }
+  updateToolCall(envelope) {
+    const callId = asString(envelope.update.toolCallId)?.trim();
+    if (!callId) return;
+    this.builder.updateToolCall(callId, (part) => {
+      const status = toolStatus(envelope.update.status);
+      if (status) part.state.status = status;
+      if (envelope.update.rawInput !== void 0) part.state.input = envelope.update.rawInput;
+      const output = toolOutput(envelope.update);
+      if (output !== void 0) {
+        if (status === "error") part.state.error = output;
+        else part.state.output = output;
+      }
+      const metadata = asRecord(part.state.metadata) ?? {};
+      if (envelope.update.kind !== void 0) metadata.kind = envelope.update.kind;
+      if (envelope.update.locations !== void 0) metadata.locations = envelope.update.locations;
+      part.state.metadata = metadata;
+    });
+  }
+  updatePlan(envelope) {
+    const part = planPart(envelope.update, envelope.timestampMs);
+    if (!part) return;
+    this.prepareAssistant(envelope);
+    if (this.latestPlan) {
+      this.latestPlan.text = part.text;
+      this.latestPlan.approval_status = part.approval_status;
+      this.latestPlan.time_created = part.time_created;
+      return;
+    }
+    this.latestPlan = part;
+    this.activeAssistant = this.builder.appendAssistantPart(part, this.assistantInput(envelope), {
+      grouping: "current"
+    });
+  }
+};
+var UserRunTracker = class {
+  hasSeenPromptIndex = false;
+  isInUserRun = false;
+  currentPromptIndex = null;
+  onUser(promptIndex) {
+    if (promptIndex !== null) this.hasSeenPromptIndex = true;
+    const isCounted = this.hasSeenPromptIndex ? promptIndex !== null : true;
+    const isNewRun = !this.isInUserRun || (this.hasSeenPromptIndex || promptIndex !== null) && promptIndex !== this.currentPromptIndex;
+    this.isInUserRun = true;
+    if (!isNewRun) return false;
+    this.currentPromptIndex = promptIndex;
+    return isCounted;
+  }
+  onNonUser() {
+    this.isInUserRun = false;
+    this.currentPromptIndex = null;
+  }
+};
+var RewindIndex = class {
+  survivingRecordIndexes = [];
+  hasRewinds = false;
+  promptStarts = [];
+  userRuns = new UserRunTracker();
+  process(record, recordIndex, fallbackTimestampMs) {
+    const envelope = unpackUpdate(record, fallbackTimestampMs);
+    if (!envelope) {
+      this.userRuns.onNonUser();
+      this.survivingRecordIndexes.push(recordIndex);
+      return;
+    }
+    const type = updateType(envelope);
+    if (envelope.method === XAI_UPDATE_METHOD && type === "rewind_marker") {
+      const target = asNumber(envelope.update.target_prompt_index);
+      if (target === void 0 || !Number.isSafeInteger(target) || target < 0) {
+        this.userRuns.onNonUser();
+        this.survivingRecordIndexes.push(recordIndex);
+        return;
+      }
+      const truncateAt = this.promptStarts[target] ?? this.survivingRecordIndexes.length;
+      this.survivingRecordIndexes.length = truncateAt;
+      this.promptStarts.length = Math.min(this.promptStarts.length, target);
+      this.userRuns.onNonUser();
+      this.hasRewinds = true;
+      return;
+    }
+    if (envelope.method !== XAI_UPDATE_METHOD && type === "user_message_chunk" && !isHostTurn(envelope.update)) {
+      const rawPromptIndex = asNumber(asRecord(envelope.update._meta)?.promptIndex);
+      const promptIndex = rawPromptIndex !== void 0 && Number.isSafeInteger(rawPromptIndex) && rawPromptIndex >= 0 ? rawPromptIndex : null;
+      if (this.userRuns.onUser(promptIndex)) {
+        this.promptStarts.push(this.survivingRecordIndexes.length);
+      }
+    } else {
+      this.userRuns.onNonUser();
+    }
+    this.survivingRecordIndexes.push(recordIndex);
+  }
+};
+function parseTranscript(meta) {
+  const reducer = new GrokTranscriptReducer(meta.id, meta.currentModel, meta.createdAt);
+  if (!meta.updatesPath || !existsSync12(meta.updatesPath)) return reducer.finish(meta.stats);
+  const rewindIndex = new RewindIndex();
+  let recordIndex = 0;
+  for (const record of readJsonlFile(meta.updatesPath)) {
+    rewindIndex.process(record, recordIndex, meta.createdAt);
+    reducer.process(record);
+    recordIndex += 1;
+  }
+  if (!rewindIndex.hasRewinds) return reducer.finish(meta.stats);
+  const survivingIndexes = new Set(rewindIndex.survivingRecordIndexes);
+  const replay = new GrokTranscriptReducer(meta.id, meta.currentModel, meta.createdAt);
+  recordIndex = 0;
+  for (const record of readJsonlFile(meta.updatesPath)) {
+    if (survivingIndexes.has(recordIndex)) replay.process(record);
+    recordIndex += 1;
+  }
+  return replay.finish(meta.stats);
+}
+var GrokAgent = class extends FileSystemSessionSource {
+  name = "grok";
+  displayName = "Grok";
+  basePath = null;
+  findBasePath() {
+    return firstExisting(join14(resolveGrokDataRoot(), "sessions"), "data/grok");
+  }
+  isAvailable() {
+    this.basePath = this.findBasePath();
+    return this.basePath !== null && this.listSessionSources().length > 0;
+  }
+  getSessionWatchPlan() {
+    const dataRoot = resolveGrokDataRoot();
+    return {
+      status: "supported",
+      targets: [{ root: dataRoot, path: join14(dataRoot, "sessions") }, { path: "data/grok" }]
+    };
+  }
+  listSessionSources(options) {
+    this.basePath ??= this.findBasePath();
+    if (!this.basePath) return [];
+    const sources = this.walkFiles(this.basePath, (entry) => entry.name === SUMMARY_FILE);
+    return sources.flatMap((source) => {
+      const summary = parseSummary(source);
+      if (!summary || !matchesScanWindow(summary.updatedAt, options)) return [];
+      return [
+        {
+          sessionId: summary.id,
+          sourcePath: source.file,
+          fingerprint: this.sourceFingerprint(source)
+        }
+      ];
+    });
+  }
+  scanSessionSource(sourcePath) {
+    const source = this.sessionSourceFile(sourcePath);
+    const summary = parseSummary(source);
+    if (!summary) return null;
+    const sessionDir = dirname6(source.file);
+    const updatesPath = join14(sessionDir, UPDATES_FILE);
+    const existingUpdatesPath = existsSync12(updatesPath) ? updatesPath : null;
+    const headData = scanHeadData(existingUpdatesPath, summary.createdAt);
+    const messageCount = headData.visibleMessageCount || summary.messageCount;
+    if (messageCount === 0) return null;
+    const title = resolveSessionTitle(
+      summary.title,
+      headData.firstUserText,
+      basenameTitle(summary.cwd)
+    );
+    const stats = { message_count: messageCount, ...headData.stats };
+    const fingerprint = this.sourceFingerprint(source);
+    const head = {
+      id: summary.id,
+      slug: `grok/${summary.id}`,
+      title,
+      directory: summary.cwd,
+      parent_reference: summary.parentSessionId ? { agentName: this.name, sessionId: summary.parentSessionId } : void 0,
+      time_created: summary.createdAt,
+      time_updated: summary.updatedAt,
+      stats,
+      model_usage: Object.keys(headData.modelUsage).length > 0 ? headData.modelUsage : void 0
+    };
+    this.sessionMetaMap.set(summary.id, {
+      id: summary.id,
+      title,
+      sourcePath: source.file,
+      sourceFingerprint: fingerprint,
+      sourceMtimeMs: summary.updatedAt,
+      directory: summary.cwd,
+      messageCount,
+      createdAt: summary.createdAt,
+      updatedAt: summary.updatedAt,
+      currentModel: summary.currentModel,
+      parentSessionId: summary.parentSessionId,
+      updatesPath: existingUpdatesPath,
+      stats
+    });
+    return head;
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    const transcript = parseTranscript(meta);
+    return {
+      reference: { agentName: this.name, sessionId: meta.id },
+      id: meta.id,
+      title: meta.title,
+      slug: `grok/${meta.id}`,
+      directory: meta.directory,
+      parent_reference: meta.parentSessionId ? { agentName: this.name, sessionId: meta.parentSessionId } : void 0,
+      version: void 0,
+      time_created: meta.createdAt,
+      time_updated: meta.updatedAt,
+      stats: transcript.stats,
+      messages: transcript.messages
+    };
+  }
+  sourceFingerprint(source) {
+    const sessionDir = dirname6(source.file);
+    return JSON.stringify([
+      HEAD_INDEX_VERSION4,
+      PARSER_VERSION3,
+      source.stat.mtimeMs,
+      source.stat.size,
+      optionalFileFingerprint(join14(sessionDir, UPDATES_FILE))
+    ]);
+  }
+};
 registerAgent({
   icon: "/icon/agent/claudecode.svg",
   iconColored: true,
@@ -7124,6 +7992,13 @@ registerAgent({
   toolStrategy: "custom",
   create: () => new CodexAgent()
 });
+registerAgent({
+  icon: "/icon/agent/grok.svg",
+  resolveDataRoot: resolveGrokDataRoot,
+  resumeCommandPrefix: "grok --resume",
+  toolStrategy: "custom",
+  create: () => new GrokAgent()
+});
 registerAgent({
   icon: "/icon/agent/pi.svg",
   resolveDataRoot: resolvePiDataRoot,
@@ -7146,11 +8021,11 @@ function fallbackDisplayName(input) {
 }
 var realFs = {
   exists(path2) {
-    return existsSync12(path2);
+    return existsSync13(path2);
   },
   readText(path2) {
     try {
-      return readFileSync7(path2, "utf8");
+      return readFileSync8(path2, "utf8");
     } catch {
       return null;
     }
@@ -7320,8 +8195,9 @@ function parseManifestName(file, text) {
 }
 function buildProjectGroups(sessions) {
   const groups = /* @__PURE__ */ new Map();
+  const tree = buildSessionTree(sessions);
   for (const session of sessions) {
-    if (isChildSession(session)) continue;
+    if (tree.mountStateOf(session) === "mounted-child") continue;
     const identity = session.project_identity;
     if (!identity) continue;
     const activity = session.time_updated ?? session.time_created;
@@ -7649,16 +8525,16 @@ function setSchemaEnsuredPath(path2) {
   schemaEnsuredPath = path2;
 }
 function getCacheDir2() {
-  return join14(homedir6(), ".cache", "codesesh");
+  return join15(homedir6(), ".cache", "codesesh");
 }
 function getCachePath2() {
-  return join14(getCacheDir2(), CACHE_FILENAME);
+  return join15(getCacheDir2(), CACHE_FILENAME);
 }
 function getLegacyCachePath() {
-  return join14(getCacheDir2(), LEGACY_CACHE_FILENAME);
+  return join15(getCacheDir2(), LEGACY_CACHE_FILENAME);
 }
 function hasCacheStorage() {
-  return existsSync13(getCachePath2());
+  return existsSync14(getCachePath2());
 }
 function likePattern(value) {
   return `%${value.trim().toLowerCase().replace(/[\\%_]/g, "\\$&")}%`;
@@ -7806,7 +8682,7 @@ function prepareUpsertIndexedSession(db) {
 }
 function upsertSessionRow(statement, agentName, session, metaJson, sortIndex, sourcePath) {
   const identity = session.project_identity ?? computeIdentity(session.directory, realFs);
-  const activityTime = session.time_updated ?? session.time_created;
+  const activityTime2 = session.time_updated ?? session.time_created;
   statement.run(
     agentName,
     session.id,
@@ -7822,7 +8698,7 @@ function upsertSessionRow(statement, agentName, session, metaJson, sortIndex, so
     identity.displayName,
     session.time_created,
     session.time_updated ?? null,
-    activityTime,
+    activityTime2,
     session.stats.message_count,
     session.stats.total_input_tokens,
     session.stats.total_output_tokens,
@@ -8130,7 +9006,9 @@ function withCacheDb(fn) {
     return fn(db);
   } catch (error) {
     getCoreDiagnostics()?.warn("cache.write_failed", {
-      message: error instanceof Error ? error.message : String(error)
+      message: error instanceof Error ? error.message : String(error),
+      code: error?.code,
+      stack: error instanceof Error ? error.stack : void 0
     });
     return null;
   } finally {
@@ -8171,7 +9049,7 @@ function runSearchIndexWrite(db, rebuild, write) {
       createMessageSearchTriggers(db);
     }
     return { value, rebuildDurationMs };
-  })();
+  }).immediate();
 }
 function createCacheTables(db) {
   db.exec(`
@@ -9182,7 +10060,7 @@ function ensureSchema(db, dbPath) {
     ]
   });
   createLatestCacheSchema(db);
-  if (getUserVersion(db) <= CACHE_SCHEMA_VERSION) {
+  if (getUserVersion(db) < CACHE_SCHEMA_VERSION) {
     setCacheSchemaVersion(db);
   }
   migrateCodexExecDecode(db);
@@ -10240,7 +11118,7 @@ function parseCachedSessionMeta(value) {
 }
 function deleteLegacyCacheFile() {
   const legacyPath = getLegacyCachePath();
-  if (!existsSync14(legacyPath)) {
+  if (!existsSync15(legacyPath)) {
     return;
   }
   try {
@@ -10532,7 +11410,7 @@ function saveCachedSessions(agentName, sessions, meta = {}) {
         );
       });
     });
-    write();
+    write.immediate();
     deleteLegacyCacheFile();
     return true;
   });
@@ -10583,7 +11461,7 @@ function saveCachedSessionChanges(agentName, changes, removedSessionIds, meta =
         );
       }
     });
-    write();
+    write.immediate();
     deleteLegacyCacheFile();
     return true;
   });
@@ -10613,7 +11491,7 @@ function clearCache() {
   const walPath = `${cachePath}-wal`;
   const shmPath = `${cachePath}-shm`;
   for (const filePath of [walPath, shmPath]) {
-    if (!existsSync14(filePath)) {
+    if (!existsSync15(filePath)) {
       continue;
     }
     try {
@@ -11184,6 +12062,66 @@ function listCachedProjectGroups(sessions) {
     lastActivity: row.last_activity == null ? null : Number(row.last_activity)
   }));
 }
+var DEFAULT_MODEL_COST_LIMIT = 20;
+function buildModelCostWhere(options) {
+  const clauses = ["m.model IS NOT NULL", "m.model <> ''"];
+  const params = [];
+  if (options.agent != null) {
+    clauses.push("s.agent_name = ?");
+    params.push(options.agent);
+  }
+  if (options.projectKind != null || options.projectKey != null) {
+    if (options.projectKind != null && options.projectKey != null) {
+      clauses.push("s.project_identity_kind = ? AND s.project_identity_key = ?");
+      params.push(options.projectKind, options.projectKey);
+    } else {
+      clauses.push("0");
+    }
+  }
+  if (options.from != null) {
+    clauses.push("s.activity_time >= ?");
+    params.push(options.from);
+  }
+  if (options.to != null) {
+    clauses.push("s.activity_time <= ?");
+    params.push(options.to);
+  }
+  return { where: `WHERE ${clauses.join(" AND ")}`, params };
+}
+var MODEL_COST_SQL = `
+  SELECT
+    m.model AS model,
+    SUM(COALESCE(m.cost, 0)) AS cost,
+    SUM(CASE WHEN m.cost_source = 'recorded' THEN COALESCE(m.cost, 0) ELSE 0 END) AS cost_recorded,
+    SUM(CASE WHEN m.cost_source = 'recorded' THEN 0 ELSE COALESCE(m.cost, 0) END) AS cost_estimated
+  FROM messages m
+  JOIN sessions s ON s.agent_name = m.agent_name AND s.session_id = m.session_id
+`;
+function listModelCostDistribution(options = {}) {
+  if (!hasCacheStorage()) {
+    return null;
+  }
+  const { where, params } = buildModelCostWhere(options);
+  const sql = `
+    ${MODEL_COST_SQL}
+    ${where}
+    GROUP BY m.model
+    ORDER BY cost DESC, m.model
+    LIMIT ?
+  `;
+  const rows = withCacheDbReadOnly(
+    (db) => db.prepare(sql).all(...params, options.limit ?? DEFAULT_MODEL_COST_LIMIT)
+  );
+  if (rows == null) {
+    return null;
+  }
+  return rows.map((row) => ({
+    model: String(row.model ?? ""),
+    cost: Number(row.cost ?? 0),
+    costRecorded: Number(row.cost_recorded ?? 0),
+    costEstimated: Number(row.cost_estimated ?? 0)
+  }));
+}
 var STATE_DB_FILENAME = "state.db";
 var STATE_SCHEMA_VERSION = 2;
 var MEMORY_STATE_STORE = "memory";
@@ -11204,16 +12142,16 @@ function getStateDir() {
   if (process.env.CODESESH_STATE_DIR) return process.env.CODESESH_STATE_DIR;
   const currentPlatform = platform4();
   if (currentPlatform === "darwin") {
-    return join15(homedir7(), "Library", "Application Support", "codesesh");
+    return join16(homedir7(), "Library", "Application Support", "codesesh");
   }
   if (currentPlatform === "win32") {
     const appData = process.env.APPDATA ?? process.env.LOCALAPPDATA;
-    return join15(appData ?? join15(homedir7(), "AppData", "Roaming"), "codesesh");
+    return join16(appData ?? join16(homedir7(), "AppData", "Roaming"), "codesesh");
   }
-  return join15(process.env.XDG_DATA_HOME ?? join15(homedir7(), ".local", "share"), "codesesh");
+  return join16(process.env.XDG_DATA_HOME ?? join16(homedir7(), ".local", "share"), "codesesh");
 }
 function getStateDbPath() {
-  return join15(getStateDir(), STATE_DB_FILENAME);
+  return join16(getStateDir(), STATE_DB_FILENAME);
 }
 function useMemoryStateStore() {
   return process.env.CODESESH_STATE_STORE === MEMORY_STATE_STORE;
@@ -11503,7 +12441,7 @@ function importBookmarks(bookmarks) {
         );
       }
     });
-    write();
+    write.immediate();
     const rows = db.prepare(
       `
           SELECT
@@ -11621,160 +12559,267 @@ function deleteSessionAlias(reference) {
   });
 }
 var DASHBOARD_RECENT_LIMIT = 10;
-function getTotalTokens(stats) {
-  return stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens;
-}
+var DASHBOARD_PROJECT_LIMIT = 12;
+var PROJECT_SPARKLINE_DAYS = 14;
 function getSessionAgentName(session) {
   return getSessionAgentKey(session);
 }
 function getSessionActivityTime(session) {
   return session.time_updated ?? session.time_created;
 }
-function buildDashboard(sessions, options) {
-  const { byAgentNames, scope, from, to, agentInfoMap } = options;
-  const agentMetrics = /* @__PURE__ */ new Map();
-  const agentMetricKeyByName = /* @__PURE__ */ new Map();
+function matchesScope(session, scope) {
+  if (scope.agent && getSessionAgentName(session) !== scope.agent) return false;
+  if (scope.projectKind == null && scope.projectKey == null) return true;
+  const identity = session.project_identity;
+  return identity != null && identity.kind === scope.projectKind && identity.key === scope.projectKey;
+}
+function scopedEntries(sessions, scope, from, to) {
+  const tree = buildSessionTree(filterSessionTreeByActivityWindow(sessions, from, to));
+  return tree.entries.filter((node) => matchesScope(node.session, scope));
+}
+function emptyDailyBucket(date) {
+  return {
+    date,
+    sessions: 0,
+    messages: 0,
+    cost: 0,
+    input: 0,
+    output: 0,
+    cache_read: 0,
+    cache_create: 0
+  };
+}
+function createAccumulator(byAgentNames, scope, to) {
+  const agents = /* @__PURE__ */ new Map();
   for (const name of byAgentNames) {
-    if (scope.agent && name.toLowerCase() !== scope.agent) continue;
-    agentMetrics.set(name, { sessions: 0, messages: 0, tokens: 0 });
-    agentMetricKeyByName.set(name.toLowerCase(), name);
+    const key = name.toLowerCase();
+    if (scope.agent && key !== scope.agent) continue;
+    agents.set(key, { name, sessions: 0, messages: 0, tokens: 0, cost: 0 });
   }
-  let totalSessions = 0;
-  let totalMessages = 0;
-  let totalTokens = 0;
-  let totalCost = 0;
-  let hasEstimatedCost = false;
-  let latestActivity = 0;
-  const recentCandidates = [];
-  const modelAgg = /* @__PURE__ */ new Map();
-  const dailyMap = /* @__PURE__ */ new Map();
-  const dailyTokenMap = /* @__PURE__ */ new Map();
+  const sparklineSlots = /* @__PURE__ */ new Map();
+  for (let slot = 0; slot < PROJECT_SPARKLINE_DAYS; slot += 1) {
+    const day = addCalendarDays(to, slot - (PROJECT_SPARKLINE_DAYS - 1));
+    sparklineSlots.set(toCalendarDayKey(day), slot);
+  }
+  return {
+    sessions: 0,
+    messages: 0,
+    tokens: 0,
+    cost: 0,
+    costRecorded: 0,
+    costEstimated: 0,
+    cacheReadTokens: 0,
+    hasEstimatedCost: false,
+    agents,
+    agentKeys: /* @__PURE__ */ new Set(),
+    daily: /* @__PURE__ */ new Map(),
+    models: /* @__PURE__ */ new Map(),
+    projects: /* @__PURE__ */ new Map(),
+    sparklineSlots,
+    recent: []
+  };
+}
+function foldModelUsage(node, into) {
+  if (node.session.model_usage) {
+    for (const [model, tokens] of Object.entries(node.session.model_usage)) {
+      into.set(model, (into.get(model) ?? 0) + tokens);
+    }
+  }
+  for (const child of node.children) foldModelUsage(child, into);
+}
+function trackProject(node, acc, dayKey, agentKey) {
+  const identity = node.session.project_identity;
+  if (!identity) return;
+  const key = getProjectIdentityKey(identity);
+  let project = acc.projects.get(key);
+  if (!project) {
+    project = {
+      identityKind: identity.kind,
+      identityKey: identity.key,
+      displayName: identity.displayName,
+      sessions: 0,
+      messages: 0,
+      tokens: 0,
+      cost: 0,
+      hasEstimatedCost: false,
+      agentSessions: /* @__PURE__ */ new Map(),
+      sparkline: Array.from({ length: PROJECT_SPARKLINE_DAYS }, () => 0)
+    };
+    acc.projects.set(key, project);
+  }
+  const stats = node.inclusiveStats;
+  project.sessions += 1;
+  project.messages += stats.messageCount;
+  project.tokens += stats.totalTokens;
+  project.cost += stats.cost;
+  if (stats.costSource === "estimated") project.hasEstimatedCost = true;
+  project.agentSessions.set(agentKey, (project.agentSessions.get(agentKey) ?? 0) + 1);
+  const slot = acc.sparklineSlots.get(dayKey);
+  if (slot != null) project.sparkline[slot] += stats.cost;
+}
+function accumulate(node, acc) {
+  const session = node.session;
+  const stats = node.inclusiveStats;
+  const activity = getSessionActivityTime(session);
+  const agentKey = getSessionAgentName(session);
+  acc.sessions += 1;
+  acc.messages += stats.messageCount;
+  acc.tokens += stats.totalTokens;
+  acc.cost += stats.cost;
+  acc.cacheReadTokens += stats.cacheReadTokens;
+  acc.agentKeys.add(agentKey);
+  if (stats.costSource === "recorded") acc.costRecorded += stats.cost;
+  else acc.costEstimated += stats.cost;
+  if (stats.costSource === "estimated") acc.hasEstimatedCost = true;
+  const metric = acc.agents.get(agentKey);
+  if (metric) {
+    metric.sessions += 1;
+    metric.messages += stats.messageCount;
+    metric.tokens += stats.totalTokens;
+    metric.cost += stats.cost;
+  }
+  const dayKey = toCalendarDayKey(activity);
+  let bucket = acc.daily.get(dayKey);
+  if (!bucket) {
+    bucket = emptyDailyBucket(dayKey);
+    acc.daily.set(dayKey, bucket);
+  }
+  bucket.sessions += 1;
+  bucket.messages += stats.messageCount;
+  bucket.cost += stats.cost;
+  bucket.input += Math.max(0, stats.inputTokens - stats.cacheReadTokens - stats.cacheCreateTokens);
+  bucket.output += stats.outputTokens;
+  bucket.cache_read += stats.cacheReadTokens;
+  bucket.cache_create += stats.cacheCreateTokens;
+  const usage = /* @__PURE__ */ new Map();
+  foldModelUsage(node, usage);
+  for (const [model, tokens] of usage) {
+    const entry = acc.models.get(model);
+    if (entry) {
+      entry.tokens += tokens;
+      entry.sessions += 1;
+    } else {
+      acc.models.set(model, { tokens, sessions: 1 });
+    }
+  }
+  trackProject(node, acc, dayKey, agentKey);
+  let recentIndex = acc.recent.length;
+  for (let i = 0; i < acc.recent.length; i += 1) {
+    if (activity > acc.recent[i].activity) {
+      recentIndex = i;
+      break;
+    }
+  }
+  if (recentIndex < DASHBOARD_RECENT_LIMIT) {
+    acc.recent.splice(recentIndex, 0, { session, activity });
+    if (acc.recent.length > DASHBOARD_RECENT_LIMIT) acc.recent.pop();
+  }
+}
+function toPreviousTotals(acc) {
+  return { sessions: acc.sessions, messages: acc.messages, tokens: acc.tokens, cost: acc.cost };
+}
+function toProjectStat(project) {
+  return {
+    identityKind: project.identityKind,
+    identityKey: project.identityKey,
+    displayName: project.displayName,
+    sessions: project.sessions,
+    messages: project.messages,
+    tokens: project.tokens,
+    cost: project.cost,
+    cost_source: project.cost > 0 ? project.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+    agents: [...project.agentSessions.entries()].sort((a, b) => b[1] - a[1]).map(([agentKey]) => agentKey),
+    sparkline: project.sparkline
+  };
+}
+function buildDashboard(sessions, options) {
+  const { byAgentNames, scope, from, to, agentInfoMap, compare } = options;
+  const acc = createAccumulator(byAgentNames, scope, to);
   if (from != null) {
     const bucketDays = countCalendarDays(from, to);
     for (let i = 0; i < bucketDays; i += 1) {
       const key = toCalendarDayKey(addCalendarDays(from, i));
-      dailyMap.set(key, { date: key, sessions: 0, messages: 0 });
-      dailyTokenMap.set(key, { date: key, input: 0, output: 0, cache_read: 0, cache_create: 0 });
-    }
-  }
-  const visibleSessions = filterSessionTreeByActivityWindow(sessions, from, to);
-  for (const session of visibleSessions) {
-    if (isChildSession(session)) continue;
-    const agentName = getSessionAgentName(session);
-    if (scope.agent && agentName !== scope.agent) continue;
-    if (scope.projectKind || scope.projectKey) {
-      const identity = session.project_identity;
-      if (!identity || !scope.projectKind || !scope.projectKey || identity.kind !== scope.projectKind || identity.key !== scope.projectKey) {
-        continue;
-      }
-    }
-    const activity = getSessionActivityTime(session);
-    const messageCount = session.stats.message_count;
-    const sessionTokens = getTotalTokens(session.stats);
-    totalSessions += 1;
-    totalMessages += messageCount;
-    totalTokens += sessionTokens;
-    totalCost += session.stats.total_cost ?? 0;
-    if (session.stats.cost_source === "estimated") hasEstimatedCost = true;
-    if (activity > latestActivity) latestActivity = activity;
-    const metricKey = agentMetricKeyByName.get(agentName);
-    if (metricKey) {
-      const metric = agentMetrics.get(metricKey);
-      metric.sessions += 1;
-      metric.messages += messageCount;
-      metric.tokens += sessionTokens;
-    }
-    const key = toCalendarDayKey(activity);
-    let bucket = dailyMap.get(key);
-    if (!bucket) {
-      bucket = { date: key, sessions: 0, messages: 0 };
-      dailyMap.set(key, bucket);
-    }
-    bucket.sessions += 1;
-    bucket.messages += messageCount;
-    let tokenBucket = dailyTokenMap.get(key);
-    if (!tokenBucket) {
-      tokenBucket = { date: key, input: 0, output: 0, cache_read: 0, cache_create: 0 };
-      dailyTokenMap.set(key, tokenBucket);
-    }
-    const cacheRead = session.stats.total_cache_read_tokens ?? 0;
-    const cacheCreate = session.stats.total_cache_create_tokens ?? 0;
-    const pureInput = session.stats.total_input_tokens - cacheRead - cacheCreate;
-    tokenBucket.input += Math.max(0, pureInput);
-    tokenBucket.output += session.stats.total_output_tokens;
-    tokenBucket.cache_read += cacheRead;
-    tokenBucket.cache_create += cacheCreate;
-    if (session.model_usage) {
-      for (const [model, tokens] of Object.entries(session.model_usage)) {
-        const entry = modelAgg.get(model);
-        if (entry) {
-          entry.tokens += tokens;
-          entry.sessions += 1;
-        } else {
-          modelAgg.set(model, { tokens, sessions: 1 });
-        }
-      }
+      acc.daily.set(key, emptyDailyBucket(key));
     }
-    let recentIndex = recentCandidates.length;
-    for (let i = 0; i < recentCandidates.length; i += 1) {
-      if (activity > recentCandidates[i].activity) {
-        recentIndex = i;
-        break;
-      }
-    }
-    if (recentIndex < DASHBOARD_RECENT_LIMIT) {
-      recentCandidates.splice(recentIndex, 0, { session, activity });
-      if (recentCandidates.length > DASHBOARD_RECENT_LIMIT) recentCandidates.pop();
+  }
+  for (const node of scopedEntries(sessions, scope, from, to)) accumulate(node, acc);
+  let previous;
+  if (compare) {
+    const compareAcc = createAccumulator(byAgentNames, scope, compare.to);
+    for (const node of scopedEntries(sessions, scope, compare.from, compare.to)) {
+      accumulate(node, compareAcc);
     }
+    previous = toPreviousTotals(compareAcc);
   }
-  const perAgent = [...agentMetrics.entries()].map(([name, metrics]) => {
-    const info = agentInfoMap?.get(name);
+  const perAgent = [...acc.agents.values()].map((metrics) => {
+    const info = agentInfoMap?.get(metrics.name);
     return {
-      name,
-      displayName: info?.displayName ?? name,
+      name: metrics.name,
+      displayName: info?.displayName ?? metrics.name,
       icon: info?.icon ?? "",
       iconColored: info?.iconColored,
       sessions: metrics.sessions,
       messages: metrics.messages,
-      tokens: metrics.tokens
+      tokens: metrics.tokens,
+      cost: metrics.cost
     };
   }).filter((item) => item.sessions > 0).sort((a, b) => b.sessions - a.sessions);
-  const dailyActivity = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
-  const dailyTokenActivity = [...dailyTokenMap.values()].sort(
-    (a, b) => a.date.localeCompare(b.date)
+  const dailyActivity = [...acc.daily.values()].sort((a, b) => a.date.localeCompare(b.date));
+  const modelDistribution = [...acc.models.entries()].map(([model, { tokens, sessions: count }]) => ({ model, tokens, sessions: count })).sort((a, b) => b.tokens - a.tokens);
+  const rankedProjects = [...acc.projects.values()].sort((a, b) => b.cost - a.cost);
+  const perProject = rankedProjects.slice(0, DASHBOARD_PROJECT_LIMIT).map(toProjectStat);
+  const projectRollup = rankedProjects.slice(DASHBOARD_PROJECT_LIMIT).reduce(
+    (rollup, project) => ({
+      projects: rollup.projects + 1,
+      sessions: rollup.sessions + project.sessions,
+      tokens: rollup.tokens + project.tokens,
+      cost: rollup.cost + project.cost
+    }),
+    { projects: 0, sessions: 0, tokens: 0, cost: 0 }
   );
-  const modelDistribution = [...modelAgg.entries()].map(([model, { tokens, sessions: count }]) => ({ model, tokens, sessions: count })).sort((a, b) => b.tokens - a.tokens);
-  const recentSessions = recentCandidates.map(({ session }) => {
-    const agentKey = getSessionAgentName(session);
-    return {
-      reference: { agentName: agentKey, sessionId: session.id },
-      session
-    };
-  });
+  const recentSessions = acc.recent.map(({ session }) => ({
+    reference: { agentName: getSessionAgentName(session), sessionId: session.id },
+    session
+  }));
+  const latest = acc.recent[0];
   return {
     totals: {
-      sessions: totalSessions,
-      messages: totalMessages,
-      tokens: totalTokens,
-      cost: totalCost,
-      cost_source: totalCost > 0 ? hasEstimatedCost ? "estimated" : "recorded" : void 0,
-      latestActivity: latestActivity || void 0
+      sessions: acc.sessions,
+      messages: acc.messages,
+      tokens: acc.tokens,
+      cost: acc.cost,
+      costRecorded: acc.costRecorded,
+      costEstimated: acc.costEstimated,
+      cacheReadTokens: acc.cacheReadTokens,
+      cost_source: acc.cost > 0 ? acc.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+      latestActivity: latest?.activity || void 0,
+      latestActivityProject: latest?.session.project_identity?.displayName,
+      latestActivityAgent: latest ? getSessionAgentName(latest.session) : void 0,
+      previous
     },
+    scopeCounts: { projects: acc.projects.size, agents: acc.agentKeys.size },
     perAgent,
     dailyActivity,
-    dailyTokenActivity,
     modelDistribution,
+    perProject,
+    projectRollup,
     recentSessions
   };
 }
 function emptyMetrics() {
-  return { messages: 0, tokens: 0, cost: 0, hasEstimatedCost: false, agentStats: /* @__PURE__ */ new Map() };
+  return {
+    sessions: 0,
+    messages: 0,
+    tokens: 0,
+    cost: 0,
+    hasEstimatedCost: false,
+    agentStats: /* @__PURE__ */ new Map()
+  };
 }
 function attachProjectMetrics(projects, sessions) {
   const metrics = /* @__PURE__ */ new Map();
-  for (const session of sessions) {
-    if (isChildSession(session)) continue;
-    const identity = session.project_identity;
+  for (const node of buildSessionTree(sessions).entries) {
+    const identity = node.session.project_identity;
     if (!identity) continue;
     const key = getProjectIdentityKey(identity);
     let current = metrics.get(key);
@@ -11782,26 +12827,26 @@ function attachProjectMetrics(projects, sessions) {
       current = emptyMetrics();
       metrics.set(key, current);
     }
-    const tokens = getTotalTokens(session.stats);
-    const cost = session.stats.total_cost ?? 0;
-    current.messages += session.stats.message_count;
-    current.tokens += tokens;
-    current.cost += cost;
-    if (session.stats.cost_source === "estimated") current.hasEstimatedCost = true;
-    const agentName = getSessionAgentName(session);
+    const stats = node.inclusiveStats;
+    current.sessions += 1;
+    current.messages += stats.messageCount;
+    current.tokens += stats.totalTokens;
+    current.cost += stats.cost;
+    if (stats.costSource === "estimated") current.hasEstimatedCost = true;
+    const agentName = getSessionAgentName(node.session);
     const agent = current.agentStats.get(agentName);
     if (agent) {
       agent.sessions += 1;
-      agent.messages += session.stats.message_count;
-      agent.tokens += tokens;
-      agent.cost += cost;
+      agent.messages += stats.messageCount;
+      agent.tokens += stats.totalTokens;
+      agent.cost += stats.cost;
     } else {
       current.agentStats.set(agentName, {
         name: agentName,
         sessions: 1,
-        messages: session.stats.message_count,
-        tokens,
-        cost
+        messages: stats.messageCount,
+        tokens: stats.totalTokens,
+        cost: stats.cost
       });
     }
   }
@@ -11811,6 +12856,7 @@ function attachProjectMetrics(projects, sessions) {
     );
     return {
       ...project,
+      sessionCount: metric?.sessions ?? 0,
       messages: metric?.messages ?? 0,
       tokens: metric?.tokens ?? 0,
       cost: metric?.cost ?? 0,
@@ -11956,6 +13002,7 @@ export {
   getSessionAgentKey,
   sessionRoutePath,
   mergeSortedSessions,
+  getSessionRouteKey,
   isChildSession,
   getRootSessions,
   filterSessionTreeByActivityWindow,
@@ -12004,6 +13051,7 @@ export {
   scanSessions,
   materializeSessionDetailResponse,
   listCachedProjectGroups,
+  listModelCostDistribution,
   StateStorageUnavailableError,
   listBookmarks,
   upsertBookmark,
@@ -12019,4 +13067,4 @@ export {
   executeSessionSearch,
   filterSessionSearchCandidates
 };
-//# sourceMappingURL=chunk-G2BTNW3C.js.map
+//# sourceMappingURL=chunk-BEF6LLRG.js.map