claude-session-dashboard 0.4.1 → 0.4.3

package/dist/server/assets/_tanstack-start-manifest_v-Bzp9kpGN.js

@@ -0,0 +1,4 @@
+const tsrStartManifest = () => ({ "routes": { "__root__": { "filePath": "/Users/dmytro.lupiak/GitHub/claude-session-dashboard/apps/web/src/routes/__root.tsx", "children": ["/", "/_dashboard"], "preloads": ["/assets/main-CV28H4XG.js"], "assets": [] }, "/": { "filePath": "/Users/dmytro.lupiak/GitHub/claude-session-dashboard/apps/web/src/routes/index.tsx" }, "/_dashboard": { "filePath": "/Users/dmytro.lupiak/GitHub/claude-session-dashboard/apps/web/src/routes/_dashboard.tsx", "children": ["/_dashboard/settings", "/_dashboard/stats", "/_dashboard/sessions/$sessionId", "/_dashboard/sessions/"], "assets": [], "preloads": ["/assets/_dashboard-t702m22X.js", "/assets/createServerFn-BYTDoNe-.js", "/assets/sessions.queries-tzrs5GhP.js"] }, "/_dashboard/settings": { "filePath": "/Users/dmytro.lupiak/GitHub/claude-session-dashboard/apps/web/src/routes/_dashboard/settings.tsx", "assets": [], "preloads": ["/assets/settings-D8yv1q93.js", "/assets/settings.types-CMYAW0cQ.js"] }, "/_dashboard/stats": { "filePath": "/Users/dmytro.lupiak/GitHub/claude-session-dashboard/apps/web/src/routes/_dashboard/stats.tsx", "assets": [], "preloads": ["/assets/stats-C_6E4jyb.js", "/assets/format-Bsprb3az.js", "/assets/useSessionCost-BBu3AmcX.js", "/assets/settings.types-CMYAW0cQ.js"] }, "/_dashboard/sessions/$sessionId": { "filePath": "/Users/dmytro.lupiak/GitHub/claude-session-dashboard/apps/web/src/routes/_dashboard/sessions/$sessionId.tsx", "assets": [], "preloads": ["/assets/_sessionId-D4Tpmmb5.js", "/assets/format-Bsprb3az.js", "/assets/useSessionCost-BBu3AmcX.js", "/assets/settings.types-CMYAW0cQ.js"] }, "/_dashboard/sessions/": { "filePath": "/Users/dmytro.lupiak/GitHub/claude-session-dashboard/apps/web/src/routes/_dashboard/sessions/index.tsx", "assets": [], "preloads": ["/assets/index-DnK_zh3s.js", "/assets/format-Bsprb3az.js"] } }, "clientEntry": "/assets/main-CV28H4XG.js" });
+export {
+  tsrStartManifest
+};

package/dist/server/assets/{project-analytics.server-aftsdOgf.js → project-analytics.server-kTooOGl-.js}

@@ -1,11 +1,10 @@
 import { c as createServerRpc } from "./createServerRpc-Bd3B-Ah9.js";
-import { s as scanAllSessions } from "./session-scanner-BzGf0Bqs.js";
+import { a as scanAllSessions } from "./session-scanner-DRGzVO2T.js";
 import { c as createServerFn } from "../server.js";
 import "node:fs";
 import "node:path";
-import "./claude-path-BdwflgZ1.js";
+import "./session-parser-DxLcS8VW.js";
 import "node:os";
-import "./session-parser-Bq8g2LOP.js";
 import "node:readline";
 import "@tanstack/history";
 import "@tanstack/router-core/ssr/client";

package/dist/server/assets/{session-detail.server-4Cp5Zyo1.js → session-detail.server-CO5XwLSv.js}

@@ -1,8 +1,7 @@
 import { c as createServerRpc } from "./createServerRpc-Bd3B-Ah9.js";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { e as extractProjectName, a as getProjectsDir, d as decodeProjectDirName } from "./claude-path-BdwflgZ1.js";
-import { p as parseDetail } from "./session-parser-Bq8g2LOP.js";
+import { e as extractProjectName, p as parseDetail, a as getProjectsDir, d as decodeProjectDirName } from "./session-parser-DxLcS8VW.js";
 import { c as createServerFn } from "../server.js";
 import "node:os";
 import "node:readline";

package/dist/server/assets/{session-parser-Bq8g2LOP.js → session-parser-DxLcS8VW.js}

@@ -1,5 +1,54 @@
+import * as path from "node:path";
+import * as os from "node:os";
 import * as fs from "node:fs";
 import * as readline from "node:readline";
+function resolveClaudeDir() {
+  if (process.env.CLAUDE_HOME) {
+    return path.resolve(process.env.CLAUDE_HOME);
+  }
+  return path.join(os.homedir(), ".claude");
+}
+const CLAUDE_DIR = resolveClaudeDir();
+function getProjectsDir() {
+  return path.join(CLAUDE_DIR, "projects");
+}
+function getStatsPath() {
+  return path.join(CLAUDE_DIR, "stats-cache.json");
+}
+function decodeProjectDirName(dirName) {
+  return dirName.replace(/^-/, "/").replace(/-/g, "/");
+}
+function extractProjectName(decodedPath) {
+  return path.basename(decodedPath);
+}
+function extractSessionId(filename) {
+  return filename.replace(/\.jsonl$/, "");
+}
+const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
+async function discoverSubagentFiles(sessionDir) {
+  const result = /* @__PURE__ */ new Map();
+  const candidateDirs = [
+    path.join(sessionDir, "subagents"),
+    path.join(sessionDir, "agents")
+  ];
+  for (const dir of candidateDirs) {
+    try {
+      const entries = await fs.promises.readdir(dir);
+      for (const entry of entries) {
+        const match = AGENT_FILE_PATTERN.exec(entry);
+        if (match) {
+          const agentId = match[1];
+          if (!result.has(agentId)) {
+            result.set(agentId, path.join(dir, entry));
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+const AGENT_DISPATCH_TOOL_NAMES = /* @__PURE__ */ new Set(["Task", "Agent"]);
 const HEAD_LINES = 15;
 async function parseSummary(filePath, sessionId, projectPath, projectName, fileSizeBytes) {
   const headLines = await readHeadLines(filePath, HEAD_LINES);
@@ -159,12 +208,13 @@ async function parseDetail(filePath, sessionId, projectPath, projectName) {
             input: block.input
           });
           toolFrequency[block.name] = (toolFrequency[block.name] ?? 0) + 1;
-          if (block.name === "Task" && block.input) {
+          if (AGENT_DISPATCH_TOOL_NAMES.has(block.name) && block.input) {
             const inp = block.input;
-            if (inp.subagent_type) {
+            const subagentType = inp.subagent_type ?? inp.agent_type;
+            if (subagentType) {
               const agent = {
-                subagentType: String(inp.subagent_type),
-                description: String(inp.description ?? ""),
+                subagentType: String(subagentType),
+                description: String(inp.description ?? inp.prompt ?? ""),
                 timestamp: msg.timestamp ?? "",
                 toolUseId: block.id ?? "",
                 model: inp.model ? String(inp.model) : void 0
@@ -275,24 +325,24 @@ async function parseDetail(filePath, sessionId, projectPath, projectName) {
             }
           }
           if (resultText && toolUseId) {
-            const agentIdMatch = resultText.match(/agentId:\s*(\w+)/);
+            const agentIdMatch = resultText.match(/agentId:\s*([\w-]+)/);
             if (agentIdMatch) {
               agentIdByToolUseId.set(String(toolUseId), agentIdMatch[1]);
             }
           }
           if (msg.toolUseResult && toolUseId) {
+            const result = msg.toolUseResult;
+            if (result.agentId) {
+              agentIdByToolUseId.set(String(toolUseId), result.agentId);
+            }
+            if (result.retrieval_status && result.task?.task_id) {
+              agentIdByToolUseId.set(String(toolUseId), result.task.task_id);
+            }
             const agent = agentByToolUseId.get(String(toolUseId));
             if (agent) {
-              const result = msg.toolUseResult;
               if (result.totalTokens) agent.totalTokens = result.totalTokens;
               if (result.totalToolUseCount) agent.totalToolUseCount = result.totalToolUseCount;
               if (result.totalDurationMs) agent.durationMs = result.totalDurationMs;
-              if (result.isAsync === true && result.agentId) {
-                agentIdByToolUseId.set(String(toolUseId), result.agentId);
-              }
-              if (result.retrieval_status && result.task?.task_id) {
-                agentIdByToolUseId.set(String(toolUseId), result.task.task_id);
-              }
             }
           }
         }
@@ -330,50 +380,64 @@ async function parseDetail(filePath, sessionId, projectPath, projectName) {
       agent.model = actualModel;
     }
   }
-  const subagentDir = filePath.replace(/\.jsonl$/, "");
+  const sessionDir = filePath.replace(/\.jsonl$/, "");
+  const subagentFileMap = await discoverSubagentFiles(sessionDir);
+  const matchedAgentIds = /* @__PURE__ */ new Set();
   await Promise.all(
     agents.map(async (agent) => {
       const agentId = agentIdByToolUseId.get(agent.toolUseId);
       if (!agentId) return;
       agent.agentId = agentId;
-      const subagentFilePath = `${subagentDir}/subagents/agent-${agentId}.jsonl`;
+      matchedAgentIds.add(agentId);
+      const subagentFilePath = subagentFileMap.get(agentId);
+      if (!subagentFilePath) return;
       try {
         const detail = await parseSubagentDetail(subagentFilePath);
-        agent.skills = detail.skills;
-        if (!agent.tokens) {
-          agent.tokens = detail.tokens;
-          totalTokens.inputTokens += detail.tokens.inputTokens;
-          totalTokens.outputTokens += detail.tokens.outputTokens;
-          totalTokens.cacheReadInputTokens += detail.tokens.cacheReadInputTokens;
-          totalTokens.cacheCreationInputTokens += detail.tokens.cacheCreationInputTokens;
-          if (detail.model) {
-            const modelId = detail.model;
-            const existing = tokensByModel[modelId] ?? {
-              inputTokens: 0,
-              outputTokens: 0,
-              cacheReadInputTokens: 0,
-              cacheCreationInputTokens: 0
-            };
-            existing.inputTokens += detail.tokens.inputTokens;
-            existing.outputTokens += detail.tokens.outputTokens;
-            existing.cacheReadInputTokens += detail.tokens.cacheReadInputTokens;
-            existing.cacheCreationInputTokens += detail.tokens.cacheCreationInputTokens;
-            tokensByModel[modelId] = existing;
-          }
-        }
-        if (!agent.toolCalls) {
-          agent.toolCalls = detail.toolCalls;
-        }
-        if (!agent.model && detail.model) {
-          agent.model = detail.model;
-        }
-        if (!agent.totalToolUseCount && detail.totalToolUseCount > 0) {
-          agent.totalToolUseCount = detail.totalToolUseCount;
-        }
+        mergeSubagentData(
+          agent,
+          detail,
+          agentProgressTokens.get(agent.toolUseId),
+          totalTokens,
+          tokensByModel
+        );
       } catch {
       }
     })
   );
+  for (const [agentId, subagentFilePath] of subagentFileMap) {
+    if (matchedAgentIds.has(agentId)) continue;
+    try {
+      const detail = await parseSubagentDetail(subagentFilePath);
+      const hasTokens = detail.tokens.inputTokens > 0 || detail.tokens.outputTokens > 0;
+      const hasActivity = hasTokens || detail.skills.length > 0 || detail.totalToolUseCount > 0;
+      if (hasTokens) {
+        addTokens(totalTokens, detail.tokens);
+        if (detail.model) {
+          const existing = tokensByModel[detail.model] ?? createEmptyTokenUsage();
+          addTokens(existing, detail.tokens);
+          tokensByModel[detail.model] = existing;
+        }
+      }
+      for (const [toolName, count] of Object.entries(detail.toolCalls)) {
+        toolFrequency[toolName] = (toolFrequency[toolName] ?? 0) + count;
+      }
+      if (hasActivity) {
+        agents.push({
+          subagentType: "unknown",
+          description: "",
+          timestamp: "",
+          toolUseId: `orphan-${agentId}`,
+          agentId,
+          tokens: detail.tokens,
+          toolCalls: detail.toolCalls,
+          model: detail.model,
+          totalToolUseCount: detail.totalToolUseCount,
+          skills: detail.skills
+        });
+      }
+    } catch {
+    }
+  }
   const modelName = modelsSet.size > 0 ? Array.from(modelsSet)[0] : "unknown";
   const contextWindow = buildContextWindowData(
     contextSnapshots,
@@ -430,7 +494,7 @@ async function parseSubagentDetail(subagentFilePath) {
                 skill: skillName,
                 args: null,
                 timestamp: msg.timestamp ?? "",
-                toolUseId: `injected-${skillName}-${msg.timestamp ?? lineCount}`,
+                toolUseId: `injected-${skillName}-${lineCount}`,
                 source: "injected"
               });
             }
@@ -500,6 +564,56 @@ function buildContextWindowData(snapshots, modelName) {
     snapshots
   };
 }
+function createEmptyTokenUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0
+  };
+}
+function addTokens(target, source) {
+  target.inputTokens += source.inputTokens;
+  target.outputTokens += source.outputTokens;
+  target.cacheReadInputTokens += source.cacheReadInputTokens;
+  target.cacheCreationInputTokens += source.cacheCreationInputTokens;
+}
+function subtractTokens(target, source) {
+  target.inputTokens -= source.inputTokens;
+  target.outputTokens -= source.outputTokens;
+  target.cacheReadInputTokens -= source.cacheReadInputTokens;
+  target.cacheCreationInputTokens -= source.cacheCreationInputTokens;
+}
+function mergeSubagentData(agent, detail, progressTokens, totalTokens, tokensByModel) {
+  agent.skills = detail.skills;
+  if (detail.tokens.inputTokens > 0 || detail.tokens.outputTokens > 0) {
+    if (progressTokens) {
+      subtractTokens(totalTokens, progressTokens);
+      const progressModel = agent.model;
+      if (progressModel && tokensByModel[progressModel]) {
+        subtractTokens(tokensByModel[progressModel], progressTokens);
+      }
+    }
+    agent.tokens = detail.tokens;
+    addTokens(totalTokens, detail.tokens);
+    if (detail.model) {
+      const existing = tokensByModel[detail.model] ?? createEmptyTokenUsage();
+      addTokens(existing, detail.tokens);
+      tokensByModel[detail.model] = existing;
+    }
+  } else if (!agent.tokens && progressTokens) {
+    agent.tokens = progressTokens;
+  }
+  if (!agent.toolCalls && Object.keys(detail.toolCalls).length > 0) {
+    agent.toolCalls = detail.toolCalls;
+  }
+  if (!agent.model && detail.model) {
+    agent.model = detail.model;
+  }
+  if (!agent.totalToolUseCount && detail.totalToolUseCount > 0) {
+    agent.totalToolUseCount = detail.totalToolUseCount;
+  }
+}
 async function readHeadLines(filePath, count) {
   const lines = [];
   const stream = fs.createReadStream(filePath, { encoding: "utf-8" });
@@ -509,6 +623,7 @@ async function readHeadLines(filePath, count) {
     if (lines.length >= count) break;
   }
   stream.destroy();
+  rl.close();
   return lines;
 }
 async function readTailLines(filePath, count) {
@@ -549,6 +664,11 @@ function extractTextContent(msg) {
   return texts.length > 0 ? texts.join("\n").slice(0, 500) : void 0;
 }
 export {
-  parseSummary as a,
+  getProjectsDir as a,
+  extractSessionId as b,
+  parseSummary as c,
+  decodeProjectDirName as d,
+  extractProjectName as e,
+  getStatsPath as g,
   parseDetail as p
 };

package/dist/server/assets/{session-scanner-BzGf0Bqs.js → session-scanner-DRGzVO2T.js}

@@ -1,7 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { a as getProjectsDir, d as decodeProjectDirName, e as extractProjectName, b as extractSessionId } from "./claude-path-BdwflgZ1.js";
-import { a as parseSummary } from "./session-parser-Bq8g2LOP.js";
+import { a as getProjectsDir, d as decodeProjectDirName, e as extractProjectName, b as extractSessionId, c as parseSummary } from "./session-parser-DxLcS8VW.js";
 async function scanProjects() {
   const projectsDir = getProjectsDir();
   let entries;
@@ -41,7 +40,7 @@ async function isSessionActive(projectDirName, sessionId) {
   return lockStat?.isDirectory() ?? false;
 }
 const summaryCache = /* @__PURE__ */ new Map();
-async function scanAllSessions() {
+async function scanSessionsInternal() {
   const projects = await scanProjects();
   const summaries = [];
   for (const project of projects) {
@@ -57,7 +56,7 @@ async function scanAllSessions() {
       const cached = summaryCache.get(sessionId);
       if (cached && cached.mtimeMs === stat.mtimeMs) {
         const active = await isSessionActive(project.dirName, sessionId);
-        summaries.push({ ...cached.summary, isActive: active });
+        summaries.push({ ...cached.summary, isActive: active, filePath });
         continue;
       }
       const summary = await parseSummary(
@@ -74,7 +73,7 @@ async function scanAllSessions() {
           mtimeMs: stat.mtimeMs,
           summary
         });
-        summaries.push(summary);
+        summaries.push({ ...summary, filePath });
       }
     }
   }
@@ -83,11 +82,19 @@ async function scanAllSessions() {
   );
   return summaries;
 }
+async function scanAllSessions() {
+  const results = await scanSessionsInternal();
+  return results.map(({ filePath: _filePath, ...summary }) => summary);
+}
+async function scanAllSessionsWithPaths() {
+  return scanSessionsInternal();
+}
 async function getActiveSessions() {
   const all = await scanAllSessions();
   return all.filter((s) => s.isActive);
 }
 export {
+  scanAllSessions as a,
   getActiveSessions as g,
-  scanAllSessions as s
+  scanAllSessionsWithPaths as s
 };

package/dist/server/assets/{sessions.server-XaGOdz4f.js → sessions.server-CTeIkXCV.js}

@@ -1,12 +1,11 @@
 import { c as createServerRpc } from "./createServerRpc-Bd3B-Ah9.js";
 import { z } from "zod";
-import { s as scanAllSessions, g as getActiveSessions } from "./session-scanner-BzGf0Bqs.js";
+import { a as scanAllSessions, g as getActiveSessions } from "./session-scanner-DRGzVO2T.js";
 import { c as createServerFn } from "../server.js";
 import "node:fs";
 import "node:path";
-import "./claude-path-BdwflgZ1.js";
+import "./session-parser-DxLcS8VW.js";
 import "node:os";
-import "./session-parser-Bq8g2LOP.js";
 import "node:readline";
 import "@tanstack/history";
 import "@tanstack/router-core/ssr/client";

package/dist/server/assets/stats.server-iJ_z7eUN.js

@@ -0,0 +1,398 @@
+import { c as createServerRpc } from "./createServerRpc-Bd3B-Ah9.js";
+import * as fs from "node:fs";
+import { g as getStatsPath, p as parseDetail } from "./session-parser-DxLcS8VW.js";
+import * as path from "node:path";
+import * as os from "node:os";
+import { z } from "zod";
+import { s as scanAllSessionsWithPaths } from "./session-scanner-DRGzVO2T.js";
+import { c as createServerFn } from "../server.js";
+import "node:readline";
+import "@tanstack/history";
+import "@tanstack/router-core/ssr/client";
+import "@tanstack/router-core";
+import "node:async_hooks";
+import "@tanstack/router-core/ssr/server";
+import "h3-v2";
+import "tiny-invariant";
+import "seroval";
+import "react/jsx-runtime";
+import "@tanstack/react-router/ssr/server";
+import "@tanstack/react-router";
+const CACHE_VERSION = 1;
+function getCacheDir() {
+  return path.join(os.homedir(), ".claude-dashboard", "cache");
+}
+function getCachePath(cacheKey) {
+  return path.join(getCacheDir(), `${cacheKey}.cache.json`);
+}
+function readDiskCache(cacheKey, sourceMtimeMs, schema) {
+  try {
+    const cachePath = getCachePath(cacheKey);
+    if (!fs.existsSync(cachePath)) {
+      return null;
+    }
+    const raw = fs.readFileSync(cachePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION) {
+      return null;
+    }
+    if (parsed.sourceMtimeMs !== sourceMtimeMs) {
+      return null;
+    }
+    const result = schema.safeParse(parsed.data);
+    if (!result.success) {
+      console.warn(`[disk-cache] Zod validation failed for "${cacheKey}":`, result.error.message);
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[disk-cache] Read failed for "${cacheKey}":`, message);
+    return null;
+  }
+}
+function writeDiskCache(cacheKey, sourceFile, sourceMtimeMs, data) {
+  try {
+    const cacheDir = getCacheDir();
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const cachePath = getCachePath(cacheKey);
+    const tmpPath = `${cachePath}.tmp`;
+    const entry = {
+      version: CACHE_VERSION,
+      sourceFile,
+      sourceMtimeMs,
+      cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    fs.writeFileSync(tmpPath, JSON.stringify(entry), "utf-8");
+    fs.renameSync(tmpPath, cachePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[disk-cache] Write failed for "${cacheKey}":`, message);
+  }
+}
+const DailyActivitySchema = z.object({
+  date: z.string(),
+  messageCount: z.number(),
+  sessionCount: z.number(),
+  toolCallCount: z.number()
+});
+const DailyModelTokensSchema = z.object({
+  date: z.string(),
+  tokensByModel: z.record(z.string(), z.number())
+});
+const ModelUsageSchema = z.record(
+  z.string(),
+  z.object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheReadInputTokens: z.number(),
+    cacheCreationInputTokens: z.number(),
+    webSearchRequests: z.number().optional(),
+    costUSD: z.number().optional()
+  })
+);
+const LongestSessionSchema = z.object({
+  sessionId: z.string(),
+  duration: z.number(),
+  messageCount: z.number(),
+  timestamp: z.string()
+});
+const StatsCacheSchema = z.object({
+  version: z.number(),
+  lastComputedDate: z.string(),
+  dailyActivity: z.array(DailyActivitySchema),
+  dailyModelTokens: z.array(DailyModelTokensSchema),
+  modelUsage: ModelUsageSchema,
+  totalSessions: z.number(),
+  totalMessages: z.number(),
+  longestSession: LongestSessionSchema,
+  firstSessionDate: z.string(),
+  hourCounts: z.record(z.string(), z.number()),
+  totalSpeculationTimeSavedMs: z.number().optional()
+});
+let cachedStats = null;
+let mergedCache = null;
+const MERGE_STALENESS_MS = 6e4;
+function getTodayDateString() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function extractDateString(isoOrDate) {
+  return isoOrDate.split("T")[0];
+}
+async function parseStats() {
+  const statsPath = getStatsPath();
+  const stat = await fs.promises.stat(statsPath).catch(() => null);
+  if (!stat) {
+    try {
+      const computed = await computeStatsFromSessions();
+      return computed;
+    } catch {
+      return null;
+    }
+  }
+  if (cachedStats && cachedStats.mtimeMs === stat.mtimeMs) {
+    return maybeEnrichWithRecentSessions(cachedStats.data, stat.mtimeMs);
+  }
+  const diskResult = readDiskCache("stats", stat.mtimeMs, StatsCacheSchema);
+  if (diskResult) {
+    cachedStats = { mtimeMs: stat.mtimeMs, data: diskResult };
+    return maybeEnrichWithRecentSessions(diskResult, stat.mtimeMs);
+  }
+  try {
+    const raw = await fs.promises.readFile(statsPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const result = StatsCacheSchema.parse(parsed);
+    writeDiskCache("stats", statsPath, stat.mtimeMs, result);
+    cachedStats = { mtimeMs: stat.mtimeMs, data: result };
+    return maybeEnrichWithRecentSessions(result, stat.mtimeMs);
+  } catch {
+    const computed = await computeStatsFromSessions();
+    return computed;
+  }
+}
+async function maybeEnrichWithRecentSessions(stats, mtimeMs) {
+  const today = getTodayDateString();
+  const lastComputed = extractDateString(stats.lastComputedDate);
+  if (lastComputed >= today) {
+    return stats;
+  }
+  if (mergedCache && mergedCache.mtimeMs === mtimeMs && Date.now() - mergedCache.mergedAt < MERGE_STALENESS_MS) {
+    return mergedCache.data;
+  }
+  try {
+    const merged = await mergeRecentSessions(stats);
+    mergedCache = { mtimeMs, mergedAt: Date.now(), data: merged };
+    return merged;
+  } catch {
+    return stats;
+  }
+}
+async function parseDetailsInBatches(sessions, batchSize = 10) {
+  const results = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sessions.length; i += batchSize) {
+    const batch = sessions.slice(i, i + batchSize);
+    const details = await Promise.all(
+      batch.map(async (s) => {
+        try {
+          return {
+            sessionId: s.sessionId,
+            detail: await parseDetail(
+              s.filePath,
+              s.sessionId,
+              s.projectPath,
+              s.projectName
+            )
+          };
+        } catch {
+          return null;
+        }
+      })
+    );
+    for (const result of details) {
+      if (result) results.set(result.sessionId, result.detail);
+    }
+  }
+  return results;
+}
+async function mergeRecentSessions(stats) {
+  const summaries = await scanAllSessionsWithPaths();
+  const cutoffDate = extractDateString(stats.lastComputedDate);
+  const recentSessions = summaries.filter((s) => {
+    const sessionDate = extractDateString(s.lastActiveAt ?? s.startedAt);
+    return sessionDate > cutoffDate;
+  });
+  if (recentSessions.length === 0) {
+    return stats;
+  }
+  const detailMap = await parseDetailsInBatches(recentSessions);
+  const activityMap = /* @__PURE__ */ new Map();
+  for (const entry of stats.dailyActivity) {
+    activityMap.set(entry.date, {
+      messageCount: entry.messageCount,
+      sessionCount: entry.sessionCount,
+      toolCallCount: entry.toolCallCount
+    });
+  }
+  const modelTokensMap = /* @__PURE__ */ new Map();
+  for (const entry of stats.dailyModelTokens) {
+    modelTokensMap.set(entry.date, { ...entry.tokensByModel });
+  }
+  const hourCounts = { ...stats.hourCounts };
+  const modelUsage = {};
+  for (const [model, usage] of Object.entries(stats.modelUsage)) {
+    modelUsage[model] = { ...usage };
+  }
+  let additionalMessages = 0;
+  const additionalSessions = recentSessions.length;
+  let longestSession = { ...stats.longestSession };
+  const existingSessionCount = stats.totalSessions;
+  for (const s of recentSessions) {
+    const date = extractDateString(s.lastActiveAt ?? s.startedAt);
+    const detail = detailMap.get(s.sessionId);
+    const cur = activityMap.get(date) ?? { messageCount: 0, sessionCount: 0, toolCallCount: 0 };
+    cur.sessionCount += 1;
+    if (detail) {
+      cur.messageCount += detail.turns.length;
+      cur.toolCallCount += Object.values(detail.toolFrequency).reduce((sum, n) => sum + n, 0);
+      const dayTokens = modelTokensMap.get(date) ?? {};
+      for (const [model, usage] of Object.entries(detail.tokensByModel)) {
+        const total = usage.inputTokens + usage.outputTokens;
+        dayTokens[model] = (dayTokens[model] ?? 0) + total;
+      }
+      modelTokensMap.set(date, dayTokens);
+      for (const [model, usage] of Object.entries(detail.tokensByModel)) {
+        const existing = modelUsage[model] ?? {
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadInputTokens: 0,
+          cacheCreationInputTokens: 0
+        };
+        existing.inputTokens += usage.inputTokens;
+        existing.outputTokens += usage.outputTokens;
+        existing.cacheReadInputTokens += usage.cacheReadInputTokens;
+        existing.cacheCreationInputTokens += usage.cacheCreationInputTokens;
+        modelUsage[model] = existing;
+      }
+      additionalMessages += detail.turns.length;
+    } else {
+      cur.messageCount += s.messageCount;
+      additionalMessages += s.messageCount;
+      if (!modelTokensMap.has(date)) {
+        modelTokensMap.set(date, {});
+      }
+    }
+    activityMap.set(date, cur);
+    updateHourCounts(hourCounts, s);
+    if (s.durationMs > longestSession.duration) {
+      longestSession = {
+        sessionId: s.sessionId,
+        duration: s.durationMs,
+        messageCount: detail?.turns.length ?? s.messageCount,
+        timestamp: s.lastActiveAt ?? s.startedAt
+      };
+    }
+  }
+  const dailyActivity = Array.from(activityMap.entries()).map(([date, v]) => ({
+    date,
+    messageCount: v.messageCount,
+    sessionCount: v.sessionCount,
+    toolCallCount: v.toolCallCount
+  })).sort((a, b) => a.date < b.date ? -1 : 1);
+  const dailyModelTokens = Array.from(modelTokensMap.entries()).map(([date, tokensByModel]) => ({ date, tokensByModel })).sort((a, b) => a.date < b.date ? -1 : 1);
+  return {
+    ...stats,
+    dailyActivity,
+    dailyModelTokens,
+    modelUsage,
+    totalSessions: existingSessionCount + additionalSessions,
+    totalMessages: stats.totalMessages + additionalMessages,
+    longestSession,
+    hourCounts
+  };
+}
+function updateHourCounts(hourCounts, session) {
+  const startedAt = session.startedAt;
+  if (!startedAt) return;
+  try {
+    const date = new Date(startedAt);
+    const hour = date.getHours().toString();
+    hourCounts[hour] = (hourCounts[hour] ?? 0) + 1;
+  } catch {
+  }
+}
+async function computeStatsFromSessions() {
+  try {
+    const summaries = await scanAllSessionsWithPaths();
+    const detailMap = await parseDetailsInBatches(summaries);
+    const activityMap = /* @__PURE__ */ new Map();
+    const modelTokensMap = /* @__PURE__ */ new Map();
+    const modelUsage = {};
+    const hourCounts = {};
+    let totalMessages = 0;
+    let longestSession = { sessionId: "", duration: 0, messageCount: 0, timestamp: "" };
+    let firstSessionDate = null;
+    for (const s of summaries) {
+      const d = (s.lastActiveAt ?? s.startedAt).split("T")[0];
+      const detail = detailMap.get(s.sessionId);
+      const cur = activityMap.get(d) ?? { messageCount: 0, sessionCount: 0, toolCallCount: 0 };
+      cur.sessionCount += 1;
+      if (detail) {
+        cur.messageCount += detail.turns.length;
+        cur.toolCallCount += Object.values(detail.toolFrequency).reduce((sum, n) => sum + n, 0);
+        totalMessages += detail.turns.length;
+        const dayTokens = modelTokensMap.get(d) ?? {};
+        for (const [model, usage] of Object.entries(detail.tokensByModel)) {
+          const total = usage.inputTokens + usage.outputTokens;
+          dayTokens[model] = (dayTokens[model] ?? 0) + total;
+        }
+        modelTokensMap.set(d, dayTokens);
+        for (const [model, usage] of Object.entries(detail.tokensByModel)) {
+          const existing = modelUsage[model] ?? {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0
+          };
+          existing.inputTokens += usage.inputTokens;
+          existing.outputTokens += usage.outputTokens;
+          existing.cacheReadInputTokens += usage.cacheReadInputTokens;
+          existing.cacheCreationInputTokens += usage.cacheCreationInputTokens;
+          modelUsage[model] = existing;
+        }
+      } else {
+        cur.messageCount += s.messageCount;
+        totalMessages += s.messageCount;
+        if (!modelTokensMap.has(d)) modelTokensMap.set(d, {});
+      }
+      activityMap.set(d, cur);
+      updateHourCounts(hourCounts, s);
+      const msgCount = detail?.turns.length ?? s.messageCount;
+      if (s.durationMs > longestSession.duration) {
+        longestSession = {
+          sessionId: s.sessionId,
+          duration: s.durationMs,
+          messageCount: msgCount,
+          timestamp: s.lastActiveAt ?? s.startedAt
+        };
+      }
+      if (!firstSessionDate || s.startedAt < firstSessionDate) {
+        firstSessionDate = s.startedAt;
+      }
+    }
+    const dailyActivity = Array.from(activityMap.entries()).map(([date, v]) => ({ date, ...v })).sort((a, b) => a.date < b.date ? -1 : 1);
+    const dailyModelTokens = Array.from(modelTokensMap.entries()).map(([date, tokensByModel]) => ({ date, tokensByModel })).sort((a, b) => a.date < b.date ? -1 : 1);
+    return {
+      version: 1,
+      lastComputedDate: (/* @__PURE__ */ new Date()).toISOString(),
+      dailyActivity,
+      dailyModelTokens,
+      modelUsage,
+      totalSessions: summaries.length,
+      totalMessages,
+      longestSession: {
+        sessionId: longestSession.sessionId,
+        duration: longestSession.duration,
+        messageCount: longestSession.messageCount,
+        timestamp: longestSession.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+      },
+      firstSessionDate: firstSessionDate ?? (/* @__PURE__ */ new Date()).toISOString(),
+      hourCounts
+    };
+  } catch {
+    return null;
+  }
+}
+const getStats_createServerFn_handler = createServerRpc({
+  id: "4b9a58c176f487b49800a372100037cdf33cf048f3592a449f115c7e3f5ea799",
+  name: "getStats",
+  filename: "src/features/stats/stats.server.ts"
+}, (opts) => getStats.__executeServer(opts));
+const getStats = createServerFn({
+  method: "GET"
+}).handler(getStats_createServerFn_handler, async () => {
+  return parseStats();
+});
+export {
+  getStats_createServerFn_handler
+};

package/dist/server/server.js

@@ -423,7 +423,7 @@ function getResponse() {
   return event.res;
 }
 async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-JNF_5-F_.js");
+  const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-Bzp9kpGN.js");
   const startManifest = tsrStartManifest();
   const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
   rootRoute.assets = rootRoute.assets || [];
@@ -579,28 +579,28 @@ function createMultiplexedStream(jsonStream, rawStreams) {
 }
 const manifest = { "4b9a58c176f487b49800a372100037cdf33cf048f3592a449f115c7e3f5ea799": {
   functionName: "getStats_createServerFn_handler",
-  importer: () => import("./assets/stats.server-qTOvID9-.js")
+  importer: () => import("./assets/stats.server-iJ_z7eUN.js")
 }, "ff8a3161afdfa175e9c519e4146a56ab5bce6e80745e99cfc2191ebbb7a859bb": {
   functionName: "getSessionDetail_createServerFn_handler",
-  importer: () => import("./assets/session-detail.server-4Cp5Zyo1.js")
-}, "bf8e4a7901f1843bdc9c46be1ad5ad59c615b8bbe611b73eb3ff28f20e43ee0d": {
-  functionName: "getSessionList_createServerFn_handler",
-  importer: () => import("./assets/sessions.server-XaGOdz4f.js")
-}, "839d29fe93dfa2a6d506af7b48ca25197190a5ff4c796e970ddfdc6e8c98827f": {
-  functionName: "getActiveSessionList_createServerFn_handler",
-  importer: () => import("./assets/sessions.server-XaGOdz4f.js")
-}, "a3f42f9012fd83586787da8f7cb90649da739dd947d867eb67572f68735ff495": {
-  functionName: "getPaginatedSessions_createServerFn_handler",
-  importer: () => import("./assets/sessions.server-XaGOdz4f.js")
+  importer: () => import("./assets/session-detail.server-CO5XwLSv.js")
 }, "810657681a273df5b4e58f0d8fcc6a5451598b489431b9bcaa98eea0ad815da8": {
   functionName: "getSettings_createServerFn_handler",
   importer: () => import("./assets/settings.server-6B2PvLgf.js")
 }, "3050115d92ca91ab1fd8fd698e33076328aae80dc64ca27c088eee16cebccc1a": {
   functionName: "saveSettings_createServerFn_handler",
   importer: () => import("./assets/settings.server-6B2PvLgf.js")
+}, "bf8e4a7901f1843bdc9c46be1ad5ad59c615b8bbe611b73eb3ff28f20e43ee0d": {
+  functionName: "getSessionList_createServerFn_handler",
+  importer: () => import("./assets/sessions.server-CTeIkXCV.js")
+}, "839d29fe93dfa2a6d506af7b48ca25197190a5ff4c796e970ddfdc6e8c98827f": {
+  functionName: "getActiveSessionList_createServerFn_handler",
+  importer: () => import("./assets/sessions.server-CTeIkXCV.js")
+}, "a3f42f9012fd83586787da8f7cb90649da739dd947d867eb67572f68735ff495": {
+  functionName: "getPaginatedSessions_createServerFn_handler",
+  importer: () => import("./assets/sessions.server-CTeIkXCV.js")
 }, "64052f224a1d6696436e5d3deeee2b798f0742e1292ffabd038c3a7bf75e6fcb": {
   functionName: "getProjectAnalytics_createServerFn_handler",
-  importer: () => import("./assets/project-analytics.server-aftsdOgf.js")
+  importer: () => import("./assets/project-analytics.server-kTooOGl-.js")
 } };
 async function getServerFnById(id) {
   const serverFnInfo = manifest[id];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-session-dashboard",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Local observability dashboard for Claude Code sessions",
   "type": "module",
   "license": "MIT",

package/dist/server/assets/_tanstack-start-manifest_v-JNF_5-F_.js

@@ -1,4 +0,0 @@
-const tsrStartManifest = () => ({ "routes": { "__root__": { "filePath": "/home/runner/work/claude-session-dashboard/claude-session-dashboard/apps/web/src/routes/__root.tsx", "children": ["/", "/_dashboard"], "preloads": ["/assets/main-CV28H4XG.js"], "assets": [] }, "/": { "filePath": "/home/runner/work/claude-session-dashboard/claude-session-dashboard/apps/web/src/routes/index.tsx" }, "/_dashboard": { "filePath": "/home/runner/work/claude-session-dashboard/claude-session-dashboard/apps/web/src/routes/_dashboard.tsx", "children": ["/_dashboard/settings", "/_dashboard/stats", "/_dashboard/sessions/$sessionId", "/_dashboard/sessions/"], "assets": [], "preloads": ["/assets/_dashboard-t702m22X.js", "/assets/createServerFn-BYTDoNe-.js", "/assets/sessions.queries-tzrs5GhP.js"] }, "/_dashboard/settings": { "filePath": "/home/runner/work/claude-session-dashboard/claude-session-dashboard/apps/web/src/routes/_dashboard/settings.tsx", "assets": [], "preloads": ["/assets/settings-D8yv1q93.js", "/assets/settings.types-CMYAW0cQ.js"] }, "/_dashboard/stats": { "filePath": "/home/runner/work/claude-session-dashboard/claude-session-dashboard/apps/web/src/routes/_dashboard/stats.tsx", "assets": [], "preloads": ["/assets/stats-C_6E4jyb.js", "/assets/format-Bsprb3az.js", "/assets/useSessionCost-BBu3AmcX.js", "/assets/settings.types-CMYAW0cQ.js"] }, "/_dashboard/sessions/$sessionId": { "filePath": "/home/runner/work/claude-session-dashboard/claude-session-dashboard/apps/web/src/routes/_dashboard/sessions/$sessionId.tsx", "assets": [], "preloads": ["/assets/_sessionId-D4Tpmmb5.js", "/assets/format-Bsprb3az.js", "/assets/useSessionCost-BBu3AmcX.js", "/assets/settings.types-CMYAW0cQ.js"] }, "/_dashboard/sessions/": { "filePath": "/home/runner/work/claude-session-dashboard/claude-session-dashboard/apps/web/src/routes/_dashboard/sessions/index.tsx", "assets": [], "preloads": ["/assets/index-DnK_zh3s.js", "/assets/format-Bsprb3az.js"] } }, "clientEntry": "/assets/main-CV28H4XG.js" });
-export {
-  tsrStartManifest
-};

package/dist/server/assets/claude-path-BdwflgZ1.js

@@ -1,31 +0,0 @@
-import * as path from "node:path";
-import * as os from "node:os";
-function resolveClaudeDir() {
-  if (process.env.CLAUDE_HOME) {
-    return path.resolve(process.env.CLAUDE_HOME);
-  }
-  return path.join(os.homedir(), ".claude");
-}
-const CLAUDE_DIR = resolveClaudeDir();
-function getProjectsDir() {
-  return path.join(CLAUDE_DIR, "projects");
-}
-function getStatsPath() {
-  return path.join(CLAUDE_DIR, "stats-cache.json");
-}
-function decodeProjectDirName(dirName) {
-  return dirName.replace(/^-/, "/").replace(/-/g, "/");
-}
-function extractProjectName(decodedPath) {
-  return path.basename(decodedPath);
-}
-function extractSessionId(filename) {
-  return filename.replace(/\.jsonl$/, "");
-}
-export {
-  getProjectsDir as a,
-  extractSessionId as b,
-  decodeProjectDirName as d,
-  extractProjectName as e,
-  getStatsPath as g
-};

package/dist/server/assets/stats.server-qTOvID9-.js

@@ -1,144 +0,0 @@
-import { c as createServerRpc } from "./createServerRpc-Bd3B-Ah9.js";
-import * as fs from "node:fs";
-import { g as getStatsPath } from "./claude-path-BdwflgZ1.js";
-import * as path from "node:path";
-import * as os from "node:os";
-import { z } from "zod";
-import { c as createServerFn } from "../server.js";
-import "@tanstack/history";
-import "@tanstack/router-core/ssr/client";
-import "@tanstack/router-core";
-import "node:async_hooks";
-import "@tanstack/router-core/ssr/server";
-import "h3-v2";
-import "tiny-invariant";
-import "seroval";
-import "react/jsx-runtime";
-import "@tanstack/react-router/ssr/server";
-import "@tanstack/react-router";
-const CACHE_VERSION = 1;
-function getCacheDir() {
-  return path.join(os.homedir(), ".claude-dashboard", "cache");
-}
-function getCachePath(cacheKey) {
-  return path.join(getCacheDir(), `${cacheKey}.cache.json`);
-}
-function readDiskCache(cacheKey, sourceMtimeMs, schema) {
-  try {
-    const cachePath = getCachePath(cacheKey);
-    if (!fs.existsSync(cachePath)) {
-      return null;
-    }
-    const raw = fs.readFileSync(cachePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== CACHE_VERSION) {
-      return null;
-    }
-    if (parsed.sourceMtimeMs !== sourceMtimeMs) {
-      return null;
-    }
-    const result = schema.safeParse(parsed.data);
-    if (!result.success) {
-      console.warn(`[disk-cache] Zod validation failed for "${cacheKey}":`, result.error.message);
-      return null;
-    }
-    return result.data;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`[disk-cache] Read failed for "${cacheKey}":`, message);
-    return null;
-  }
-}
-function writeDiskCache(cacheKey, sourceFile, sourceMtimeMs, data) {
-  try {
-    const cacheDir = getCacheDir();
-    fs.mkdirSync(cacheDir, { recursive: true });
-    const cachePath = getCachePath(cacheKey);
-    const tmpPath = `${cachePath}.tmp`;
-    const entry = {
-      version: CACHE_VERSION,
-      sourceFile,
-      sourceMtimeMs,
-      cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      data
-    };
-    fs.writeFileSync(tmpPath, JSON.stringify(entry), "utf-8");
-    fs.renameSync(tmpPath, cachePath);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`[disk-cache] Write failed for "${cacheKey}":`, message);
-  }
-}
-const DailyActivitySchema = z.object({
-  date: z.string(),
-  messageCount: z.number(),
-  sessionCount: z.number(),
-  toolCallCount: z.number()
-});
-const DailyModelTokensSchema = z.object({
-  date: z.string(),
-  tokensByModel: z.record(z.string(), z.number())
-});
-const ModelUsageSchema = z.record(
-  z.string(),
-  z.object({
-    inputTokens: z.number(),
-    outputTokens: z.number(),
-    cacheReadInputTokens: z.number(),
-    cacheCreationInputTokens: z.number(),
-    webSearchRequests: z.number().optional(),
-    costUSD: z.number().optional()
-  })
-);
-const LongestSessionSchema = z.object({
-  sessionId: z.string(),
-  duration: z.number(),
-  messageCount: z.number(),
-  timestamp: z.string()
-});
-const StatsCacheSchema = z.object({
-  version: z.number(),
-  lastComputedDate: z.string(),
-  dailyActivity: z.array(DailyActivitySchema),
-  dailyModelTokens: z.array(DailyModelTokensSchema),
-  modelUsage: ModelUsageSchema,
-  totalSessions: z.number(),
-  totalMessages: z.number(),
-  longestSession: LongestSessionSchema,
-  firstSessionDate: z.string(),
-  hourCounts: z.record(z.string(), z.number()),
-  totalSpeculationTimeSavedMs: z.number().optional()
-});
-let cachedStats = null;
-async function parseStats() {
-  const statsPath = getStatsPath();
-  const stat = await fs.promises.stat(statsPath).catch(() => null);
-  if (!stat) return null;
-  if (cachedStats && cachedStats.mtimeMs === stat.mtimeMs) {
-    return cachedStats.data;
-  }
-  const diskResult = readDiskCache("stats", stat.mtimeMs, StatsCacheSchema);
-  if (diskResult) {
-    cachedStats = { mtimeMs: stat.mtimeMs, data: diskResult };
-    return diskResult;
-  }
-  const raw = await fs.promises.readFile(statsPath, "utf-8");
-  const parsed = JSON.parse(raw);
-  const result = StatsCacheSchema.parse(parsed);
-  writeDiskCache("stats", statsPath, stat.mtimeMs, result);
-  cachedStats = { mtimeMs: stat.mtimeMs, data: result };
-  return result;
-}
-const getStats_createServerFn_handler = createServerRpc({
-  id: "4b9a58c176f487b49800a372100037cdf33cf048f3592a449f115c7e3f5ea799",
-  name: "getStats",
-  filename: "src/features/stats/stats.server.ts"
-}, (opts) => getStats.__executeServer(opts));
-const getStats = createServerFn({
-  method: "GET"
-}).handler(getStats_createServerFn_handler, async () => {
-  return parseStats();
-});
-export {
-  getStats_createServerFn_handler
-};