nairon-bench 0.0.20 → 0.0.21

package/dist/index.js

@@ -3868,15 +3868,15 @@ __export(exports_client, {
   getClerkId: () => getClerkId,
   api: () => api
 });
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, mkdirSync } from "node:fs";
-import { join as join3 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 function loadConfig() {
-  if (!existsSync3(CONFIG_FILE)) {
+  if (!existsSync4(CONFIG_FILE)) {
     return { github: undefined };
   }
   try {
-    return JSON.parse(readFileSync3(CONFIG_FILE, "utf-8"));
+    return JSON.parse(readFileSync4(CONFIG_FILE, "utf-8"));
   } catch {
     return { github: undefined };
   }
@@ -3884,8 +3884,8 @@ function loadConfig() {
 function saveConfig(config) {
   const existing = loadConfig();
   const merged = { ...existing, ...config };
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync2(CONFIG_FILE, JSON.stringify(merged, null, 2));
 }
 function getConfig() {
   return loadConfig();
@@ -3929,8 +3929,8 @@ var init_client = __esm(() => {
   init_index_node();
   init_api2();
   init_dist();
-  CONFIG_DIR = join3(homedir2(), ".nairon-bench");
-  CONFIG_FILE = join3(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join4(homedir3(), ".nairon-bench");
+  CONFIG_FILE = join4(CONFIG_DIR, "config.json");
   getClerkId = getGitHub;
   requireClerkId = requireGitHub;
 });
@@ -4446,8 +4446,8 @@ function defineCommand2(def) {
 }
 
 // src/commands/scan.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -8515,9 +8515,9 @@ async function collectGit(projectDir, since) {
 }
 
 // src/collectors/agents.ts
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, basename } from "node:path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2, basename } from "node:path";
 // ../shared/src/constants.ts
 var PHASE_WEIGHTS = {
   requirements: 0.2,
@@ -8800,57 +8800,179 @@ function computeNaironScore(git, agents, tests) {
 function clamp(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
+// src/lib/cache.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+var CACHE_VERSION = 1;
+var CACHE_DIR = join(homedir(), ".nairon", "cache");
+var SESSION_CACHE_FILE = join(CACHE_DIR, "sessions.json");
+function ensureCacheDir() {
+  if (!existsSync(CACHE_DIR)) {
+    mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+function loadCache() {
+  try {
+    if (existsSync(SESSION_CACHE_FILE)) {
+      const content = readFileSync(SESSION_CACHE_FILE, "utf-8");
+      const data = JSON.parse(content);
+      if (data.version === CACHE_VERSION) {
+        return data;
+      }
+    }
+  } catch {}
+  return { version: CACHE_VERSION, entries: {} };
+}
+function saveCache(data) {
+  ensureCacheDir();
+  writeFileSync(SESSION_CACHE_FILE, JSON.stringify(data));
+}
+function isCacheValid(filePath, cache2) {
+  const entry = cache2.entries[filePath];
+  if (!entry)
+    return false;
+  try {
+    const stat = statSync(filePath);
+    return entry.mtime === stat.mtimeMs && entry.size === stat.size;
+  } catch {
+    return false;
+  }
+}
+function getFileStats(filePath) {
+  try {
+    const stat = statSync(filePath);
+    return { mtime: stat.mtimeMs, size: stat.size };
+  } catch {
+    return null;
+  }
+}
+class SessionCache {
+  cache;
+  dirty = false;
+  constructor() {
+    this.cache = loadCache();
+  }
+  isValid(filePath) {
+    return isCacheValid(filePath, this.cache);
+  }
+  get(filePath) {
+    if (this.isValid(filePath)) {
+      return this.cache.entries[filePath].session;
+    }
+    return null;
+  }
+  set(filePath, session) {
+    const stats = getFileStats(filePath);
+    if (!stats)
+      return;
+    this.cache.entries[filePath] = {
+      mtime: stats.mtime,
+      size: stats.size,
+      session
+    };
+    this.dirty = true;
+  }
+  save() {
+    if (this.dirty) {
+      saveCache(this.cache);
+      this.dirty = false;
+    }
+  }
+  getStats() {
+    return {
+      total: Object.keys(this.cache.entries).length,
+      hits: 0,
+      misses: 0
+    };
+  }
+  prune() {
+    const before = Object.keys(this.cache.entries).length;
+    for (const filePath of Object.keys(this.cache.entries)) {
+      if (!existsSync(filePath)) {
+        delete this.cache.entries[filePath];
+        this.dirty = true;
+      }
+    }
+    return before - Object.keys(this.cache.entries).length;
+  }
+}
+function clearCache() {
+  try {
+    if (existsSync(SESSION_CACHE_FILE)) {
+      writeFileSync(SESSION_CACHE_FILE, JSON.stringify({ version: CACHE_VERSION, entries: {} }));
+    }
+  } catch {}
+}
+function getCacheInfo() {
+  try {
+    if (existsSync(SESSION_CACHE_FILE)) {
+      const stat = statSync(SESSION_CACHE_FILE);
+      const cache2 = loadCache();
+      return {
+        entries: Object.keys(cache2.entries).length,
+        sizeBytes: stat.size
+      };
+    }
+  } catch {}
+  return { entries: 0, sizeBytes: 0 };
+}
+
 // src/collectors/agents.ts
-async function collectAgentSessions(since) {
+var sessionCache = null;
+async function collectAgentSessions(since, useCache = true) {
+  sessionCache = useCache ? new SessionCache : null;
   const sessions = [];
-  const claudeProjectsDir = join(homedir(), ".claude", "projects");
-  if (existsSync(claudeProjectsDir)) {
+  const claudeProjectsDir = join2(homedir2(), ".claude", "projects");
+  if (existsSync2(claudeProjectsDir)) {
     const claudeSessions = collectClaudeSessions(claudeProjectsDir, since);
     sessions.push(...claudeSessions);
   }
-  const openCodeDir = join(homedir(), ".local", "share", "opencode");
-  if (existsSync(openCodeDir)) {
+  const openCodeDir = join2(homedir2(), ".local", "share", "opencode");
+  if (existsSync2(openCodeDir)) {
     const openCodeSessions = collectOpenCodeSessions(openCodeDir, since);
     sessions.push(...openCodeSessions);
   }
   const cursorDirs = [
-    join(homedir(), ".cursor", "sessions"),
-    join(homedir(), "Library", "Application Support", "Cursor", "sessions"),
-    join(homedir(), ".config", "cursor", "sessions")
+    join2(homedir2(), ".cursor", "sessions"),
+    join2(homedir2(), "Library", "Application Support", "Cursor", "sessions"),
+    join2(homedir2(), ".config", "cursor", "sessions")
   ];
   for (const cursorDir of cursorDirs) {
-    if (existsSync(cursorDir)) {
+    if (existsSync2(cursorDir)) {
       const cursorSessions = collectCursorSessions(cursorDir, since);
       sessions.push(...cursorSessions);
       break;
     }
   }
   const windsurfDirs = [
-    join(homedir(), ".codeium", "chat_history"),
-    join(homedir(), ".windsurf", "sessions"),
-    join(homedir(), "Library", "Application Support", "Windsurf", "sessions")
+    join2(homedir2(), ".codeium", "chat_history"),
+    join2(homedir2(), ".windsurf", "sessions"),
+    join2(homedir2(), "Library", "Application Support", "Windsurf", "sessions")
   ];
   for (const windsurfDir of windsurfDirs) {
-    if (existsSync(windsurfDir)) {
+    if (existsSync2(windsurfDir)) {
       const windsurfSessions = collectWindsurfSessions(windsurfDir, since);
       sessions.push(...windsurfSessions);
       break;
     }
   }
   const copilotDirs = [
-    join(homedir(), ".config", "github-copilot"),
-    join(homedir(), "Library", "Application Support", "Code", "User", "globalStorage", "github.copilot"),
-    join(homedir(), ".vscode", "extensions")
+    join2(homedir2(), ".config", "github-copilot"),
+    join2(homedir2(), "Library", "Application Support", "Code", "User", "globalStorage", "github.copilot"),
+    join2(homedir2(), ".vscode", "extensions")
   ];
   for (const copilotDir of copilotDirs) {
-    if (existsSync(copilotDir)) {
+    if (existsSync2(copilotDir)) {
       const copilotSessions = collectCopilotSessions(copilotDir, since);
       sessions.push(...copilotSessions);
       break;
     }
   }
-  if (sessions.length === 0)
+  if (sessions.length === 0) {
+    sessionCache?.save();
     return null;
+  }
   let totalTokens = 0;
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
@@ -8873,6 +8995,7 @@ async function collectAgentSessions(since) {
       costByModel[session.model] = (costByModel[session.model] ?? 0) + session.costUsd;
     }
   }
+  sessionCache?.save();
   return {
     sessions,
     totalSessions: sessions.length,
@@ -8890,9 +9013,9 @@ async function collectAgentSessions(since) {
 function collectClaudeSessions(projectsDir, since) {
   const sessions = [];
   try {
-    const projectDirs = readdirSync(projectsDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join(projectsDir, d2.name));
+    const projectDirs = readdirSync(projectsDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join2(projectsDir, d2.name));
     for (const projectDir of projectDirs) {
-      const files = readdirSync(projectDir).filter((f3) => f3.endsWith(".jsonl")).map((f3) => join(projectDir, f3));
+      const files = readdirSync(projectDir).filter((f3) => f3.endsWith(".jsonl")).map((f3) => join2(projectDir, f3));
       for (const file of files) {
         const session = parseClaudeSessionFile(file, since);
         if (session) {
@@ -8905,7 +9028,15 @@ function collectClaudeSessions(projectsDir, since) {
 }
 function parseClaudeSessionFile(filePath, since) {
   try {
-    const content = readFileSync(filePath, "utf-8");
+    const cached = sessionCache?.get(filePath);
+    if (cached) {
+      const cachedEndedAt = cached.endedAt ? new Date(cached.endedAt) : null;
+      if (cachedEndedAt && cachedEndedAt >= since) {
+        return cached;
+      }
+      return null;
+    }
+    const content = readFileSync2(filePath, "utf-8");
     const lines = content.trim().split(`
 `).filter(Boolean);
     if (lines.length === 0)
@@ -8970,7 +9101,7 @@ function parseClaudeSessionFile(filePath, since) {
     const durationMinutes = Math.round((endedAt.getTime() - startedAt.getTime()) / 60000);
     const costUsd = calculateTokenCost(model, inputTokens, outputTokens, cachedTokens);
     const patterns = detectPatterns(messages);
-    return {
+    const session = {
       agent: "claude",
       sessionId: basename(filePath, ".jsonl"),
       startedAt: startedAt.toISOString(),
@@ -8987,6 +9118,8 @@ function parseClaudeSessionFile(filePath, since) {
       toolNames: Array.from(toolNamesSet),
       patterns
     };
+    sessionCache?.set(filePath, session);
+    return session;
   } catch {
     return null;
   }
@@ -9157,15 +9290,15 @@ function similarity(a2, b2) {
 }
 function collectOpenCodeSessions(baseDir, since) {
   const sessions = [];
-  const sessionStorageDir = join(baseDir, "storage", "session");
-  const messageStorageDir = join(baseDir, "storage", "message");
-  const partStorageDir = join(baseDir, "storage", "part");
-  if (!existsSync(sessionStorageDir))
+  const sessionStorageDir = join2(baseDir, "storage", "session");
+  const messageStorageDir = join2(baseDir, "storage", "message");
+  const partStorageDir = join2(baseDir, "storage", "part");
+  if (!existsSync2(sessionStorageDir))
     return sessions;
   try {
-    const projectDirs = readdirSync(sessionStorageDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join(sessionStorageDir, d2.name));
+    const projectDirs = readdirSync(sessionStorageDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join2(sessionStorageDir, d2.name));
     for (const projectDir of projectDirs) {
-      const sessionFiles = readdirSync(projectDir).filter((f3) => f3.startsWith("ses_") && f3.endsWith(".json")).map((f3) => join(projectDir, f3));
+      const sessionFiles = readdirSync(projectDir).filter((f3) => f3.startsWith("ses_") && f3.endsWith(".json")).map((f3) => join2(projectDir, f3));
       for (const sessionFile of sessionFiles) {
         const session = parseOpenCodeSession(sessionFile, messageStorageDir, partStorageDir, since);
         if (session) {
@@ -9178,20 +9311,28 @@ function collectOpenCodeSessions(baseDir, since) {
 }
 function parseOpenCodeSession(sessionFile, messageStorageDir, partStorageDir, since) {
   try {
-    const sessionContent = readFileSync(sessionFile, "utf-8");
+    const cached = sessionCache?.get(sessionFile);
+    if (cached) {
+      const cachedEndedAt = cached.endedAt ? new Date(cached.endedAt) : null;
+      if (cachedEndedAt && cachedEndedAt >= since) {
+        return cached;
+      }
+      return null;
+    }
+    const sessionContent = readFileSync2(sessionFile, "utf-8");
     const session = JSON.parse(sessionContent);
     const sessionStart = new Date(session.time.created);
     const sessionEnd = session.time.updated ? new Date(session.time.updated) : sessionStart;
     if (sessionEnd < since)
       return null;
-    const messagesDir = join(messageStorageDir, session.id);
-    if (!existsSync(messagesDir))
+    const messagesDir = join2(messageStorageDir, session.id);
+    if (!existsSync2(messagesDir))
       return null;
-    const messageFiles = readdirSync(messagesDir).filter((f3) => f3.startsWith("msg_") && f3.endsWith(".json")).map((f3) => join(messagesDir, f3));
+    const messageFiles = readdirSync(messagesDir).filter((f3) => f3.startsWith("msg_") && f3.endsWith(".json")).map((f3) => join2(messagesDir, f3));
     const messages = [];
     for (const msgFile of messageFiles) {
       try {
-        const msgContent = readFileSync(msgFile, "utf-8");
+        const msgContent = readFileSync2(msgFile, "utf-8");
         messages.push(JSON.parse(msgContent));
       } catch {}
     }
@@ -9223,7 +9364,7 @@ function parseOpenCodeSession(sessionFile, messageStorageDir, partStorageDir, si
     const durationMinutes = Math.round((sessionEnd.getTime() - sessionStart.getTime()) / 60000);
     const costUsd = calculateTokenCost(model, inputTokens, outputTokens, cachedTokens);
     const patterns = detectOpenCodePatterns(messages, partStorageDir);
-    return {
+    const agentSession = {
       agent: "opencode",
       sessionId: session.id,
       startedAt: sessionStart.toISOString(),
@@ -9240,6 +9381,8 @@ function parseOpenCodeSession(sessionFile, messageStorageDir, partStorageDir, si
       toolNames: [],
       patterns
     };
+    sessionCache?.set(sessionFile, agentSession);
+    return agentSession;
   } catch {
     return null;
   }
@@ -9251,14 +9394,14 @@ function detectOpenCodePatterns(messages, partStorageDir) {
     const msg = messages[i2];
     if (msg.role !== "user")
       continue;
-    const partDir = join(partStorageDir, msg.id);
-    if (!existsSync(partDir))
+    const partDir = join2(partStorageDir, msg.id);
+    if (!existsSync2(partDir))
       continue;
     try {
       const partFiles = readdirSync(partDir).filter((f3) => f3.endsWith(".json"));
       let text = "";
       for (const partFile of partFiles) {
-        const partContent = readFileSync(join(partDir, partFile), "utf-8");
+        const partContent = readFileSync2(join2(partDir, partFile), "utf-8");
         const part = JSON.parse(partContent);
         if (part.type === "text" && part.text) {
           text += part.text + " ";
@@ -9384,9 +9527,9 @@ function collectCursorSessions(sessionsDir, since) {
   try {
     const files = readdirSync(sessionsDir).filter((f3) => f3.endsWith(".json") || f3.endsWith(".jsonl"));
     for (const file of files) {
-      const filePath = join(sessionsDir, file);
+      const filePath = join2(sessionsDir, file);
       try {
-        const content = readFileSync(filePath, "utf-8");
+        const content = readFileSync2(filePath, "utf-8");
         let data;
         if (content.startsWith("[")) {
           data = JSON.parse(content);
@@ -9431,7 +9574,7 @@ function collectCursorSessions(sessionsDir, since) {
           outputTokens,
           cachedTokens: 0,
           totalTokens,
-          costUsd: calculateTokenCost(inputTokens, outputTokens, "gpt-4"),
+          costUsd: calculateTokenCost(firstEntry?.model || "gpt-4", inputTokens, outputTokens),
           model: firstEntry?.model || "gpt-4",
           toolCalls: 0,
           messageCount,
@@ -9448,9 +9591,9 @@ function collectWindsurfSessions(sessionsDir, since) {
   try {
     const files = readdirSync(sessionsDir).filter((f3) => f3.endsWith(".json") || f3.endsWith(".jsonl"));
     for (const file of files) {
-      const filePath = join(sessionsDir, file);
+      const filePath = join2(sessionsDir, file);
       try {
-        const content = readFileSync(filePath, "utf-8");
+        const content = readFileSync2(filePath, "utf-8");
         let data;
         if (content.startsWith("[")) {
           data = JSON.parse(content);
@@ -9494,7 +9637,7 @@ function collectWindsurfSessions(sessionsDir, since) {
           outputTokens,
           cachedTokens: 0,
           totalTokens,
-          costUsd: calculateTokenCost(inputTokens, outputTokens, "gpt-4"),
+          costUsd: calculateTokenCost(firstEntry?.model || "codeium", inputTokens, outputTokens),
           model: firstEntry?.model || "codeium",
           toolCalls: 0,
           messageCount,
@@ -9510,19 +9653,19 @@ function collectCopilotSessions(copilotDir, since) {
   const sessions = [];
   try {
     const searchPaths = [
-      join(copilotDir, "usage"),
-      join(copilotDir, "telemetry"),
-      join(copilotDir, "chat"),
+      join2(copilotDir, "usage"),
+      join2(copilotDir, "telemetry"),
+      join2(copilotDir, "chat"),
       copilotDir
     ];
     for (const searchPath of searchPaths) {
-      if (!existsSync(searchPath))
+      if (!existsSync2(searchPath))
         continue;
       const files = readdirSync(searchPath).filter((f3) => f3.endsWith(".json") || f3.endsWith(".jsonl") || f3.endsWith(".log"));
       for (const file of files) {
-        const filePath = join(searchPath, file);
+        const filePath = join2(searchPath, file);
         try {
-          const content = readFileSync(filePath, "utf-8");
+          const content = readFileSync2(filePath, "utf-8");
           let entries = [];
           try {
             if (content.startsWith("[")) {
@@ -9584,8 +9727,8 @@ function collectCopilotSessions(copilotDir, since) {
 }
 
 // src/collectors/tests.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
 async function collectTestResults(projectDir) {
   const vitestResult = tryVitestReport(projectDir);
   if (vitestResult)
@@ -9600,16 +9743,16 @@ async function collectTestResults(projectDir) {
 }
 function tryVitestReport(projectDir) {
   const paths = [
-    join2(projectDir, "test-results", "vitest-results.json"),
-    join2(projectDir, "coverage", "coverage-summary.json")
+    join3(projectDir, "test-results", "vitest-results.json"),
+    join3(projectDir, "coverage", "coverage-summary.json")
   ];
-  const hasVitest = ["vitest.config.ts", "vitest.config.js", "vitest.config.mts"].some((f3) => existsSync2(join2(projectDir, f3)));
+  const hasVitest = ["vitest.config.ts", "vitest.config.js", "vitest.config.mts"].some((f3) => existsSync3(join3(projectDir, f3)));
   if (!hasVitest)
     return null;
   for (const p of paths) {
-    if (existsSync2(p)) {
+    if (existsSync3(p)) {
       try {
-        const data = JSON.parse(readFileSync2(p, "utf-8"));
+        const data = JSON.parse(readFileSync3(p, "utf-8"));
         return parseVitestJson(data);
       } catch {}
     }
@@ -9645,16 +9788,16 @@ function parseVitestJson(data) {
 }
 function tryJestReport(projectDir) {
   const paths = [
-    join2(projectDir, "test-results", "jest-results.json"),
-    join2(projectDir, "jest-results.json")
+    join3(projectDir, "test-results", "jest-results.json"),
+    join3(projectDir, "jest-results.json")
   ];
-  const hasJest = ["jest.config.ts", "jest.config.js", "jest.config.mjs"].some((f3) => existsSync2(join2(projectDir, f3)));
+  const hasJest = ["jest.config.ts", "jest.config.js", "jest.config.mjs"].some((f3) => existsSync3(join3(projectDir, f3)));
   if (!hasJest)
     return null;
   for (const p of paths) {
-    if (existsSync2(p)) {
+    if (existsSync3(p)) {
       try {
-        const data = JSON.parse(readFileSync2(p, "utf-8"));
+        const data = JSON.parse(readFileSync3(p, "utf-8"));
         return {
           framework: "jest",
           totalTests: data.numTotalTests ?? 0,
@@ -9675,13 +9818,13 @@ function tryPlaywrightReport(projectDir) {
   const hasPlaywright = [
     "playwright.config.ts",
     "playwright.config.js"
-  ].some((f3) => existsSync2(join2(projectDir, f3)));
+  ].some((f3) => existsSync3(join3(projectDir, f3)));
   if (!hasPlaywright)
     return null;
-  const reportPath = join2(projectDir, "test-results", "results.json");
-  if (existsSync2(reportPath)) {
+  const reportPath = join3(projectDir, "test-results", "results.json");
+  if (existsSync3(reportPath)) {
     try {
-      const data = JSON.parse(readFileSync2(reportPath, "utf-8"));
+      const data = JSON.parse(readFileSync3(reportPath, "utf-8"));
       const suites = data.suites ?? [];
       let passed = 0;
       let failed = 0;
@@ -9722,9 +9865,9 @@ function tryPlaywrightReport(projectDir) {
 init_client();
 
 // src/lib/analyzer.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
 import { execSync } from "node:child_process";
 function analyzeWorkflow(agents, projectDir) {
   const sessionPatterns = analyzeSessionPatterns(agents);
@@ -9829,10 +9972,10 @@ function analyzeEfficiency(agents) {
   };
 }
 function detectEnvironment(projectDir, agents) {
-  const home = homedir3();
-  const claudeConfigDir = join4(home, ".claude");
-  const hasClaudeRules = existsSync4(join4(projectDir, "CLAUDE.md")) || existsSync4(join4(projectDir, ".claude", "settings.local.json")) || existsSync4(join4(projectDir, ".cursorrules")) || existsSync4(join4(projectDir, ".clauderules"));
-  const hasAgentsmd = existsSync4(join4(projectDir, "AGENTS.md"));
+  const home = homedir4();
+  const claudeConfigDir = join5(home, ".claude");
+  const hasClaudeRules = existsSync5(join5(projectDir, "CLAUDE.md")) || existsSync5(join5(projectDir, ".claude", "settings.local.json")) || existsSync5(join5(projectDir, ".cursorrules")) || existsSync5(join5(projectDir, ".clauderules"));
+  const hasAgentsmd = existsSync5(join5(projectDir, "AGENTS.md"));
   let hasSupermemory = false;
   let hasContext7 = false;
   let hasNia = false;
@@ -9886,13 +10029,13 @@ function detectEnvironment(projectDir, agents) {
       }
     }
   }
-  const transcriptsDir = join4(home, ".claude", "transcripts");
-  if (!hasSupermemory && existsSync4(transcriptsDir)) {
+  const transcriptsDir = join5(home, ".claude", "transcripts");
+  if (!hasSupermemory && existsSync5(transcriptsDir)) {
     try {
       const transcriptFiles = readdirSync2(transcriptsDir).filter((f3) => f3.endsWith(".jsonl")).slice(-20);
       for (const file of transcriptFiles) {
         try {
-          const content = readFileSync4(join4(transcriptsDir, file), "utf-8");
+          const content = readFileSync5(join5(transcriptsDir, file), "utf-8");
           if (content.includes('"tool_name":"supermemory"') || content.includes('"name":"supermemory"') || content.includes("supermemory")) {
             hasSupermemory = true;
             if (!detectedMcps.includes("supermemory")) {
@@ -9905,18 +10048,18 @@ function detectEnvironment(projectDir, agents) {
       }
     } catch {}
   }
-  const claudeSettingsLocal = join4(home, ".claude", "settings.local.json");
-  const claudeProjectSettings = join4(projectDir, ".claude", "settings.local.json");
+  const claudeSettingsLocal = join5(home, ".claude", "settings.local.json");
+  const claudeProjectSettings = join5(projectDir, ".claude", "settings.local.json");
   const mcpConfigPaths = [
-    join4(home, ".claude", "claude_desktop_config.json"),
-    join4(home, ".claude", "settings.json"),
+    join5(home, ".claude", "claude_desktop_config.json"),
+    join5(home, ".claude", "settings.json"),
     claudeSettingsLocal,
     claudeProjectSettings
   ];
   for (const configPath of mcpConfigPaths) {
-    if (existsSync4(configPath)) {
+    if (existsSync5(configPath)) {
       try {
-        const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+        const config = JSON.parse(readFileSync5(configPath, "utf-8"));
         const mcpServers = config.mcpServers || config.mcp_servers || {};
         for (const [name, _3] of Object.entries(mcpServers)) {
           const mcpName = name.toLowerCase();
@@ -9940,12 +10083,12 @@ function detectEnvironment(projectDir, agents) {
       } catch {}
     }
   }
-  const agentsMdPath = join4(projectDir, "AGENTS.md");
-  const globalAgentsMdPath = join4(home, ".config", "Claude", "AGENTS.md");
+  const agentsMdPath = join5(projectDir, "AGENTS.md");
+  const globalAgentsMdPath = join5(home, ".config", "Claude", "AGENTS.md");
   for (const agentsMd of [agentsMdPath, globalAgentsMdPath]) {
-    if (existsSync4(agentsMd)) {
+    if (existsSync5(agentsMd)) {
       try {
-        const content = readFileSync4(agentsMd, "utf-8").toLowerCase();
+        const content = readFileSync5(agentsMd, "utf-8").toLowerCase();
         if (content.includes("context7") || content.includes("context-7")) {
           hasContext7 = true;
           if (!detectedMcps.includes("context7")) {
@@ -10003,16 +10146,16 @@ function detectEnvironment(projectDir, agents) {
     } catch {}
   }
   if (!hasBeads) {
-    hasBeads = existsSync4(join4(projectDir, ".beads"));
+    hasBeads = existsSync5(join5(projectDir, ".beads"));
   }
   let hasSkills = false;
   let skillCount = 0;
   const skillsDirs = [
-    join4(claudeConfigDir, "skills"),
-    join4(home, ".agents", "skills")
+    join5(claudeConfigDir, "skills"),
+    join5(home, ".agents", "skills")
   ];
   for (const skillsDir of skillsDirs) {
-    if (existsSync4(skillsDir)) {
+    if (existsSync5(skillsDir)) {
       try {
         const skills = readdirSync2(skillsDir, { withFileTypes: true }).filter((d2) => d2.isDirectory() || d2.isSymbolicLink());
         skillCount += skills.length;
@@ -10223,7 +10366,7 @@ function analyzeRequirements(agents, git, projectDir) {
       recommendations.push("Spend more time understanding the problem before implementing");
     }
   }
-  const hasRequirementsDocs = existsSync4(join4(projectDir, "CLAUDE.md")) || existsSync4(join4(projectDir, "docs", "requirements.md")) || existsSync4(join4(projectDir, "PRD.md"));
+  const hasRequirementsDocs = existsSync5(join5(projectDir, "CLAUDE.md")) || existsSync5(join5(projectDir, "docs", "requirements.md")) || existsSync5(join5(projectDir, "PRD.md"));
   if (hasRequirementsDocs) {
     score += 10;
   } else {
@@ -10250,18 +10393,18 @@ function analyzePlanning(agents, git, projectDir) {
   const issues = [];
   const recommendations = [];
   let score = 50;
-  const usesTaskTracking = existsSync4(join4(projectDir, ".beads"));
+  const usesTaskTracking = existsSync5(join5(projectDir, ".beads"));
   if (usesTaskTracking) {
     score += 20;
   } else {
     issues.push("No task tracking system detected");
     recommendations.push("Install Beads for persistent task tracking: bun add -g beads && bd init");
   }
-  const usesDesignDocs = existsSync4(join4(projectDir, "docs", "design.md")) || existsSync4(join4(projectDir, "ARCHITECTURE.md")) || existsSync4(join4(projectDir, "docs", "spec.md"));
+  const usesDesignDocs = existsSync5(join5(projectDir, "docs", "design.md")) || existsSync5(join5(projectDir, "ARCHITECTURE.md")) || existsSync5(join5(projectDir, "docs", "spec.md"));
   if (usesDesignDocs) {
     score += 15;
   }
-  const hasSystemDesign = existsSync4(join4(projectDir, "CLAUDE.md")) || existsSync4(join4(projectDir, "AGENTS.md")) || existsSync4(join4(projectDir, ".claude", "settings.local.json"));
+  const hasSystemDesign = existsSync5(join5(projectDir, "CLAUDE.md")) || existsSync5(join5(projectDir, "AGENTS.md")) || existsSync5(join5(projectDir, ".claude", "settings.local.json"));
   if (hasSystemDesign) {
     score += 15;
   } else {
@@ -10363,7 +10506,7 @@ function analyzeTestingPhase(agents, tests, projectDir) {
   const issues = [];
   const recommendations = [];
   let score = 40;
-  const hasTestFramework = tests !== null || existsSync4(join4(projectDir, "vitest.config.ts")) || existsSync4(join4(projectDir, "jest.config.js")) || existsSync4(join4(projectDir, "playwright.config.ts"));
+  const hasTestFramework = tests !== null || existsSync5(join5(projectDir, "vitest.config.ts")) || existsSync5(join5(projectDir, "jest.config.js")) || existsSync5(join5(projectDir, "playwright.config.ts"));
   if (hasTestFramework) {
     score += 15;
   } else {
@@ -14023,6 +14166,11 @@ var scanCommand = defineCommand2({
       alias: "q",
       description: "Quiet mode - only output the score number",
       default: false
+    },
+    "no-cache": {
+      type: "boolean",
+      description: "Disable session caching (slower but ensures fresh data)",
+      default: false
     }
   },
   async run({ args }) {
@@ -14030,6 +14178,7 @@ var scanCommand = defineCommand2({
     const since = parseSince(args.since);
     const jsonOutput = args.json;
     const quietMode = args.quiet;
+    const useCache = !args["no-cache"];
     const silent = jsonOutput || quietMode;
     if (!silent) {
       console.log();
@@ -14047,7 +14196,7 @@ var scanCommand = defineCommand2({
     }
     if (!silent)
       await thinkingStep("Scanning AI session logs...", 600);
-    const agents = await collectAgentSessions(since);
+    const agents = await collectAgentSessions(since, useCache);
     if (agents && !silent) {
       await revealDiscovery(icons.success, `Sessions: ${colors2.primary(agents.totalSessions.toString())} sessions loaded`, 200);
     }
@@ -14142,7 +14291,7 @@ var scanCommand = defineCommand2({
       console.log(colors2.dim("  " + "═".repeat(45)));
       console.log();
       if (!args["no-report"]) {
-        const reportDir = join5(projectDir, args["report-dir"]);
+        const reportDir = join6(projectDir, args["report-dir"]);
         const reportPath = generateReport(reportDir, score, git, agents, tests, args.since, sdlcAnalysis, scanCost, analysis);
         console.log(`  ${icons.success} Report saved: ${colors2.dim(reportPath)}`);
       }
@@ -14302,12 +14451,12 @@ function parseSince(since) {
   return new Date(Date.now() - ms);
 }
 function generateReport(reportDir, score, git, agents, tests, since, sdlcAnalysis, scanCost, analysis) {
-  if (!existsSync5(reportDir)) {
-    mkdirSync2(reportDir, { recursive: true });
+  if (!existsSync6(reportDir)) {
+    mkdirSync3(reportDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = `scan-${timestamp}.md`;
-  const filepath = join5(reportDir, filename);
+  const filepath = join6(reportDir, filename);
   const lines = [];
   lines.push(`# NaironAI Scan Report`);
   lines.push("");
@@ -14423,7 +14572,7 @@ function generateReport(reportDir, score, git, agents, tests, since, sdlcAnalysi
   lines.push("---");
   lines.push("");
   lines.push("*Generated by [nairon-bench](https://github.com/ObaidUr-Rahmaan/nairon-bench)*");
-  writeFileSync2(filepath, lines.join(`
+  writeFileSync3(filepath, lines.join(`
 `));
   return filepath;
 }
@@ -14622,9 +14771,9 @@ function renderBar(value, width) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join7 } from "node:path";
 init_client();
 var doctorCommand = defineCommand2({
   meta: {
@@ -14642,16 +14791,16 @@ var doctorCommand = defineCommand2({
     results.push({ label: "OS", status: "info", value: `${process.platform} ${process.arch}` });
     results.push({ label: "Bun", status: "info", value: typeof Bun !== "undefined" ? Bun.version : "N/A" });
     results.push({ label: "Node", status: "info", value: process.version });
-    results.push({ label: "Home", status: "info", value: homedir4() });
-    const gitDir = join6(process.cwd(), ".git");
-    if (existsSync6(gitDir)) {
+    results.push({ label: "Home", status: "info", value: homedir5() });
+    const gitDir = join7(process.cwd(), ".git");
+    if (existsSync7(gitDir)) {
       results.push({ label: "Git", status: "success", value: "Repository detected" });
     } else {
       results.push({ label: "Git", status: "warn", value: "No repository in current directory" });
     }
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir4());
-      if (existsSync6(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir5());
+      if (existsSync7(resolvedPath)) {
         results.push({ label: agent, status: "success", value: `found at ${resolvedPath}` });
       }
     }
@@ -14706,9 +14855,9 @@ var doctorCommand = defineCommand2({
 
 // src/commands/init.ts
 init_dist();
-import { existsSync as existsSync7 } from "node:fs";
-import { homedir as homedir5, platform as platform2, arch } from "node:os";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { homedir as homedir6, platform as platform2, arch } from "node:os";
+import { join as join8 } from "node:path";
 init_client();
 
 // src/lib/github-auth.ts
@@ -14878,8 +15027,8 @@ var initCommand = defineCommand2({
     consola.start("Step 2/6: Detecting AI agents...");
     const detectedAgents = [];
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir5());
-      if (existsSync7(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir6());
+      if (existsSync8(resolvedPath)) {
         detectedAgents.push(agent);
         consola.success(`  Found: ${agent}`);
       }
@@ -14982,7 +15131,7 @@ var initCommand = defineCommand2({
       { name: "playwright", configs: ["playwright.config.ts", "playwright.config.js"] }
     ];
     for (const fw of testFrameworks) {
-      if (fw.configs.some((c3) => existsSync7(join7(process.cwd(), c3)))) {
+      if (fw.configs.some((c3) => existsSync8(join8(process.cwd(), c3)))) {
         toolStack.testing.push(fw.name);
       }
     }
@@ -15051,13 +15200,13 @@ var initCommand = defineCommand2({
 });
 function detectPackageManager() {
   const cwd = process.cwd();
-  if (existsSync7(join7(cwd, "bun.lock")) || existsSync7(join7(cwd, "bun.lockb")))
+  if (existsSync8(join8(cwd, "bun.lock")) || existsSync8(join8(cwd, "bun.lockb")))
     return "bun";
-  if (existsSync7(join7(cwd, "pnpm-lock.yaml")))
+  if (existsSync8(join8(cwd, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync7(join7(cwd, "yarn.lock")))
+  if (existsSync8(join8(cwd, "yarn.lock")))
     return "yarn";
-  if (existsSync7(join7(cwd, "package-lock.json")))
+  if (existsSync8(join8(cwd, "package-lock.json")))
     return "npm";
   return;
 }
@@ -15072,15 +15221,15 @@ var CLAUDE_CODE_SKILLS = [
 ];
 function detectEasyWins(detectedAgents) {
   const wins = [];
-  const home = homedir5();
+  const home = homedir6();
   const hasClaudeCode = detectedAgents.some((a2) => a2.toLowerCase().includes("claude") || a2.toLowerCase().includes("opencode"));
-  const claudeConfigDir = join7(home, ".claude");
-  const hasClaudeConfig = existsSync7(claudeConfigDir);
+  const claudeConfigDir = join8(home, ".claude");
+  const hasClaudeConfig = existsSync8(claudeConfigDir);
   if (hasClaudeCode || hasClaudeConfig) {
-    const skillsDir = join7(home, ".claude", "skills");
+    const skillsDir = join8(home, ".claude", "skills");
     for (const skill of CLAUDE_CODE_SKILLS) {
-      const skillPath = join7(skillsDir, skill.id);
-      const isInstalled = existsSync7(skillPath);
+      const skillPath = join8(skillsDir, skill.id);
+      const isInstalled = existsSync8(skillPath);
       if (!isInstalled) {
         wins.push({
           icon: skill.icon,
@@ -15851,9 +16000,9 @@ function renderBar2(value, width) {
 // src/commands/publish.ts
 init_dist();
 init_client();
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { join as join8 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join9 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 var publishCommand = defineCommand2({
   meta: {
     name: "publish",
@@ -15877,7 +16026,7 @@ var publishCommand = defineCommand2({
   },
   async run({ args }) {
     const projectDir = args.project ?? process.cwd();
-    const reportDir = join8(projectDir, args["report-dir"]);
+    const reportDir = join9(projectDir, args["report-dir"]);
     consola.start(`Analyzing your AI workflow...
 `);
     consola.info("Reading scan reports...");
@@ -15957,12 +16106,12 @@ var publishCommand = defineCommand2({
   }
 });
 function readReports(reportDir) {
-  if (!existsSync8(reportDir)) {
+  if (!existsSync9(reportDir)) {
     return [];
   }
   const files = readdirSync3(reportDir).filter((f3) => f3.endsWith(".md") && f3.startsWith("scan-")).sort();
   return files.map((file) => {
-    const content = readFileSync5(join8(reportDir, file), "utf-8");
+    const content = readFileSync6(join9(reportDir, file), "utf-8");
     return parseReport(content, file);
   });
 }
@@ -15991,13 +16140,13 @@ function parseReport(content, filename) {
   return { date, overall, tier, tokenEfficiency, tokenWaste, phases, models };
 }
 function detectConcepts(projectDir) {
-  const home = homedir6();
+  const home = homedir7();
   return {
-    skills: existsSync8(join8(home, ".claude", "settings.json")) && readFileSync5(join8(home, ".claude", "settings.json"), "utf-8").includes("skill"),
-    mcpServers: existsSync8(join8(home, ".config", "opencode", "config.json")) || existsSync8(join8(home, ".claude", "claude_desktop_config.json")) || existsSync8(join8(home, ".claude", "settings.json")) && readFileSync5(join8(home, ".claude", "settings.json"), "utf-8").includes("mcpServers"),
-    customCommands: existsSync8(join8(home, ".claude", "commands")) || existsSync8(join8(projectDir, ".claude", "commands")),
-    agentConfig: existsSync8(join8(projectDir, "AGENTS.md")) || existsSync8(join8(projectDir, ".cursorrules")) || existsSync8(join8(projectDir, ".github", "copilot-instructions.md")),
-    contextManagement: existsSync8(join8(projectDir, "MEMORY.md")) || existsSync8(join8(projectDir, ".context")) || existsSync8(join8(projectDir, "docs", "architecture.md")) || existsSync8(join8(projectDir, ".beads"))
+    skills: existsSync9(join9(home, ".claude", "settings.json")) && readFileSync6(join9(home, ".claude", "settings.json"), "utf-8").includes("skill"),
+    mcpServers: existsSync9(join9(home, ".config", "opencode", "config.json")) || existsSync9(join9(home, ".claude", "claude_desktop_config.json")) || existsSync9(join9(home, ".claude", "settings.json")) && readFileSync6(join9(home, ".claude", "settings.json"), "utf-8").includes("mcpServers"),
+    customCommands: existsSync9(join9(home, ".claude", "commands")) || existsSync9(join9(projectDir, ".claude", "commands")),
+    agentConfig: existsSync9(join9(projectDir, "AGENTS.md")) || existsSync9(join9(projectDir, ".cursorrules")) || existsSync9(join9(projectDir, ".github", "copilot-instructions.md")),
+    contextManagement: existsSync9(join9(projectDir, "MEMORY.md")) || existsSync9(join9(projectDir, ".context")) || existsSync9(join9(projectDir, "docs", "architecture.md")) || existsSync9(join9(projectDir, ".beads"))
   };
 }
 function computeConceptsScore(concepts) {
@@ -16018,18 +16167,18 @@ function computeConceptsScore(concepts) {
 }
 function detectTools(projectDir) {
   const tools = [];
-  const home = homedir6();
+  const home = homedir7();
   const toolChecks = [
-    { name: "Claude Code", check: () => existsSync8(join8(home, ".claude")) },
-    { name: "Cursor", check: () => existsSync8(join8(projectDir, ".cursorrules")) },
-    { name: "GitHub Copilot", check: () => existsSync8(join8(projectDir, ".github", "copilot-instructions.md")) },
-    { name: "OpenCode", check: () => existsSync8(join8(home, ".config", "opencode")) },
-    { name: "Windsurf", check: () => existsSync8(join8(home, ".windsurf")) },
-    { name: "Aider", check: () => existsSync8(join8(projectDir, ".aider.conf.yml")) },
-    { name: "Codeium", check: () => existsSync8(join8(home, ".codeium")) },
-    { name: "Beads", check: () => existsSync8(join8(projectDir, ".beads")) },
-    { name: "Convex", check: () => existsSync8(join8(projectDir, "convex")) },
-    { name: "Supabase", check: () => existsSync8(join8(projectDir, "supabase")) }
+    { name: "Claude Code", check: () => existsSync9(join9(home, ".claude")) },
+    { name: "Cursor", check: () => existsSync9(join9(projectDir, ".cursorrules")) },
+    { name: "GitHub Copilot", check: () => existsSync9(join9(projectDir, ".github", "copilot-instructions.md")) },
+    { name: "OpenCode", check: () => existsSync9(join9(home, ".config", "opencode")) },
+    { name: "Windsurf", check: () => existsSync9(join9(home, ".windsurf")) },
+    { name: "Aider", check: () => existsSync9(join9(projectDir, ".aider.conf.yml")) },
+    { name: "Codeium", check: () => existsSync9(join9(home, ".codeium")) },
+    { name: "Beads", check: () => existsSync9(join9(projectDir, ".beads")) },
+    { name: "Convex", check: () => existsSync9(join9(projectDir, "convex")) },
+    { name: "Supabase", check: () => existsSync9(join9(projectDir, "supabase")) }
   ];
   for (const { name, check } of toolChecks) {
     try {
@@ -16439,9 +16588,9 @@ function formatTokens3(tokens) {
 }
 
 // src/commands/session.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join9, basename as basename2 } from "node:path";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync2 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join10, basename as basename2 } from "node:path";
 var sessionCommand = defineCommand2({
   meta: {
     name: "session",
@@ -16600,23 +16749,23 @@ var sessionCommand = defineCommand2({
 });
 async function collectSessionList() {
   const sessions = [];
-  const claudeProjectsDir = join9(homedir7(), ".claude", "projects");
-  if (!existsSync9(claudeProjectsDir)) {
+  const claudeProjectsDir = join10(homedir8(), ".claude", "projects");
+  if (!existsSync10(claudeProjectsDir)) {
     return sessions;
   }
   const projectDirs = readdirSync4(claudeProjectsDir);
   for (const projectDir of projectDirs) {
-    const projectPath = join9(claudeProjectsDir, projectDir);
-    const stat = statSync(projectPath);
+    const projectPath = join10(claudeProjectsDir, projectDir);
+    const stat = statSync2(projectPath);
     if (!stat.isDirectory())
       continue;
     const projectName = decodeProjectName(projectDir);
     const files = readdirSync4(projectPath).filter((f3) => f3.endsWith(".jsonl"));
     for (const file of files) {
-      const filePath = join9(projectPath, file);
+      const filePath = join10(projectPath, file);
       const sessionId = basename2(file, ".jsonl").slice(0, 8);
       try {
-        const content = readFileSync6(filePath, "utf-8");
+        const content = readFileSync7(filePath, "utf-8");
         const lines = content.trim().split(`
 `).filter(Boolean);
         if (lines.length === 0)
@@ -16658,7 +16807,7 @@ async function collectSessionList() {
         if (cost === 0 && totalTokens > 0) {
           cost = totalTokens / 1e6 * 3;
         }
-        const fileStat = statSync(filePath);
+        const fileStat = statSync2(filePath);
         const duration = Math.round((fileStat.mtimeMs - startedAt.getTime()) / 60000);
         sessions.push({
           id: sessionId,
@@ -16690,7 +16839,7 @@ async function parseSessionDetails(filePath) {
     patterns: []
   };
   try {
-    const content = readFileSync6(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     const lines = content.trim().split(`
 `).filter(Boolean);
     const filesSet = new Set;
@@ -16772,7 +16921,7 @@ function decodeProjectName(encoded) {
 }
 
 // src/commands/export.ts
-import { writeFileSync as writeFileSync3 } from "node:fs";
+import { writeFileSync as writeFileSync4 } from "node:fs";
 var exportCommand = defineCommand2({
   meta: {
     name: "export",
@@ -16890,12 +17039,12 @@ var exportCommand = defineCommand2({
     for (const fmt of formats) {
       if (fmt === "json") {
         const jsonPath = `${basePath}.json`;
-        writeFileSync3(jsonPath, JSON.stringify(exportData, null, 2));
+        writeFileSync4(jsonPath, JSON.stringify(exportData, null, 2));
         console.log(`  ${icons.success} Exported: ${colors2.primary(jsonPath)}`);
       } else if (fmt === "csv") {
         const csvPath = `${basePath}.csv`;
         const csv = generateCSV(exportData);
-        writeFileSync3(csvPath, csv);
+        writeFileSync4(csvPath, csv);
         console.log(`  ${icons.success} Exported: ${colors2.primary(csvPath)}`);
       }
     }
@@ -17424,6 +17573,65 @@ var badgesCommand = defineCommand2({
   }
 });
 
+// src/commands/cache.ts
+var cacheCommand = defineCommand2({
+  meta: {
+    name: "cache",
+    description: "Manage the session cache for faster scans"
+  },
+  args: {
+    clear: {
+      type: "boolean",
+      description: "Clear the session cache",
+      default: false
+    },
+    info: {
+      type: "boolean",
+      description: "Show cache statistics",
+      default: false
+    }
+  },
+  async run({ args }) {
+    console.log();
+    console.log(colors2.bold(colors2.primary("  Session Cache")));
+    console.log(colors2.dim("  " + "─".repeat(40)));
+    console.log();
+    if (args.clear) {
+      const spinner = createSpinner("Clearing cache...");
+      spinner.start();
+      try {
+        clearCache();
+        spinner.succeed("Cache cleared");
+      } catch (err) {
+        spinner.fail("Failed to clear cache");
+        console.log(`  ${colors2.dim(err instanceof Error ? err.message : String(err))}`);
+      }
+      console.log();
+      return;
+    }
+    const info2 = getCacheInfo();
+    console.log(`  ${icons.info} Cache Status`);
+    console.log();
+    console.log(`  ${colors2.dim("Cached sessions:")} ${colors2.primary(info2.entries.toString())}`);
+    console.log(`  ${colors2.dim("Cache size:")} ${colors2.primary(formatBytes(info2.sizeBytes))}`);
+    console.log();
+    if (info2.entries > 0) {
+      console.log(`  ${colors2.dim("Run")} ${colors2.primary("nb cache --clear")} ${colors2.dim("to clear the cache")}`);
+    } else {
+      console.log(`  ${colors2.dim("Cache is empty. Run")} ${colors2.primary("nb scan")} ${colors2.dim("to populate it.")}`);
+    }
+    console.log();
+  }
+});
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k2 = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i3 = Math.floor(Math.log(bytes) / Math.log(k2));
+  return `${parseFloat((bytes / Math.pow(k2, i3)).toFixed(1))} ${sizes[i3]}`;
+}
+
 // src/index.ts
 var VERSION = "0.0.13";
 var CYAN = "\x1B[36m";
@@ -17454,7 +17662,7 @@ function showBanner() {
   log("");
 }
 var args = process.argv.slice(2);
-var subcommands = ["init", "scan", "report", "dashboard", "insights", "tools", "doctor", "publish", "history", "cost", "session", "export", "pr", "badges"];
+var subcommands = ["init", "scan", "report", "dashboard", "insights", "tools", "doctor", "publish", "history", "cost", "session", "export", "pr", "badges", "cache"];
 var hasSubcommand = args.some((arg) => subcommands.includes(arg));
 var hasHelp = args.includes("--help") || args.includes("-h");
 var hasVersion = args.includes("--version");
@@ -17481,7 +17689,8 @@ if (!hasSubcommand && !hasHelp && !hasVersion && args.length === 0) {
       session: sessionCommand,
       export: exportCommand,
       pr: prCommand,
-      badges: badgesCommand
+      badges: badgesCommand,
+      cache: cacheCommand
     }
   });
   runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nairon-bench",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "AI workflow benchmarking CLI",
   "type": "module",
   "bin": {