codesesh 0.5.0 → 0.6.0

package/dist/index.js

@@ -5,6 +5,7 @@ import {
   computeIdentity,
   createRegisteredAgents,
   deleteBookmark,
+  extractSessionFileActivity,
   filterSessions,
   getAgentInfoMap,
   getCursorDataPath,
@@ -12,16 +13,19 @@ import {
   importBookmarks,
   listBookmarks,
   listCachedProjectGroups,
+  listFileActivity,
+  parseSearchQuery,
   perf,
   realFs,
   refreshPricingCache,
   resolveProviderRoots,
   saveCachedSessions,
   scanSessions,
+  searchFileActivitySessions,
   searchSessions,
   syncSessionSearchIndex,
   upsertBookmark
-} from "./chunk-FZNZAMTZ.js";
+} from "./chunk-SQYHWMQV.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -167,6 +171,24 @@ var AppLogger = class {
   }
 };
 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) {
@@ -195,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;
 }
@@ -203,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);
 }
@@ -233,6 +308,148 @@ function sanitizeClientLogData(value) {
     })
   );
 }
+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: {
@@ -257,10 +474,9 @@ function handleGetAgents(c, scanSource, defaults = {}) {
 function handleGetProjects(c, scanSource, defaults = {}) {
   const scanResult = scanSource.getSnapshot();
   const { from, to } = defaults;
+  const sessions = filterSessionsByActivityWindow(scanResult.sessions, from, to);
   return c.json({
-    projects: listCachedProjectGroups(
-      filterSessionsByActivityWindow(scanResult.sessions, from, to)
-    )
+    projects: attachProjectMetrics(listCachedProjectGroups(sessions), sessions)
   });
 }
 function handleGetSessions(c, scanSource, defaults = {}) {
@@ -294,31 +510,60 @@ 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();
@@ -339,6 +584,7 @@ async function handleGetSessionData(c, scanSource) {
     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,
@@ -349,9 +595,15 @@ async function handleGetSessionData(c, scanSource) {
     });
     return c.json({
       ...data,
-      project_identity: data.project_identity ?? head?.project_identity,
+      project_identity: projectIdentity,
       smart_tags: smartTags,
-      smart_tags_source_updated_at: getSmartTagSourceTimestamp(data)
+      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";
@@ -473,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
       ])
@@ -496,7 +757,7 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
     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;
@@ -558,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 = {
@@ -575,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);
@@ -632,6 +900,7 @@ function createApiRoutes(scanSource, store, options = {}) {
   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));
@@ -659,10 +928,10 @@ function findWebDistPath() {
   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);
@@ -744,9 +1013,17 @@ async function createServer(port, store, options = {}) {
 }
 
 // src/live-scan.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname2, isAbsolute, join as join2 } 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)
@@ -808,11 +1085,14 @@ function buildUpdateEvent(agentName, previousSessions, nextSessions) {
     timestamp: Date.now()
   };
 }
+function toAbsolutePath(path) {
+  return isAbsolute(path) ? path : resolve2(path);
+}
 function closestWatchablePath(targetPath) {
   if (!isAbsolute(targetPath) && !existsSync3(targetPath)) {
     return null;
   }
-  let current = targetPath;
+  let current = toAbsolutePath(targetPath);
   while (!existsSync3(current)) {
     const parent = dirname2(current);
     if (parent === current) {
@@ -822,31 +1102,85 @@ 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: join2(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: join2(roots.codexRoot, "sessions"), depth: 4 }];
+      return [{ root: roots.codexRoot, path: join2(roots.codexRoot, "sessions") }];
     case "cursor":
       return cursorDataPath ? [
-        { path: join2(cursorDataPath, "globalStorage", "state.vscdb") },
-        { path: join2(cursorDataPath, "workspaceStorage"), depth: 2 }
+        {
+          root: cursorDataPath,
+          path: join2(cursorDataPath, "globalStorage", "state.vscdb")
+        },
+        { root: cursorDataPath, path: join2(cursorDataPath, "workspaceStorage") }
       ] : [];
     case "kimi":
       return [
-        { path: join2(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: join2(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 [];
@@ -869,7 +1203,14 @@ 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", {
@@ -897,6 +1238,10 @@ var LiveScanStore = class {
     });
     if (this.watchEnabled) {
       this.startWatching();
+      this.initialSearchIndexTimer = setTimeout(() => {
+        this.initialSearchIndexTimer = null;
+        this.startSearchIndexWorker("scan.initial.background");
+      }, 1e3);
     }
   }
   getSnapshot() {
@@ -917,20 +1262,108 @@ 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();
@@ -966,50 +1399,195 @@ var LiveScanStore = class {
     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;
       }
+      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;
+        }
+        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", {
-        agent: agent.name,
-        targets: watchTargets.map((target) => ({
-          path: target.path,
-          depth: target.depth ?? 0
+        root: rootPath,
+        agents,
+        targets: scopes.map((scope) => ({
+          agent: scope.agentName,
+          path: scope.targetPath
         }))
       });
-      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
-          )
+      if (isRecursiveWatchSupported()) {
+        const started = this.watchDirectory(rootPath, scopes, true);
+        if (started) {
+          continue;
         }
-      );
-      watcher.on("all", () => {
-        this.scheduleRefresh(agent.name);
+      }
+      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) => {
-        appLogger.error("watch.error", { agent: agent.name, 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) {
@@ -1030,15 +1608,20 @@ var LiveScanStore = class {
     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 });
@@ -1072,7 +1655,18 @@ var LiveScanStore = class {
     if (!this.hasStartupWindow()) {
       saveCachedSessions(agentName, nextSessions, buildAgentCacheMeta(agent));
     }
-    syncSessionSearchIndex(agentName, nextSessions, (sessionId) => agent.getSessionData(sessionId));
+    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();
@@ -1086,7 +1680,10 @@ var LiveScanStore = class {
       sessions: nextSessions.length,
       new_sessions: event?.newSessions ?? 0,
       updated_sessions: event?.updatedSessions ?? 0,
-      removed_sessions: event?.removedSessions ?? 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)
     });
   }
 };
@@ -1096,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
@@ -1243,7 +1840,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-DMEDEJ2D.js");
+      const { clearCache: clear } = await import("./dist-NT4CH6KD.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");