codesesh 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,21 +1,31 @@
 #!/usr/bin/env node
 import {
   BookmarkStorageUnavailableError,
+  classifySessionTags,
+  computeIdentity,
   createRegisteredAgents,
   deleteBookmark,
+  extractSessionFileActivity,
   filterSessions,
   getAgentInfoMap,
   getCursorDataPath,
+  getSmartTagSourceTimestamp,
   importBookmarks,
   listBookmarks,
+  listCachedProjectGroups,
+  listFileActivity,
+  parseSearchQuery,
   perf,
+  realFs,
+  refreshPricingCache,
   resolveProviderRoots,
   saveCachedSessions,
   scanSessions,
+  searchFileActivitySessions,
   searchSessions,
   syncSessionSearchIndex,
   upsertBookmark
-} from "./chunk-BGQXQTWM.js";
+} from "./chunk-SQYHWMQV.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -24,14 +34,162 @@ 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();
+function logSearchIndexSync(context, result, data = {}) {
+  if (!result || result.mode !== "bulk" || result.rebuildDurationMs == null) {
+    return;
+  }
+  appLogger.info("search_index.sync", {
+    context,
+    agent: result.agentName,
+    mode: result.mode,
+    sessions: result.sessions,
+    changed: result.changed,
+    deleted: result.deleted,
+    indexed: result.indexed,
+    skipped: result.skipped,
+    duration_ms: Math.round(result.durationMs),
+    rebuild_duration_ms: Math.round(result.rebuildDurationMs),
+    ...data
+  });
+}
+
 // src/api/handlers.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -59,6 +217,9 @@ function parseBookmarkPayload(value) {
 function getTotalTokens(stats) {
   return stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens;
 }
+function getSessionAgentName(session) {
+  return session.slug.split("/")[0]?.toLowerCase() || "unknown";
+}
 function getSessionActivityTime(session) {
   return session.time_updated ?? session.time_created;
 }
@@ -67,6 +228,56 @@ function parseDateParam(value, fallback) {
   const ts = new Date(value).getTime();
   return Number.isNaN(ts) ? fallback : ts;
 }
+function parseNumberParam(value) {
+  if (value == null || !value.trim()) return void 0;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : void 0;
+}
+function searchParams(c) {
+  return new URL(c.req.url ?? "http://localhost/", "http://localhost/").searchParams;
+}
+function queryValues(params, ...names) {
+  return names.flatMap(
+    (name) => params.getAll(name).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean)
+  );
+}
+function parseSmartTags(values) {
+  const tags = values.map((value) => value.toLowerCase()).filter(
+    (value) => [
+      "bugfix",
+      "refactoring",
+      "feature-dev",
+      "testing",
+      "docs",
+      "git-ops",
+      "build-deploy",
+      "exploration",
+      "planning"
+    ].includes(value)
+  );
+  return tags.length > 0 ? [...new Set(tags)] : void 0;
+}
+function parseSearchOptions(c, defaults) {
+  const params = searchParams(c);
+  const limitValue = parseNumberParam(params.get("limit") ?? void 0);
+  return {
+    agent: optionalQueryValue(params.get("agent") ?? void 0),
+    project: optionalQueryValue(params.get("project") ?? void 0),
+    projectKey: optionalQueryValue(params.get("projectKey") ?? void 0),
+    cwd: optionalQueryValue(params.get("cwd") ?? void 0),
+    tags: parseSmartTags(queryValues(params, "tag", "tags", "signal")),
+    tools: queryValues(params, "tool", "tools").map((tool) => tool.toLowerCase()),
+    file: optionalQueryValue(params.get("file") ?? params.get("path") ?? void 0),
+    fileKind: parseFileActivityKind(
+      optionalQueryValue(params.get("fileKind") ?? params.get("fileActivity") ?? void 0)
+    ),
+    costMin: parseNumberParam(params.get("costMin") ?? void 0),
+    costMax: parseNumberParam(params.get("costMax") ?? void 0),
+    from: parseDateParam(params.get("from") ?? void 0, defaults.from),
+    to: parseDateParam(params.get("to") ?? void 0, defaults.to),
+    limit: limitValue && limitValue > 0 ? Math.min(limitValue, 100) : 50
+  };
+}
 function filterSessionsByWindow(sessions, from, to) {
   return filterSessionsByActivityWindow(sessions, from, to);
 }
@@ -79,6 +290,166 @@ 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 sessionMatchesCostFilter(session, options) {
+  const cost = session.stats.total_cost;
+  if (options.costMin != null) {
+    if (options.costMinExclusive ? cost <= options.costMin : cost < options.costMin) return false;
+  }
+  if (options.costMax != null) {
+    if (options.costMaxExclusive ? cost >= options.costMax : cost > options.costMax) return false;
+  }
+  return true;
+}
+function mergeSearchLists(left, right) {
+  const values = [...left ?? [], ...right ?? []];
+  return values.length > 0 ? [...new Set(values)] : void 0;
+}
+function mergeSearchOptions(options, filters) {
+  return {
+    ...options,
+    agent: options.agent ?? filters.agent,
+    project: options.project ?? filters.project,
+    projectKey: options.projectKey ?? filters.projectKey,
+    cwd: options.cwd ?? filters.cwd,
+    tags: mergeSearchLists(options.tags, filters.tags),
+    tools: mergeSearchLists(options.tools, filters.tools),
+    file: options.file ?? filters.file,
+    fileKind: options.fileKind ?? filters.fileKind,
+    costMin: options.costMin ?? filters.costMin,
+    costMax: options.costMax ?? filters.costMax,
+    costMinExclusive: options.costMinExclusive ?? filters.costMinExclusive,
+    costMaxExclusive: options.costMaxExclusive ?? filters.costMaxExclusive
+  };
+}
+function mergeSearchResults(results, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const result of results) {
+    const key = `${result.agentName}/${result.session.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(result);
+    if (merged.length >= limit) break;
+  }
+  return merged;
+}
+function getProjectGroupKey(identityKind, identityKey) {
+  return `${identityKind}:${identityKey}`;
+}
+function attachProjectMetrics(projects, sessions) {
+  const metrics = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const identity = session.project_identity;
+    if (!identity) continue;
+    const key = getProjectGroupKey(identity.kind, identity.key);
+    let current = metrics.get(key);
+    if (!current) {
+      current = {
+        messages: 0,
+        tokens: 0,
+        cost: 0,
+        hasEstimatedCost: false,
+        agentStats: /* @__PURE__ */ new Map()
+      };
+      metrics.set(key, current);
+    }
+    const tokens = getTotalTokens(session.stats);
+    const cost = session.stats.total_cost ?? 0;
+    current.messages += session.stats.message_count;
+    current.tokens += tokens;
+    current.cost += cost;
+    if (session.stats.cost_source === "estimated") current.hasEstimatedCost = true;
+    const agentName = getSessionAgentName(session);
+    const agent = current.agentStats.get(agentName);
+    if (agent) {
+      agent.sessions += 1;
+      agent.messages += session.stats.message_count;
+      agent.tokens += tokens;
+      agent.cost += cost;
+    } else {
+      current.agentStats.set(agentName, {
+        name: agentName,
+        sessions: 1,
+        messages: session.stats.message_count,
+        tokens,
+        cost
+      });
+    }
+  }
+  return projects.map((project) => {
+    const metric = metrics.get(getProjectGroupKey(project.identityKind, project.identityKey));
+    return {
+      ...project,
+      messages: metric?.messages ?? 0,
+      tokens: metric?.tokens ?? 0,
+      cost: metric?.cost ?? 0,
+      cost_source: metric && metric.cost > 0 ? metric.hasEstimatedCost ? "estimated" : "recorded" : void 0,
+      agentStats: [...metric?.agentStats.values() ?? []].sort((a, b) => b.sessions - a.sessions)
+    };
+  });
+}
+function matchesDashboardScope(session, scope) {
+  if (scope.agent && getSessionAgentName(session) !== scope.agent) return false;
+  if (scope.projectKey) {
+    const identity = session.project_identity;
+    if (!identity || identity.key !== scope.projectKey) return false;
+    if (scope.projectKind && identity.kind !== scope.projectKind) return false;
+  }
+  return true;
+}
+function filterSessionsByDashboardScope(sessions, scope) {
+  if (!scope.agent && !scope.projectKey) return sessions;
+  return sessions.filter((session) => matchesDashboardScope(session, scope));
+}
+function matchesRecentSearchFilters(session, options) {
+  if (options.projectKey && session.project_identity?.key !== options.projectKey) return false;
+  if (options.cwd && !matchesProjectScope(session, options.cwd)) return false;
+  if (options.project) {
+    const projectNeedle = options.project.toLowerCase();
+    const projectText = [
+      session.project_identity?.key,
+      session.project_identity?.displayName,
+      session.directory
+    ].filter(Boolean).join("\n").toLowerCase();
+    if (!projectText.includes(projectNeedle)) return false;
+  }
+  if (options.tags?.length && !options.tags.every((tag) => session.smart_tags?.includes(tag))) {
+    return false;
+  }
+  if (!sessionMatchesCostFilter(session, options)) return false;
+  return true;
+}
+function recentSearchSessions(scanResult, options) {
+  const entries = options.agent ? [[options.agent, scanResult.byAgent[options.agent] ?? []]] : Object.entries(scanResult.byAgent);
+  return entries.flatMap(
+    ([agentName, sessions]) => filterSessionsByActivityWindow(sessions, options.from, options.to).filter((session) => matchesRecentSearchFilters(session, options)).map((session) => ({ agentName, session }))
+  ).toSorted(
+    (a, b) => (b.session.time_updated ?? b.session.time_created) - (a.session.time_updated ?? a.session.time_created)
+  ).slice(0, options.limit).map(({ agentName, session }) => ({
+    agentName,
+    session,
+    snippet: `Recent session \xB7 ${session.directory}`,
+    matchType: "recent"
+  }));
+}
 function handleGetConfig(c, defaults) {
   return c.json({
     window: {
@@ -100,11 +471,21 @@ 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;
+  const sessions = filterSessionsByActivityWindow(scanResult.sessions, from, to);
+  return c.json({
+    projects: attachProjectMetrics(listCachedProjectGroups(sessions), sessions)
+  });
+}
 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 = [];
@@ -113,10 +494,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));
   }
@@ -124,32 +510,62 @@ function handleGetSessions(c, scanSource, defaults = {}) {
 }
 function handleSearchSessions(c, scanSource, defaults = {}) {
   const query = c.req.query("q")?.trim() ?? "";
-  if (!query) {
-    return c.json({ results: [] });
-  }
   const scanResult = scanSource.getSnapshot();
-  const agent = c.req.query("agent");
-  const cwd = c.req.query("cwd");
-  const from = parseDateParam(c.req.query("from"), defaults.from);
-  const to = parseDateParam(c.req.query("to"), defaults.to);
-  for (const indexedAgent of scanResult.agents) {
-    const sessions = scanResult.byAgent[indexedAgent.name] ?? [];
-    syncSessionSearchIndex(
-      indexedAgent.name,
-      sessions,
-      (sessionId) => indexedAgent.getSessionData(sessionId)
-    );
+  const searchOptions = parseSearchOptions(c, defaults);
+  const parsedQuery = parseSearchQuery(query);
+  const mergedSearchOptions = mergeSearchOptions(searchOptions, parsedQuery.filters);
+  const textQuery = parsedQuery.text || (parsedQuery.hasQualifiers ? "" : query);
+  const needsIndexedSearch = Boolean(
+    textQuery || mergedSearchOptions.file || mergedSearchOptions.fileKind || mergedSearchOptions.tools?.length
+  );
+  if (!needsIndexedSearch) {
+    return c.json({
+      results: recentSearchSessions(
+        scanResult,
+        mergedSearchOptions
+      )
+    });
   }
-  const results = searchSessions(query, {
-    agent,
-    cwd,
-    from,
-    to,
-    limit: 50
-  });
+  const fileQuery = mergedSearchOptions.file ?? (!parsedQuery.text ? parsedQuery.filters.file : void 0) ?? (!parsedQuery.hasQualifiers && query ? parsedQuery.text || query : "");
+  const results = mergeSearchResults(
+    [
+      ...fileQuery ? searchFileActivitySessions(fileQuery, mergedSearchOptions) : [],
+      ...searchSessions(query, mergedSearchOptions)
+    ],
+    mergedSearchOptions.limit ?? 50
+  );
   return c.json({ results });
 }
+function parseFileActivityKind(value) {
+  if (value === "read" || value === "edit" || value === "write" || value === "delete") {
+    return value;
+  }
+  return void 0;
+}
+function optionalQueryValue(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function handleGetFileActivity(c, defaults = {}) {
+  const limitValue = Number(c.req.query("limit"));
+  const limit = Number.isFinite(limitValue) && limitValue > 0 ? Math.min(limitValue, 200) : 50;
+  return c.json({
+    activity: listFileActivity({
+      agent: optionalQueryValue(c.req.query("agent")),
+      sessionId: optionalQueryValue(c.req.query("sessionId")),
+      projectKey: optionalQueryValue(c.req.query("projectKey")),
+      project: optionalQueryValue(c.req.query("project")),
+      cwd: optionalQueryValue(c.req.query("cwd")),
+      path: optionalQueryValue(c.req.query("path")),
+      kind: parseFileActivityKind(optionalQueryValue(c.req.query("kind"))),
+      from: parseDateParam(c.req.query("from"), defaults.from),
+      to: parseDateParam(c.req.query("to"), defaults.to),
+      limit
+    })
+  });
+}
 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");
@@ -161,13 +577,55 @@ 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);
+    const projectIdentity = data.project_identity ?? head?.project_identity ?? computeIdentity(data.directory, realFs);
+    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: projectIdentity,
+      smart_tags: smartTags,
+      smart_tags_source_updated_at: getSmartTagSourceTimestamp(data),
+      file_activity: extractSessionFileActivity(
+        agentName,
+        sessionId,
+        projectIdentity.key,
+        data.messages
+      )
+    });
   } 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) {
   try {
     return c.json({ bookmarks: listBookmarks(), storageAvailable: true });
@@ -240,23 +698,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 };
 }
@@ -268,10 +725,19 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
     c.req.query("from"),
     c.req.query("to")
   );
-  const windowed = filterSessionsByActivityWindow(scanResult.sessions, from, to);
+  const scope = {
+    agent: optionalQueryValue(c.req.query("agent"))?.toLowerCase(),
+    projectKind: optionalQueryValue(c.req.query("projectKind")),
+    projectKey: optionalQueryValue(c.req.query("projectKey"))
+  };
+  const scopedSessions = filterSessionsByDashboardScope(scanResult.sessions, scope);
+  const windowed = filterSessionsByActivityWindow(scopedSessions, from, to);
+  const scopedByAgent = Object.fromEntries(
+    Object.entries(scanResult.byAgent).filter(([name]) => !scope.agent || name.toLowerCase() === scope.agent).map(([name, sessions]) => [name, filterSessionsByDashboardScope(sessions, scope)])
+  );
   const agentInfo = getAgentInfoMap(
     Object.fromEntries(
-      Object.entries(scanResult.byAgent).map(([name, sessions]) => [
+      Object.entries(scopedByAgent).map(([name, sessions]) => [
         name,
         filterSessionsByActivityWindow(sessions, from, to).length
       ])
@@ -281,15 +747,17 @@ 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;
   }
-  const perAgent = Object.entries(scanResult.byAgent).map(([name, sessions]) => {
+  const perAgent = Object.entries(scopedByAgent).map(([name, sessions]) => {
     const info = agentInfoMap.get(name);
     const agentWindowed = filterSessionsByActivityWindow(sessions, from, to);
     let messages = 0;
@@ -310,7 +778,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 });
@@ -350,7 +819,7 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
   const dailyTokenActivity = [...dailyTokenMap.values()];
   const modelDistribution = [...modelAgg.entries()].map(([model, { tokens, sessions: count }]) => ({ model, tokens, sessions: count })).sort((a, b) => b.tokens - a.tokens);
   const recentSessions = [...windowed].sort((a, b) => getSessionActivityTime(b) - getSessionActivityTime(a)).slice(0, 10).map((session) => {
-    const agentKey = session.slug.split("/")[0] ?? "unknown";
+    const agentKey = getSessionAgentName(session);
     return { ...session, agentName: agentKey };
   });
   const data = {
@@ -359,6 +828,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,
@@ -366,6 +836,13 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
     dailyTokenActivity,
     modelDistribution,
     recentSessions,
+    recentFileActivities: listFileActivity({
+      agent: scope.agent,
+      projectKey: scope.projectKey,
+      from,
+      to,
+      limit: 12
+    }),
     window: { from, to, days }
   };
   return c.json(data);
@@ -420,14 +897,17 @@ 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("/file-activity", (c) => handleGetFileActivity(c, listDefaults));
   api.get("/sessions/:agent/:id", (c) => handleGetSessionData(c, scanSource));
   api.get("/dashboard", (c) => handleGetDashboard(c, scanSource, listDefaults));
   api.get("/bookmarks", (c) => handleGetBookmarks(c));
   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));
   }
@@ -438,20 +918,20 @@ 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;
 }
 function waitForListening(server) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const handleListening = () => {
       server.off("error", handleError);
-      resolve3();
+      resolve4();
     };
     const handleError = (error) => {
       server.off("listening", handleListening);
@@ -469,7 +949,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,
@@ -492,6 +991,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();
@@ -499,9 +999,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();
@@ -511,9 +1013,17 @@ 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 chokidar from "chokidar";
+import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2, watch } from "fs";
+import { dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Worker } from "worker_threads";
+var REFRESH_DEBOUNCE_MS = 200;
+var EMPTY_AGENT_REFRESH_DEBOUNCE_MS = 3e4;
+var PENDING_REFRESH_DELAY_MS = 100;
+var WRITE_STABILITY_THRESHOLD_MS = 250;
+var WRITE_STABILITY_POLL_MS = 100;
+var NEW_SESSION_EVENT_WINDOW_MS = 250;
+var SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD = 100;
 function sortSessions(sessions) {
   return [...sessions].sort(
     (a, b) => (b.time_updated ?? b.time_created) - (a.time_updated ?? a.time_created)
@@ -575,12 +1085,15 @@ function buildUpdateEvent(agentName, previousSessions, nextSessions) {
     timestamp: Date.now()
   };
 }
+function toAbsolutePath(path) {
+  return isAbsolute(path) ? path : resolve2(path);
+}
 function closestWatchablePath(targetPath) {
-  if (!isAbsolute(targetPath) && !existsSync2(targetPath)) {
+  if (!isAbsolute(targetPath) && !existsSync3(targetPath)) {
     return null;
   }
-  let current = targetPath;
-  while (!existsSync2(current)) {
+  let current = toAbsolutePath(targetPath);
+  while (!existsSync3(current)) {
     const parent = dirname2(current);
     if (parent === current) {
       return null;
@@ -589,43 +1102,99 @@ function closestWatchablePath(targetPath) {
   }
   return current;
 }
+function getWatchRoot(path) {
+  const stat = statSync2(path);
+  return stat.isDirectory() ? path : dirname2(path);
+}
+function isRecursiveWatchSupported(platform = process.platform, nodeVersion = process.versions.node) {
+  if (platform === "darwin" || platform === "win32") {
+    return true;
+  }
+  if (platform !== "linux" && platform !== "aix" && platform !== "ibmi") {
+    return false;
+  }
+  const [major = 0, minor = 0] = nodeVersion.split(".").map((part) => Number(part));
+  return major > 19 || major === 19 && minor >= 1;
+}
+function isRecursiveWatchUnavailable(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+}
+function isSameOrChildPath(parentPath, childPath) {
+  const path = relative(parentPath, childPath);
+  return path === "" || !path.startsWith("..") && !isAbsolute(path);
+}
+function isRelatedPath(changedPath, targetPath) {
+  return isSameOrChildPath(targetPath, changedPath) || isSameOrChildPath(changedPath, targetPath);
+}
+function mergeEvents(previous, next) {
+  return {
+    type: "sessions-updated",
+    changedAgents: Array.from(/* @__PURE__ */ new Set([...previous.changedAgents, ...next.changedAgents])),
+    newSessions: previous.newSessions + next.newSessions,
+    updatedSessions: previous.updatedSessions + next.updatedSessions,
+    removedSessions: previous.removedSessions + next.removedSessions,
+    totalSessions: next.totalSessions,
+    timestamp: next.timestamp
+  };
+}
+function mergeScopes(target, scopes) {
+  for (const scope of scopes) {
+    if (!target.some(
+      (item) => item.agentName === scope.agentName && item.targetPath === scope.targetPath
+    )) {
+      target.push(scope);
+    }
+  }
+}
+function resolveWatchEventPath(watchPath, filename) {
+  const filenameText = filename?.toString();
+  if (!filenameText) {
+    return watchPath;
+  }
+  return isAbsolute(filenameText) ? filenameText : join2(watchPath, filenameText);
+}
 function resolveAgentWatchTargets(agentName) {
   const roots = resolveProviderRoots();
   const cursorDataPath = getCursorDataPath();
   switch (agentName) {
     case "claudecode":
       return [
-        { path: join(roots.claudeRoot, "projects"), depth: 2 },
-        { path: "data/claudecode", depth: 2 }
+        { root: roots.claudeRoot, path: join2(roots.claudeRoot, "projects") },
+        { path: "data/claudecode" }
       ];
     case "codex":
-      return [{ path: join(roots.codexRoot, "sessions"), depth: 4 }];
+      return [{ root: roots.codexRoot, path: join2(roots.codexRoot, "sessions") }];
     case "cursor":
       return cursorDataPath ? [
-        { path: join(cursorDataPath, "globalStorage", "state.vscdb") },
-        { path: join(cursorDataPath, "workspaceStorage"), depth: 2 }
+        {
+          root: cursorDataPath,
+          path: join2(cursorDataPath, "globalStorage", "state.vscdb")
+        },
+        { root: cursorDataPath, path: join2(cursorDataPath, "workspaceStorage") }
       ] : [];
     case "kimi":
       return [
-        { path: join(roots.kimiRoot, "sessions"), depth: 2 },
-        { path: "data/kimi", depth: 2 }
+        { root: roots.kimiRoot, path: join2(roots.kimiRoot, "sessions") },
+        { path: "data/kimi" }
       ];
     case "opencode":
       return [
-        { path: join(roots.opencodeRoot, "opencode.db") },
-        { path: "data/opencode/opencode.db" }
+        { root: roots.opencodeRoot, path: join2(roots.opencodeRoot, "opencode.db") },
+        { root: "data/opencode", path: "data/opencode/opencode.db" }
       ];
     default:
       return [];
   }
 }
 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 = [];
@@ -634,37 +1203,45 @@ var LiveScanStore = class {
   refreshTimestamps = /* @__PURE__ */ new Map();
   refreshInFlight = /* @__PURE__ */ new Set();
   pendingRefreshes = /* @__PURE__ */ new Set();
+  pendingRefreshPathCounts = /* @__PURE__ */ new Map();
   watchers = [];
+  fallbackWatchScopes = /* @__PURE__ */ new Map();
+  stablePaths = /* @__PURE__ */ new Map();
+  pendingEvent = null;
+  pendingEventTimer = null;
+  initialSearchIndexTimer = null;
+  searchIndexWorker = null;
   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();
+      this.initialSearchIndexTimer = setTimeout(() => {
+        this.initialSearchIndexTimer = null;
+        this.startSearchIndexWorker("scan.initial.background");
+      }, 1e3);
     }
   }
   getSnapshot() {
@@ -685,17 +1262,133 @@ var LiveScanStore = class {
       clearTimeout(timer);
     }
     this.refreshTimers.clear();
+    this.pendingRefreshPathCounts.clear();
+    for (const state of this.stablePaths.values()) {
+      if (state.timer) {
+        clearTimeout(state.timer);
+      }
+    }
+    this.stablePaths.clear();
+    if (this.pendingEventTimer) {
+      clearTimeout(this.pendingEventTimer);
+      this.pendingEventTimer = null;
+    }
+    if (this.initialSearchIndexTimer) {
+      clearTimeout(this.initialSearchIndexTimer);
+      this.initialSearchIndexTimer = null;
+    }
+    if (this.searchIndexWorker) {
+      await this.searchIndexWorker.terminate();
+      this.searchIndexWorker = null;
+    }
+    this.pendingEvent = null;
     await Promise.all(this.watchers.map((watcher) => watcher.close()));
     this.watchers = [];
+    this.fallbackWatchScopes.clear();
   }
   emit(event) {
+    if (this.pendingEvent || event.newSessions > 0) {
+      this.queueEvent(event);
+      return;
+    }
+    this.emitNow(event);
+  }
+  emitNow(event) {
     for (const listener of this.listeners) {
       listener(event);
     }
   }
+  queueEvent(event) {
+    this.pendingEvent = this.pendingEvent ? mergeEvents(this.pendingEvent, event) : event;
+    if (this.pendingEventTimer) {
+      return;
+    }
+    this.pendingEventTimer = setTimeout(() => {
+      const pending = this.pendingEvent;
+      this.pendingEvent = null;
+      this.pendingEventTimer = null;
+      if (pending) {
+        this.emitNow(pending);
+      }
+    }, NEW_SESSION_EVENT_WINDOW_MS);
+  }
   rebuildSessions() {
     this.sessions = sortSessions(Object.values(this.byAgent).flat());
   }
+  hasStartupWindow() {
+    return this.startupScanOptions.from != null || this.startupScanOptions.to != null;
+  }
+  getSearchIndexWorkerUrl() {
+    const workerUrl = new URL("./search-index-worker.js", import.meta.url);
+    if (workerUrl.protocol === "file:" && !existsSync3(fileURLToPath2(workerUrl))) {
+      return null;
+    }
+    return workerUrl;
+  }
+  startSearchIndexWorker(context) {
+    if (this.searchIndexWorker) return;
+    const workerUrl = this.getSearchIndexWorkerUrl();
+    if (!workerUrl) {
+      appLogger.warn("search_index.worker_missing", { context });
+      return;
+    }
+    const worker = new Worker(workerUrl, {
+      workerData: {
+        context,
+        agentNames: this.agents.map((agent) => agent.name),
+        sessionsByAgent: this.byAgent,
+        metaByAgent: Object.fromEntries(
+          this.agents.map((agent) => [agent.name, buildAgentCacheMeta(agent)])
+        )
+      }
+    });
+    worker.unref();
+    this.searchIndexWorker = worker;
+    worker.on("message", (message) => {
+      if (message.type === "sync-result") {
+        logSearchIndexSync(message.context, message.result);
+      } else if (message.type === "done") {
+        appLogger.info(`${message.context}.done`, {
+          duration_ms: Math.round(message.durationMs),
+          sessions: message.sessions
+        });
+      }
+    });
+    worker.on("error", (error) => {
+      appLogger.error("search_index.worker_error", { context, error });
+    });
+    worker.on("exit", (code) => {
+      this.searchIndexWorker = null;
+      if (code !== 0) {
+        appLogger.warn("search_index.worker_exit", { context, code });
+      }
+    });
+  }
+  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;
@@ -703,44 +1396,199 @@ 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() {
+    const scopesByRoot = /* @__PURE__ */ new Map();
     for (const agent of this.agents) {
-      const rawTargets = resolveAgentWatchTargets(agent.name);
-      const watchTargets = rawTargets.map((target) => {
-        const watchPath = closestWatchablePath(target.path);
-        return watchPath ? { ...target, path: watchPath } : null;
-      }).filter((target) => target !== null).filter(
-        (target, index, items) => items.findIndex((item) => item.path === target.path && item.depth === target.depth) === index
-      );
+      const watchTargets = resolveAgentWatchTargets(agent.name);
       if (watchTargets.length === 0) {
+        appLogger.debug("watch.skip", { agent: agent.name });
         continue;
       }
-      const watcher = chokidar.watch(
-        watchTargets.map((target) => target.path),
-        {
-          ignoreInitial: true,
-          awaitWriteFinish: {
-            stabilityThreshold: 250,
-            pollInterval: 100
-          },
-          depth: watchTargets.reduce(
-            (maxDepth, target) => Math.max(maxDepth, target.depth ?? 0),
-            0
-          )
+      for (const target of watchTargets) {
+        const watchRootPath = closestWatchablePath(target.root ?? target.path);
+        if (!watchRootPath) continue;
+        let rootPath;
+        try {
+          rootPath = getWatchRoot(watchRootPath);
+        } catch (error) {
+          this.reportWatchError("watch.resolve.error", { path: watchRootPath, error });
+          continue;
         }
-      );
-      watcher.on("all", () => {
-        this.scheduleRefresh(agent.name);
+        const targetPath = toAbsolutePath(target.path);
+        const scopes = scopesByRoot.get(rootPath) ?? [];
+        if (!scopes.some((scope) => scope.agentName === agent.name && scope.targetPath === targetPath)) {
+          scopes.push({ agentName: agent.name, targetPath });
+        }
+        scopesByRoot.set(rootPath, scopes);
+      }
+    }
+    for (const [rootPath, scopes] of scopesByRoot.entries()) {
+      const agents = Array.from(new Set(scopes.map((scope) => scope.agentName)));
+      appLogger.info("watch.start", {
+        root: rootPath,
+        agents,
+        targets: scopes.map((scope) => ({
+          agent: scope.agentName,
+          path: scope.targetPath
+        }))
+      });
+      if (isRecursiveWatchSupported()) {
+        const started = this.watchDirectory(rootPath, scopes, true);
+        if (started) {
+          continue;
+        }
+      }
+      this.watchDirectoryTree(rootPath, scopes);
+    }
+  }
+  watchDirectory(path, scopes, recursive) {
+    try {
+      const watcher = watch(path, { recursive }, (eventType, filename) => {
+        queueMicrotask(() => {
+          try {
+            const activeScopes = recursive ? scopes : this.fallbackWatchScopes.get(path) ?? scopes;
+            this.handleWatchEvent(path, activeScopes, eventType, filename);
+            if (!recursive) {
+              this.watchNewDirectories(path, filename, activeScopes);
+            }
+          } catch (error) {
+            this.reportWatchError("watch.event.error", { path, recursive, error });
+          }
+        });
       });
       watcher.on("error", (error) => {
-        console.error(`[${agent.name}] File watcher failed:`, error);
+        this.reportWatchError("watch.error", { path, recursive, error });
       });
       this.watchers.push(watcher);
+      return true;
+    } catch (error) {
+      if (recursive && isRecursiveWatchUnavailable(error)) {
+        appLogger.warn("watch.recursive_unavailable", { path, error });
+        return false;
+      }
+      this.reportWatchError("watch.start.error", { path, recursive, error });
+      return false;
     }
   }
-  scheduleRefresh(agentName, delayMs = 200) {
+  watchDirectoryTree(rootPath, scopes) {
+    const pending = [rootPath];
+    while (pending.length > 0) {
+      const dirPath = pending.pop();
+      this.watchFallbackDirectory(dirPath, scopes);
+      try {
+        for (const entry of readdirSync2(dirPath, { withFileTypes: true })) {
+          if (entry.isDirectory()) {
+            pending.push(join2(dirPath, entry.name));
+          }
+        }
+      } catch (error) {
+        this.reportWatchError("watch.scan.error", { path: dirPath, error });
+      }
+    }
+  }
+  watchFallbackDirectory(path, scopes) {
+    const existingScopes = this.fallbackWatchScopes.get(path);
+    if (existingScopes) {
+      mergeScopes(existingScopes, scopes);
+      return;
+    }
+    const storedScopes = [...scopes];
+    this.fallbackWatchScopes.set(path, storedScopes);
+    if (!this.watchDirectory(path, storedScopes, false)) {
+      this.fallbackWatchScopes.delete(path);
+    }
+  }
+  watchNewDirectories(watchPath, filename, scopes) {
+    const path = resolveWatchEventPath(watchPath, filename);
+    try {
+      if (statSync2(path).isDirectory()) {
+        this.watchDirectoryTree(path, scopes);
+      }
+    } catch {
+    }
+  }
+  handleWatchEvent(watchPath, scopes, eventType, filename) {
+    const changedPath = resolveWatchEventPath(watchPath, filename);
+    const agentNames = new Set(
+      scopes.filter((scope) => isRelatedPath(changedPath, scope.targetPath)).map((scope) => scope.agentName)
+    );
+    if (agentNames.size === 0) {
+      return;
+    }
+    appLogger.debug("watch.event", {
+      event: eventType,
+      path: changedPath,
+      agents: Array.from(agentNames)
+    });
+    this.waitForStablePath(changedPath, agentNames);
+  }
+  waitForStablePath(path, agentNames) {
+    const existing = this.stablePaths.get(path);
+    if (existing) {
+      for (const agentName of agentNames) {
+        existing.agentNames.add(agentName);
+      }
+      return;
+    }
+    const state = {
+      path,
+      agentNames: new Set(agentNames),
+      lastMtimeMs: null,
+      lastSize: null,
+      stableSince: Date.now(),
+      timer: null
+    };
+    this.stablePaths.set(path, state);
+    this.pollStablePath(path);
+  }
+  pollStablePath(path) {
+    const state = this.stablePaths.get(path);
+    if (!state) {
+      return;
+    }
+    let size;
+    let mtimeMs;
+    try {
+      const stat = statSync2(path);
+      size = stat.size;
+      mtimeMs = stat.mtimeMs;
+    } catch {
+      this.stablePaths.delete(path);
+      this.scheduleRefreshForAgents(state.agentNames);
+      return;
+    }
+    const now = Date.now();
+    const unchanged = state.lastSize === size && state.lastMtimeMs === mtimeMs;
+    if (!unchanged) {
+      state.lastSize = size;
+      state.lastMtimeMs = mtimeMs;
+      state.stableSince = now;
+    }
+    if (unchanged && now - state.stableSince >= WRITE_STABILITY_THRESHOLD_MS) {
+      this.stablePaths.delete(path);
+      this.scheduleRefreshForAgents(state.agentNames);
+      return;
+    }
+    state.timer = setTimeout(() => this.pollStablePath(path), WRITE_STABILITY_POLL_MS);
+  }
+  scheduleRefreshForAgents(agentNames) {
+    for (const agentName of agentNames) {
+      this.pendingRefreshPathCounts.set(
+        agentName,
+        (this.pendingRefreshPathCounts.get(agentName) ?? 0) + 1
+      );
+      const delayMs = (this.byAgent[agentName]?.length ?? 0) === 0 ? EMPTY_AGENT_REFRESH_DEBOUNCE_MS : REFRESH_DEBOUNCE_MS;
+      this.scheduleRefresh(agentName, delayMs);
+    }
+  }
+  reportWatchError(event, data) {
+    appLogger.error(event, data);
+    console.error("[watch] File watcher failed:", data.error);
+  }
+  scheduleRefresh(agentName, delayMs = REFRESH_DEBOUNCE_MS) {
+    appLogger.debug("scan.refresh.schedule", { agent: agentName, delay_ms: delayMs });
     const existing = this.refreshTimers.get(agentName);
     if (existing) {
       clearTimeout(existing);
@@ -753,22 +1601,30 @@ var LiveScanStore = class {
   }
   async refreshAgent(agentName) {
     if (this.refreshInFlight.has(agentName)) {
+      appLogger.debug("scan.refresh.pending", { agent: agentName });
       this.pendingRefreshes.add(agentName);
       return;
     }
     this.refreshInFlight.add(agentName);
     try {
       await this.runRefresh(agentName);
+    } catch (error) {
+      appLogger.error("scan.refresh.error", { agent: agentName, error });
+      console.error(`[${agentName}] Session refresh failed:`, error);
     } finally {
       this.refreshInFlight.delete(agentName);
       if (this.pendingRefreshes.delete(agentName)) {
-        this.scheduleRefresh(agentName, 100);
+        this.scheduleRefresh(agentName, PENDING_REFRESH_DELAY_MS);
       }
     }
   }
   async runRefresh(agentName) {
+    const startedAt = performance.now();
+    const pendingPathCount = this.pendingRefreshPathCounts.get(agentName) ?? 0;
+    this.pendingRefreshPathCounts.delete(agentName);
     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] ?? [];
@@ -782,18 +1638,35 @@ 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));
-    syncSessionSearchIndex(agentName, nextSessions, (sessionId) => agent.getSessionData(sessionId));
+    if (!this.hasStartupWindow()) {
+      saveCachedSessions(agentName, nextSessions, buildAgentCacheMeta(agent));
+    }
+    const searchIndexOptions = pendingPathCount >= SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD ? { isBulk: true } : void 0;
+    const syncResult = searchIndexOptions ? syncSessionSearchIndex(
+      agentName,
+      nextSessions,
+      (sessionId) => agent.getSessionData(sessionId),
+      searchIndexOptions
+    ) : syncSessionSearchIndex(
+      agentName,
+      nextSessions,
+      (sessionId) => agent.getSessionData(sessionId)
+    );
+    logSearchIndexSync("scan.refresh", syncResult, { pending_paths: pendingPathCount });
     const event = buildUpdateEvent(agentName, previousSessions, nextSessions);
     this.byAgent[agentName] = sortSessions(nextSessions);
     this.rebuildSessions();
@@ -801,6 +1674,17 @@ 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,
+      pending_paths: pendingPathCount,
+      search_index_mode: syncResult?.mode,
+      search_index_rebuild_duration_ms: syncResult?.rebuildDurationMs == null ? void 0 : Math.round(syncResult.rebuildDurationMs)
+    });
   }
 };
 
@@ -809,10 +1693,10 @@ import { consola } from "consola";
 
 // src/version.ts
 import { readFileSync } from "fs";
-import { resolve as resolve2, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname = dirname3(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync(resolve2(__dirname, "../package.json"), "utf-8"));
+import { resolve as resolve3, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname = dirname3(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(readFileSync(resolve3(__dirname, "../package.json"), "utf-8"));
 var VERSION = pkg.version;
 
 // src/output.ts
@@ -936,6 +1820,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;
@@ -945,11 +1830,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-5NKHH33A.js");
+      const { clearCache: clear } = await import("./dist-NT4CH6KD.js");
       clear();
+      appLogger.info("cache.clear");
       console.log("Cache cleared.");
     }
+    void refreshPricingCache();
     let targetSession = null;
     if (args.session) {
       targetSession = parseSessionUri(args.session);
@@ -979,9 +1875,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());
     }
@@ -1004,6 +1910,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;
     }
@@ -1022,9 +1932,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);
     }
   }