codesesh 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,20 +1,27 @@
 #!/usr/bin/env node
 import {
+  BookmarkStorageUnavailableError,
+  classifySessionTags,
+  computeIdentity,
   createRegisteredAgents,
   deleteBookmark,
   filterSessions,
   getAgentInfoMap,
   getCursorDataPath,
+  getSmartTagSourceTimestamp,
   importBookmarks,
   listBookmarks,
+  listCachedProjectGroups,
   perf,
+  realFs,
+  refreshPricingCache,
   resolveProviderRoots,
   saveCachedSessions,
   scanSessions,
   searchSessions,
   syncSessionSearchIndex,
   upsertBookmark
-} from "./chunk-EIIG7J6V.js";
+} from "./chunk-FZNZAMTZ.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -23,14 +30,144 @@ import { defineCommand, runMain } from "citty";
 import { Hono as Hono2 } from "hono";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { logger } from "hono/logger";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 
 // src/api/routes.ts
 import { Hono } from "hono";
 
+// src/logging.ts
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  unlinkSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var LEVEL_WEIGHT = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function parseLevel(value) {
+  if (value === "debug" || value === "info" || value === "warn" || value === "error") {
+    return value;
+  }
+  return "info";
+}
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function getDefaultLogDir() {
+  const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+  return join(base, "codesesh", "logs");
+}
+function toLogValue(value, depth = 0) {
+  if (value == null || typeof value === "string" || typeof value === "number") return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+  }
+  if (depth >= 4) return "[truncated]";
+  if (Array.isArray(value)) return value.slice(0, 50).map((item) => toLogValue(item, depth + 1));
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        toLogValue(item, depth + 1)
+      ])
+    );
+  }
+  return String(value);
+}
+function timestampForFile(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+var AppLogger = class {
+  logDir;
+  level;
+  maxBytes;
+  maxFiles;
+  currentPath;
+  rotationIndex = 0;
+  constructor(options = {}) {
+    this.logDir = options.logDir ?? process.env.CODESESH_LOG_DIR ?? getDefaultLogDir();
+    this.level = options.level ?? parseLevel(process.env.CODESESH_LOG_LEVEL);
+    this.maxBytes = options.maxBytes ?? parsePositiveInt(process.env.CODESESH_LOG_MAX_BYTES, 5e6);
+    this.maxFiles = options.maxFiles ?? parsePositiveInt(process.env.CODESESH_LOG_MAX_FILES, 5);
+    this.currentPath = join(this.logDir, "codesesh.log");
+  }
+  getLogPath() {
+    return this.currentPath;
+  }
+  debug(event, data = {}) {
+    this.write("debug", event, data);
+  }
+  info(event, data = {}) {
+    this.write("info", event, data);
+  }
+  warn(event, data = {}) {
+    this.write("warn", event, data);
+  }
+  error(event, data = {}) {
+    this.write("error", event, data);
+  }
+  write(level, event, data) {
+    if (LEVEL_WEIGHT[level] < LEVEL_WEIGHT[this.level]) return;
+    try {
+      mkdirSync(this.logDir, { recursive: true });
+      const line = `${JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        event,
+        pid: process.pid,
+        ...toLogValue(data)
+      })}
+`;
+      this.rotateIfNeeded(Buffer.byteLength(line));
+      appendFileSync(this.currentPath, line, "utf8");
+    } catch {
+    }
+  }
+  rotateIfNeeded(nextBytes) {
+    if (!existsSync(this.currentPath)) {
+      this.removeExpiredLogs();
+      return;
+    }
+    const currentSize = statSync(this.currentPath).size;
+    if (currentSize + nextBytes <= this.maxBytes) return;
+    this.rotationIndex += 1;
+    const rotatedPath = join(
+      this.logDir,
+      `codesesh-${timestampForFile()}-${process.pid}-${this.rotationIndex}.log`
+    );
+    renameSync(this.currentPath, rotatedPath);
+    this.removeExpiredLogs();
+  }
+  removeExpiredLogs() {
+    const rotated = readdirSync(this.logDir).filter((name) => /^codesesh-.+\.log$/.test(name)).map((name) => {
+      const path = join(this.logDir, name);
+      return { path, mtimeMs: statSync(path).mtimeMs };
+    }).toSorted((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const item of rotated.slice(Math.max(0, this.maxFiles - 1))) {
+      unlinkSync(item.path);
+    }
+  }
+};
+var appLogger = new AppLogger();
+
 // src/api/handlers.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -78,6 +215,24 @@ function filterSessionsByActivityWindow(sessions, from, to) {
     return true;
   });
 }
+function matchesProjectScope(session, cwd) {
+  if (!session.directory) return false;
+  const identity = computeIdentity(cwd, realFs);
+  if (session.project_identity?.key === identity.key) return true;
+  return session.directory.toLowerCase().includes(cwd.toLowerCase());
+}
+function sanitizeClientLogData(value) {
+  if (!isRecord(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).slice(0, 30).map(([key, item]) => {
+      if (typeof item === "string") return [key, item.slice(0, 300)];
+      if (typeof item === "number" || typeof item === "boolean" || item == null) {
+        return [key, item];
+      }
+      return [key, String(item).slice(0, 300)];
+    })
+  );
+}
 function handleGetConfig(c, defaults) {
   return c.json({
     window: {
@@ -99,11 +254,22 @@ function handleGetAgents(c, scanSource, defaults = {}) {
   const info = getAgentInfoMap(counts);
   return c.json(info);
 }
+function handleGetProjects(c, scanSource, defaults = {}) {
+  const scanResult = scanSource.getSnapshot();
+  const { from, to } = defaults;
+  return c.json({
+    projects: listCachedProjectGroups(
+      filterSessionsByActivityWindow(scanResult.sessions, from, to)
+    )
+  });
+}
 function handleGetSessions(c, scanSource, defaults = {}) {
   const scanResult = scanSource.getSnapshot();
   const agent = c.req.query("agent");
   const q = c.req.query("q")?.toLowerCase();
-  const cwd = c.req.query("cwd")?.toLowerCase();
+  const cwd = c.req.query("cwd");
+  const projectKey = c.req.query("projectKey");
+  const tag = c.req.query("tag")?.toLowerCase();
   const from = parseDateParam(c.req.query("from"), defaults.from);
   const to = parseDateParam(c.req.query("to"), defaults.to);
   let sessions = [];
@@ -112,10 +278,15 @@ function handleGetSessions(c, scanSource, defaults = {}) {
   } else {
     sessions = [...scanResult.sessions];
   }
-  if (cwd) {
-    sessions = sessions.filter((s) => s.directory.toLowerCase().includes(cwd));
+  if (projectKey) {
+    sessions = sessions.filter((s) => s.project_identity?.key === projectKey);
+  } else if (cwd) {
+    sessions = sessions.filter((s) => matchesProjectScope(s, cwd));
   }
   sessions = filterSessionsByActivityWindow(sessions, from, to);
+  if (tag) {
+    sessions = sessions.filter((s) => s.smart_tags?.includes(tag));
+  }
   if (q) {
     sessions = sessions.filter((s) => s.title.toLowerCase().includes(q));
   }
@@ -149,6 +320,7 @@ function handleSearchSessions(c, scanSource, defaults = {}) {
   return c.json({ results });
 }
 async function handleGetSessionData(c, scanSource) {
+  const startedAt = performance.now();
   const scanResult = scanSource.getSnapshot();
   const agentName = c.req.param("agent");
   const sessionId = c.req.param("id");
@@ -160,22 +332,71 @@ async function handleGetSessionData(c, scanSource) {
     return c.json({ error: `Unknown agent: ${agentName}` }, 404);
   }
   try {
+    const loadStartedAt = performance.now();
     const data = agent.getSessionData(sessionId);
-    return c.json(data);
+    const loadDuration = performance.now() - loadStartedAt;
+    const tagStartedAt = performance.now();
+    const smartTags = classifySessionTags(data);
+    const tagDuration = performance.now() - tagStartedAt;
+    const head = scanResult.byAgent[agentName]?.find((item) => item.id === sessionId);
+    appLogger.info("api.session_data", {
+      agent: agentName,
+      session_id: sessionId,
+      messages: data.messages.length,
+      load_duration_ms: Math.round(loadDuration),
+      tag_duration_ms: Math.round(tagDuration),
+      duration_ms: Math.round(performance.now() - startedAt)
+    });
+    return c.json({
+      ...data,
+      project_identity: data.project_identity ?? head?.project_identity,
+      smart_tags: smartTags,
+      smart_tags_source_updated_at: getSmartTagSourceTimestamp(data)
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : "Failed to load session";
+    appLogger.error("api.session_data.error", {
+      agent: agentName,
+      session_id: sessionId,
+      duration_ms: Math.round(performance.now() - startedAt),
+      error: message
+    });
     return c.json({ error: message }, 500);
   }
 }
+async function handlePostClientLog(c) {
+  const payload = await c.req.json().catch(() => null);
+  const rawEvent = payload?.event;
+  if (typeof rawEvent !== "string" || !rawEvent.trim()) {
+    return c.json({ ok: false }, 400);
+  }
+  const event = rawEvent.trim().replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 120);
+  appLogger.info(`client.${event}`, sanitizeClientLogData(payload?.data));
+  return c.json({ ok: true });
+}
 function handleGetBookmarks(c) {
-  return c.json({ bookmarks: listBookmarks() });
+  try {
+    return c.json({ bookmarks: listBookmarks(), storageAvailable: true });
+  } catch (error) {
+    if (error instanceof BookmarkStorageUnavailableError) {
+      return c.json({ bookmarks: [], storageAvailable: false });
+    }
+    throw error;
+  }
 }
 async function handlePutBookmark(c) {
   const payload = parseBookmarkPayload(await c.req.json().catch(() => null));
   if (!payload) {
     return c.json({ error: "Invalid bookmark payload" }, 400);
   }
-  return c.json({ bookmark: upsertBookmark(payload) });
+  try {
+    return c.json({ bookmark: upsertBookmark(payload), storageAvailable: true });
+  } catch (error) {
+    if (error instanceof BookmarkStorageUnavailableError) {
+      return c.json({ error: "Bookmark storage is unavailable" }, 503);
+    }
+    throw error;
+  }
 }
 async function handleImportBookmarks(c) {
   const payload = await c.req.json().catch(() => null);
@@ -186,7 +407,14 @@ async function handleImportBookmarks(c) {
   if (bookmarks.length !== payload.length) {
     return c.json({ error: "Invalid bookmark payload" }, 400);
   }
-  return c.json({ bookmarks: importBookmarks(bookmarks) });
+  try {
+    return c.json({ bookmarks: importBookmarks(bookmarks), storageAvailable: true });
+  } catch (error) {
+    if (error instanceof BookmarkStorageUnavailableError) {
+      return c.json({ error: "Bookmark storage is unavailable" }, 503);
+    }
+    throw error;
+  }
 }
 function handleDeleteBookmark(c) {
   const agentKey = c.req.param("agent");
@@ -194,8 +422,15 @@ function handleDeleteBookmark(c) {
   if (!agentKey || !sessionId) {
     return c.json({ error: "Missing bookmark identifier" }, 400);
   }
-  deleteBookmark(agentKey, sessionId);
-  return c.json({ ok: true });
+  try {
+    deleteBookmark(agentKey, sessionId);
+    return c.json({ ok: true, storageAvailable: true });
+  } catch (error) {
+    if (error instanceof BookmarkStorageUnavailableError) {
+      return c.json({ error: "Bookmark storage is unavailable" }, 503);
+    }
+    throw error;
+  }
 }
 function toLocalDateKey(ts) {
   const d = new Date(ts);
@@ -211,23 +446,22 @@ function startOfLocalDay(ts) {
 }
 function resolveDashboardWindow(defaults, queryDays, queryFrom, queryTo) {
   const now = Date.now();
-  const todayStart = startOfLocalDay(now);
-  const toTs = parseDateParam(queryTo, defaults.to) ?? todayStart + 24 * 60 * 60 * 1e3 - 1;
+  const toTs = parseDateParam(queryTo, defaults.to) ?? now;
   const parsedDays = queryDays ? parseInt(queryDays, 10) : NaN;
   let days = Number.isFinite(parsedDays) && parsedDays > 0 ? parsedDays : defaults.days;
   const fromFromQuery = parseDateParam(queryFrom, void 0);
   let fromTs;
   if (fromFromQuery != null) {
-    fromTs = startOfLocalDay(fromFromQuery);
-    days ??= Math.max(1, Math.ceil((todayStart - fromTs) / 864e5) + 1);
-  } else if (days && days > 0) {
-    fromTs = todayStart - (days - 1) * 864e5;
+    fromTs = fromFromQuery;
+    days ??= Math.max(1, Math.ceil((toTs - fromTs) / 864e5));
   } else if (defaults.from != null) {
-    fromTs = startOfLocalDay(defaults.from);
-    days = Math.max(1, Math.ceil((todayStart - fromTs) / 864e5) + 1);
+    fromTs = defaults.from;
+    days ??= Math.max(1, Math.ceil((toTs - fromTs) / 864e5));
+  } else if (days && days > 0) {
+    fromTs = startOfLocalDay(toTs) - (days - 1) * 864e5;
   } else {
     days = 30;
-    fromTs = todayStart - (days - 1) * 864e5;
+    fromTs = startOfLocalDay(toTs) - (days - 1) * 864e5;
   }
   return { from: fromTs, to: toTs, days };
 }
@@ -252,11 +486,13 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
   let totalMessages = 0;
   let totalTokens = 0;
   let totalCost = 0;
+  let hasEstimatedCost = false;
   let latestActivity = 0;
   for (const session of windowed) {
     totalMessages += session.stats.message_count;
     totalTokens += getTotalTokens(session.stats);
     totalCost += session.stats.total_cost ?? 0;
+    if (session.stats.cost_source === "estimated") hasEstimatedCost = true;
     const activity = getSessionActivityTime(session);
     if (activity > latestActivity) latestActivity = activity;
   }
@@ -281,7 +517,8 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
   const dailyMap = /* @__PURE__ */ new Map();
   const dailyTokenMap = /* @__PURE__ */ new Map();
   const bucketStart = startOfLocalDay(from);
-  for (let i = 0; i < days; i += 1) {
+  const bucketDays = Math.floor((startOfLocalDay(to) - bucketStart) / 864e5) + 1;
+  for (let i = 0; i < bucketDays; i += 1) {
     const ts = bucketStart + i * 864e5;
     const key = toLocalDateKey(ts);
     dailyMap.set(key, { date: key, sessions: 0, messages: 0 });
@@ -330,6 +567,7 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
       messages: totalMessages,
       tokens: totalTokens,
       cost: totalCost,
+      cost_source: totalCost > 0 ? hasEstimatedCost ? "estimated" : "recorded" : void 0,
       latestActivity: latestActivity || void 0
     },
     perAgent,
@@ -391,6 +629,7 @@ function createApiRoutes(scanSource, store, options = {}) {
   };
   api.get("/config", (c) => handleGetConfig(c, listDefaults));
   api.get("/agents", (c) => handleGetAgents(c, scanSource, listDefaults));
+  api.get("/projects", (c) => handleGetProjects(c, scanSource, listDefaults));
   api.get("/sessions", (c) => handleGetSessions(c, scanSource, listDefaults));
   api.get("/search", (c) => handleSearchSessions(c, scanSource, listDefaults));
   api.get("/sessions/:agent/:id", (c) => handleGetSessionData(c, scanSource));
@@ -399,6 +638,7 @@ function createApiRoutes(scanSource, store, options = {}) {
   api.put("/bookmarks", (c) => handlePutBookmark(c));
   api.post("/bookmarks/import", (c) => handleImportBookmarks(c));
   api.delete("/bookmarks/:agent/:id", (c) => handleDeleteBookmark(c));
+  api.post("/logs", (c) => handlePostClientLog(c));
   if (store) {
     api.get("/events", (c) => createSseResponse(store, c.req.raw.signal));
   }
@@ -409,11 +649,11 @@ function createApiRoutes(scanSource, store, options = {}) {
 function findWebDistPath() {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
   const packagedPath = resolve(__dirname2, "web");
-  if (existsSync(packagedPath)) {
+  if (existsSync2(packagedPath)) {
     return packagedPath;
   }
   const devPath = resolve(__dirname2, "../../../apps/web/dist");
-  if (existsSync(devPath)) {
+  if (existsSync2(devPath)) {
     return devPath;
   }
   return null;
@@ -440,7 +680,26 @@ function getServerStartupErrorMessage(error, port) {
 }
 async function createServer(port, store, options = {}) {
   const app = new Hono2();
-  app.use("*", logger());
+  app.use("*", async (c, next) => {
+    const startedAt = performance.now();
+    let thrown;
+    try {
+      await next();
+    } catch (error) {
+      thrown = error;
+      throw error;
+    } finally {
+      const url2 = new URL(c.req.url);
+      appLogger.info("http.request", {
+        method: c.req.method,
+        path: url2.pathname,
+        query_keys: [...url2.searchParams.keys()].toSorted(),
+        status: c.res.status,
+        duration_ms: Math.round(performance.now() - startedAt),
+        error: thrown instanceof Error ? thrown.message : void 0
+      });
+    }
+  });
   const routeOptions = {
     defaultSessionFrom: options.defaultSessionFrom,
     defaultSessionTo: options.defaultSessionTo,
@@ -463,6 +722,7 @@ async function createServer(port, store, options = {}) {
   try {
     await waitForListening(server);
   } catch (error) {
+    appLogger.error("server.listen.error", { port, error });
     server.close();
     if (store.shutdown) {
       await store.shutdown();
@@ -470,9 +730,11 @@ async function createServer(port, store, options = {}) {
     throw new Error(getServerStartupErrorMessage(error, port));
   }
   const url = `http://localhost:${port}`;
+  appLogger.info("server.listen", { port, url });
   return {
     url,
     shutdown: () => {
+      appLogger.info("server.shutdown", { port });
       server.close();
       if (store.shutdown) {
         void store.shutdown();
@@ -482,8 +744,8 @@ async function createServer(port, store, options = {}) {
 }
 
 // src/live-scan.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname2, isAbsolute, join } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, isAbsolute, join as join2 } from "path";
 import chokidar from "chokidar";
 function sortSessions(sessions) {
   return [...sessions].sort(
@@ -547,11 +809,11 @@ function buildUpdateEvent(agentName, previousSessions, nextSessions) {
   };
 }
 function closestWatchablePath(targetPath) {
-  if (!isAbsolute(targetPath) && !existsSync2(targetPath)) {
+  if (!isAbsolute(targetPath) && !existsSync3(targetPath)) {
     return null;
   }
   let current = targetPath;
-  while (!existsSync2(current)) {
+  while (!existsSync3(current)) {
     const parent = dirname2(current);
     if (parent === current) {
       return null;
@@ -566,24 +828,24 @@ function resolveAgentWatchTargets(agentName) {
   switch (agentName) {
     case "claudecode":
       return [
-        { path: join(roots.claudeRoot, "projects"), depth: 2 },
+        { path: join2(roots.claudeRoot, "projects"), depth: 2 },
         { path: "data/claudecode", depth: 2 }
       ];
     case "codex":
-      return [{ path: join(roots.codexRoot, "sessions"), depth: 4 }];
+      return [{ path: join2(roots.codexRoot, "sessions"), depth: 4 }];
     case "cursor":
       return cursorDataPath ? [
-        { path: join(cursorDataPath, "globalStorage", "state.vscdb") },
-        { path: join(cursorDataPath, "workspaceStorage"), depth: 2 }
+        { path: join2(cursorDataPath, "globalStorage", "state.vscdb") },
+        { path: join2(cursorDataPath, "workspaceStorage"), depth: 2 }
       ] : [];
     case "kimi":
       return [
-        { path: join(roots.kimiRoot, "sessions"), depth: 2 },
+        { path: join2(roots.kimiRoot, "sessions"), depth: 2 },
         { path: "data/kimi", depth: 2 }
       ];
     case "opencode":
       return [
-        { path: join(roots.opencodeRoot, "opencode.db") },
+        { path: join2(roots.opencodeRoot, "opencode.db") },
         { path: "data/opencode/opencode.db" }
       ];
     default:
@@ -591,12 +853,14 @@ function resolveAgentWatchTargets(agentName) {
   }
 }
 var LiveScanStore = class {
-  constructor(watchEnabled = true, scanOptions = {}) {
+  constructor(watchEnabled = true, scanOptions = {}, startupScanOptions = {}) {
     this.watchEnabled = watchEnabled;
     this.scanOptions = scanOptions;
+    this.startupScanOptions = startupScanOptions;
   }
   watchEnabled;
   scanOptions;
+  startupScanOptions;
   agents = [];
   byAgent = {};
   sessions = [];
@@ -607,33 +871,30 @@ var LiveScanStore = class {
   pendingRefreshes = /* @__PURE__ */ new Set();
   watchers = [];
   async initialize() {
+    const startedAt = performance.now();
+    appLogger.info("scan.initial.start", {
+      watch_enabled: this.watchEnabled,
+      agents: this.scanOptions.agents,
+      use_cache: this.scanOptions.useCache ?? true,
+      startup_from: this.startupScanOptions.from,
+      startup_to: this.startupScanOptions.to
+    });
     const initialResult = await scanSessions({
       ...this.scanOptions,
-      useCache: true,
-      smartRefresh: false
+      ...this.startupScanOptions,
+      useCache: this.scanOptions.useCache ?? true,
+      smartRefresh: false,
+      writeCache: this.startupScanOptions.from != null || this.startupScanOptions.to != null ? false : void 0,
+      includeSmartTags: this.startupScanOptions.from != null || this.startupScanOptions.to != null ? false : void 0
     });
-    const knownAgents = createRegisteredAgents();
-    const agentMap = /* @__PURE__ */ new Map();
-    const allowedAgents = this.getAllowedAgents();
-    for (const agent of initialResult.agents) {
-      agentMap.set(agent.name, agent);
-    }
-    for (const agent of knownAgents) {
-      if (!agentMap.has(agent.name)) {
-        agentMap.set(agent.name, agent);
-      }
-    }
-    this.agents = [...agentMap.values()].filter((agent) => {
-      if (!allowedAgents) {
-        return true;
-      }
-      return allowedAgents.has(agent.name.toLowerCase());
+    this.applyScanResult(initialResult);
+    appLogger.info("scan.initial.done", {
+      duration_ms: Math.round(performance.now() - startedAt),
+      sessions: this.sessions.length,
+      agents: Object.fromEntries(
+        Object.entries(this.byAgent).map(([key, value]) => [key, value.length])
+      )
     });
-    for (const agent of this.agents) {
-      this.byAgent[agent.name] = sortSessions(initialResult.byAgent[agent.name] ?? []);
-      this.refreshTimestamps.set(agent.name, Date.now());
-    }
-    this.rebuildSessions();
     if (this.watchEnabled) {
       this.startWatching();
     }
@@ -667,6 +928,34 @@ var LiveScanStore = class {
   rebuildSessions() {
     this.sessions = sortSessions(Object.values(this.byAgent).flat());
   }
+  hasStartupWindow() {
+    return this.startupScanOptions.from != null || this.startupScanOptions.to != null;
+  }
+  applyScanResult(result) {
+    const knownAgents = createRegisteredAgents();
+    const agentMap = /* @__PURE__ */ new Map();
+    const allowedAgents = this.getAllowedAgents();
+    for (const agent of result.agents) {
+      agentMap.set(agent.name, agent);
+    }
+    for (const agent of knownAgents) {
+      if (!agentMap.has(agent.name)) {
+        agentMap.set(agent.name, agent);
+      }
+    }
+    this.agents = [...agentMap.values()].filter((agent) => {
+      if (!allowedAgents) {
+        return true;
+      }
+      return allowedAgents.has(agent.name.toLowerCase());
+    });
+    this.byAgent = {};
+    for (const agent of this.agents) {
+      this.byAgent[agent.name] = sortSessions(result.byAgent[agent.name] ?? []);
+      this.refreshTimestamps.set(agent.name, Date.now());
+    }
+    this.rebuildSessions();
+  }
   getAllowedAgents() {
     if (!this.scanOptions.agents?.length) {
       return null;
@@ -674,7 +963,7 @@ var LiveScanStore = class {
     return new Set(this.scanOptions.agents.map((agent) => agent.toLowerCase()));
   }
   applyFilters(sessions) {
-    return filterSessions(sessions, this.scanOptions);
+    return filterSessions(sessions, { ...this.scanOptions, ...this.startupScanOptions });
   }
   startWatching() {
     for (const agent of this.agents) {
@@ -686,8 +975,16 @@ var LiveScanStore = class {
         (target, index, items) => items.findIndex((item) => item.path === target.path && item.depth === target.depth) === index
       );
       if (watchTargets.length === 0) {
+        appLogger.debug("watch.skip", { agent: agent.name });
         continue;
       }
+      appLogger.info("watch.start", {
+        agent: agent.name,
+        targets: watchTargets.map((target) => ({
+          path: target.path,
+          depth: target.depth ?? 0
+        }))
+      });
       const watcher = chokidar.watch(
         watchTargets.map((target) => target.path),
         {
@@ -706,12 +1003,14 @@ var LiveScanStore = class {
         this.scheduleRefresh(agent.name);
       });
       watcher.on("error", (error) => {
+        appLogger.error("watch.error", { agent: agent.name, error });
         console.error(`[${agent.name}] File watcher failed:`, error);
       });
       this.watchers.push(watcher);
     }
   }
   scheduleRefresh(agentName, delayMs = 200) {
+    appLogger.debug("scan.refresh.schedule", { agent: agentName, delay_ms: delayMs });
     const existing = this.refreshTimers.get(agentName);
     if (existing) {
       clearTimeout(existing);
@@ -724,6 +1023,7 @@ var LiveScanStore = class {
   }
   async refreshAgent(agentName) {
     if (this.refreshInFlight.has(agentName)) {
+      appLogger.debug("scan.refresh.pending", { agent: agentName });
       this.pendingRefreshes.add(agentName);
       return;
     }
@@ -738,8 +1038,10 @@ var LiveScanStore = class {
     }
   }
   async runRefresh(agentName) {
+    const startedAt = performance.now();
     const agent = this.agents.find((item) => item.name === agentName);
     if (!agent) {
+      appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
       return;
     }
     const previousSessions = this.byAgent[agentName] ?? [];
@@ -753,17 +1055,23 @@ var LiveScanStore = class {
       );
       this.refreshTimestamps.set(agentName, checkResult.timestamp);
       if (!checkResult.hasChanges) {
+        appLogger.debug("scan.refresh.unchanged", {
+          agent: agentName,
+          duration_ms: Math.round(performance.now() - startedAt)
+        });
         return;
       }
       nextSessions = await Promise.resolve(
         agent.incrementalScan(previousSessions, checkResult.changedIds ?? [])
       );
     } else {
-      nextSessions = await Promise.resolve(agent.scan());
+      nextSessions = await Promise.resolve(agent.scan(this.startupScanOptions));
       this.refreshTimestamps.set(agentName, Date.now());
     }
     nextSessions = this.applyFilters(nextSessions);
-    saveCachedSessions(agentName, nextSessions, buildAgentCacheMeta(agent));
+    if (!this.hasStartupWindow()) {
+      saveCachedSessions(agentName, nextSessions, buildAgentCacheMeta(agent));
+    }
     syncSessionSearchIndex(agentName, nextSessions, (sessionId) => agent.getSessionData(sessionId));
     const event = buildUpdateEvent(agentName, previousSessions, nextSessions);
     this.byAgent[agentName] = sortSessions(nextSessions);
@@ -772,6 +1080,14 @@ var LiveScanStore = class {
       event.totalSessions = this.sessions.length;
       this.emit(event);
     }
+    appLogger.info("scan.refresh.done", {
+      agent: agentName,
+      duration_ms: Math.round(performance.now() - startedAt),
+      sessions: nextSessions.length,
+      new_sessions: event?.newSessions ?? 0,
+      updated_sessions: event?.updatedSessions ?? 0,
+      removed_sessions: event?.removedSessions ?? 0
+    });
   }
 };
 
@@ -907,6 +1223,7 @@ var main = defineCommand({
     }
   },
   async run({ args }) {
+    const startedAt = performance.now();
     const port = parseInt(args.port, 10) || 4321;
     const noOpen = args.noOpen;
     const jsonOnly = args.json;
@@ -916,11 +1233,22 @@ var main = defineCommand({
     if (trace) {
       perf.enable();
     }
+    appLogger.info("cli.start", {
+      version: VERSION,
+      argv: process.argv.slice(2),
+      port,
+      json: jsonOnly,
+      no_open: noOpen,
+      cache: useCache,
+      log_path: appLogger.getLogPath()
+    });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-2YXXOCZJ.js");
+      const { clearCache: clear } = await import("./dist-DMEDEJ2D.js");
       clear();
+      appLogger.info("cache.clear");
       console.log("Cache cleared.");
     }
+    void refreshPricingCache();
     let targetSession = null;
     if (args.session) {
       targetSession = parseSessionUri(args.session);
@@ -950,9 +1278,19 @@ var main = defineCommand({
       cwd: cwdFilter,
       useCache
     };
-    const store = new LiveScanStore(!jsonOnly, scanOptions);
+    const startupScanOptions = targetSession || jsonOnly ? {} : { from: listDefaultFrom, to: listDefaultTo };
+    const store = new LiveScanStore(!jsonOnly, scanOptions, startupScanOptions);
     await store.initialize();
     const result = store.getSnapshot();
+    appLogger.info("cli.scan_ready", {
+      duration_ms: Math.round(performance.now() - startedAt),
+      sessions: result.sessions.length,
+      agents: Object.fromEntries(
+        Object.entries(result.byAgent).map(([key, value]) => [key, value.length])
+      ),
+      startup_from: startupScanOptions.from,
+      startup_to: startupScanOptions.to
+    });
     if (trace) {
       console.log(perf.getReport());
     }
@@ -975,6 +1313,10 @@ var main = defineCommand({
         })),
         sessions: windowed
       };
+      appLogger.info("cli.json_output", {
+        sessions: windowed.length,
+        duration_ms: Math.round(performance.now() - startedAt)
+      });
       console.log(JSON.stringify(output, null, 2));
       return;
     }
@@ -993,9 +1335,15 @@ var main = defineCommand({
     }
     console.log(`  ${url}`);
     console.log("");
+    appLogger.info("cli.ready", {
+      url,
+      duration_ms: Math.round(performance.now() - startedAt),
+      log_path: appLogger.getLogPath()
+    });
     if (!noOpen) {
       const open = (await import("open")).default;
       const targetUrl = targetSession ? `${url}/${targetSession.agent.toLowerCase()}/${targetSession.sessionId}` : url;
+      appLogger.info("browser.open", { url: targetUrl });
       await open(targetUrl);
     }
   }