codesesh 0.9.1 → 0.10.0

package/dist/index.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 import {
   BookmarkStorageUnavailableError,
+  FileSystemSessionSource,
+  attachMissingProjectIdentities,
+  buildAgentCacheMeta,
+  buildDashboard,
   classifySessionTags,
   computeIdentity,
+  computeSessionDiff,
   createProjectScopeMatcher,
   createRegisteredAgents,
   deleteBookmark,
@@ -10,7 +15,10 @@ import {
   filterSessions,
   getAgentInfoMap,
   getCursorDataPath,
+  getSessionActivityTime,
+  getSessionAgentName,
   getSmartTagSourceTimestamp,
+  getTotalTokens,
   importBookmarks,
   isAgentCacheInitialized,
   listBookmarks,
@@ -28,8 +36,11 @@ import {
   scanSessions,
   searchFileActivitySessions,
   searchSessions,
+  sessionSignature,
+  sortSessions,
+  startOfLocalDay,
   upsertBookmark
-} from "./chunk-5UOLRSFH.js";
+} from "./chunk-ZQMIB7QO.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -195,7 +206,6 @@ function logSearchIndexSync(context, result, data = {}) {
 }
 
 // src/api/handlers.ts
-var DASHBOARD_RECENT_LIMIT = 10;
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -219,15 +229,6 @@ function parseBookmarkPayload(value) {
     stats: value.stats
   };
 }
-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;
-}
 function parseDateParam(value, fallback) {
   if (value == null) return fallback;
   const ts = new Date(value).getTime();
@@ -682,18 +683,6 @@ function handleDeleteBookmark(c) {
     throw error;
   }
 }
-function toLocalDateKey(ts) {
-  const d = new Date(ts);
-  const year = d.getFullYear();
-  const month = `${d.getMonth() + 1}`.padStart(2, "0");
-  const day = `${d.getDate()}`.padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-function startOfLocalDay(ts) {
-  const d = new Date(ts);
-  d.setHours(0, 0, 0, 0);
-  return d.getTime();
-}
 function resolveDashboardWindow(defaults, queryDays, queryFrom, queryTo) {
   const now = Date.now();
   const toTs = parseDateParam(queryTo, defaults.to) ?? now;
@@ -732,138 +721,17 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
     projectKind: optionalQueryValue(c.req.query("projectKind")),
     projectKey: optionalQueryValue(c.req.query("projectKey"))
   };
-  const agentMetrics = /* @__PURE__ */ new Map();
-  const agentMetricKeyByName = /* @__PURE__ */ new Map();
-  for (const name of Object.keys(scanResult.byAgent)) {
-    if (scope.agent && name.toLowerCase() !== scope.agent) continue;
-    agentMetrics.set(name, { sessions: 0, messages: 0, tokens: 0 });
-    agentMetricKeyByName.set(name.toLowerCase(), name);
-  }
   const agentInfo = getAgentInfoMap({});
   const agentInfoMap = new Map(agentInfo.map((a) => [a.name, a]));
-  let totalSessions = 0;
-  let totalMessages = 0;
-  let totalTokens = 0;
-  let totalCost = 0;
-  let hasEstimatedCost = false;
-  let latestActivity = 0;
-  const recentCandidates = [];
-  const modelAgg = /* @__PURE__ */ new Map();
-  const dailyMap = /* @__PURE__ */ new Map();
-  const dailyTokenMap = /* @__PURE__ */ new Map();
-  if (from != null) {
-    const bucketStart = startOfLocalDay(from);
-    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 });
-      dailyTokenMap.set(key, { date: key, input: 0, output: 0, cache_read: 0, cache_create: 0 });
-    }
-  }
-  for (const session of scanResult.sessions) {
-    const agentName = getSessionAgentName(session);
-    if (scope.agent && agentName !== scope.agent) continue;
-    if (scope.projectKey) {
-      const identity = session.project_identity;
-      if (!identity || identity.key !== scope.projectKey) continue;
-      if (scope.projectKind && identity.kind !== scope.projectKind) continue;
-    }
-    const activity = getSessionActivityTime(session);
-    if (from != null && activity < from) continue;
-    if (activity > to) continue;
-    const messageCount = session.stats.message_count;
-    const sessionTokens = getTotalTokens(session.stats);
-    totalSessions += 1;
-    totalMessages += messageCount;
-    totalTokens += sessionTokens;
-    totalCost += session.stats.total_cost ?? 0;
-    if (session.stats.cost_source === "estimated") hasEstimatedCost = true;
-    if (activity > latestActivity) latestActivity = activity;
-    const metricKey = agentMetricKeyByName.get(agentName);
-    if (metricKey) {
-      const metric = agentMetrics.get(metricKey);
-      metric.sessions += 1;
-      metric.messages += messageCount;
-      metric.tokens += sessionTokens;
-    }
-    const key = toLocalDateKey(activity);
-    let bucket = dailyMap.get(key);
-    if (!bucket) {
-      bucket = { date: key, sessions: 0, messages: 0 };
-      dailyMap.set(key, bucket);
-    }
-    bucket.sessions += 1;
-    bucket.messages += messageCount;
-    let tokenBucket = dailyTokenMap.get(key);
-    if (!tokenBucket) {
-      tokenBucket = { date: key, input: 0, output: 0, cache_read: 0, cache_create: 0 };
-      dailyTokenMap.set(key, tokenBucket);
-    }
-    const cacheRead = session.stats.total_cache_read_tokens ?? 0;
-    const cacheCreate = session.stats.total_cache_create_tokens ?? 0;
-    const pureInput = session.stats.total_input_tokens - cacheRead - cacheCreate;
-    tokenBucket.input += Math.max(0, pureInput);
-    tokenBucket.output += session.stats.total_output_tokens;
-    tokenBucket.cache_read += cacheRead;
-    tokenBucket.cache_create += cacheCreate;
-    if (session.model_usage) {
-      for (const [model, tokens] of Object.entries(session.model_usage)) {
-        const entry = modelAgg.get(model);
-        if (entry) {
-          entry.tokens += tokens;
-          entry.sessions += 1;
-        } else {
-          modelAgg.set(model, { tokens, sessions: 1 });
-        }
-      }
-    }
-    let recentIndex = recentCandidates.length;
-    for (let i = 0; i < recentCandidates.length; i += 1) {
-      if (activity > recentCandidates[i].activity) {
-        recentIndex = i;
-        break;
-      }
-    }
-    if (recentIndex < DASHBOARD_RECENT_LIMIT) {
-      recentCandidates.splice(recentIndex, 0, { session, activity });
-      if (recentCandidates.length > DASHBOARD_RECENT_LIMIT) recentCandidates.pop();
-    }
-  }
-  const perAgent = [...agentMetrics.entries()].map(([name, metrics]) => {
-    const info = agentInfoMap.get(name);
-    return {
-      name,
-      displayName: info?.displayName ?? name,
-      icon: info?.icon ?? "",
-      sessions: metrics.sessions,
-      messages: metrics.messages,
-      tokens: metrics.tokens
-    };
-  }).filter((item) => item.sessions > 0).sort((a, b) => b.sessions - a.sessions);
-  const dailyActivity = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
-  const dailyTokenActivity = [...dailyTokenMap.values()].sort(
-    (a, b) => a.date.localeCompare(b.date)
-  );
-  const modelDistribution = [...modelAgg.entries()].map(([model, { tokens, sessions: count }]) => ({ model, tokens, sessions: count })).sort((a, b) => b.tokens - a.tokens);
-  const recentSessions = recentCandidates.map(({ session }) => {
-    const agentKey = getSessionAgentName(session);
-    return { ...session, agentName: agentKey };
+  const aggregate = buildDashboard(scanResult.sessions, {
+    byAgentNames: Object.keys(scanResult.byAgent),
+    scope,
+    from,
+    to,
+    agentInfoMap
   });
   const data = {
-    totals: {
-      sessions: totalSessions,
-      messages: totalMessages,
-      tokens: totalTokens,
-      cost: totalCost,
-      cost_source: totalCost > 0 ? hasEstimatedCost ? "estimated" : "recorded" : void 0,
-      latestActivity: latestActivity || void 0
-    },
-    perAgent,
-    dailyActivity,
-    dailyTokenActivity,
-    modelDistribution,
-    recentSessions,
+    ...aggregate,
     recentFileActivities: listFileActivity({
       agent: scope.agent,
       projectKey: scope.projectKey,
@@ -1078,112 +946,15 @@ async function createServer(port, store, options = {}) {
 }
 
 // src/live-scan.ts
-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 { existsSync as existsSync4 } from "fs";
 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;
+
+// src/session-watcher.ts
+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";
 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)
-  );
-}
-function sessionSignature(session) {
-  return JSON.stringify([
-    session.title,
-    session.directory,
-    session.time_created,
-    session.time_updated ?? session.time_created,
-    session.stats.message_count,
-    session.stats.total_input_tokens,
-    session.stats.total_output_tokens,
-    session.stats.total_cost,
-    session.stats.total_tokens ?? 0
-  ]);
-}
-function buildAgentCacheMeta(agent, sessionIds) {
-  const metaMap = agent.getSessionMetaMap?.();
-  const meta = {};
-  if (!metaMap) return meta;
-  for (const [id, data] of metaMap.entries()) {
-    if (sessionIds && !sessionIds.has(id)) continue;
-    meta[id] = { id, ...data };
-  }
-  return meta;
-}
-function attachMissingProjectIdentities(sessions) {
-  const identities = /* @__PURE__ */ new Map();
-  return sessions.map((session) => {
-    if (session.project_identity) return session;
-    const directory = session.directory || "";
-    let identity = identities.get(directory);
-    if (!identity) {
-      identity = computeIdentity(directory, realFs);
-      identities.set(directory, identity);
-    }
-    return { ...session, project_identity: identity };
-  });
-}
-function buildRefreshDiff(agentName, previousSessions, nextSessions, candidateChangedIds = []) {
-  const previousMap = new Map(previousSessions.map((session) => [session.id, session]));
-  const nextMap = new Map(nextSessions.map((session) => [session.id, session]));
-  const candidateChangedIdSet = new Set(candidateChangedIds);
-  const changedSessions = [];
-  const removedSessionIds = [];
-  let newSessions = 0;
-  let updatedSessions = 0;
-  let removedSessions = 0;
-  nextSessions.forEach((session, index) => {
-    const id = session.id;
-    const previous = previousMap.get(id);
-    if (!previous) {
-      newSessions += 1;
-      changedSessions.push({ session, sortIndex: index });
-      return;
-    }
-    const hasSignatureChange = sessionSignature(previous) !== sessionSignature(session);
-    const hasContentChange = candidateChangedIdSet.has(id);
-    if (hasSignatureChange || hasContentChange) {
-      updatedSessions += 1;
-    }
-    if (hasContentChange || hasSignatureChange) {
-      changedSessions.push({ session, sortIndex: index });
-    }
-  });
-  for (const id of previousMap.keys()) {
-    if (!nextMap.has(id)) {
-      removedSessions += 1;
-      removedSessionIds.push(id);
-    }
-  }
-  if (newSessions === 0 && updatedSessions === 0 && removedSessions === 0) {
-    return { event: null, changedSessions, removedSessionIds };
-  }
-  return {
-    changedSessions,
-    removedSessionIds,
-    event: {
-      type: "sessions-updated",
-      changedAgents: [agentName],
-      newSessions,
-      updatedSessions,
-      removedSessions,
-      totalSessions: nextSessions.length,
-      timestamp: Date.now(),
-      changedSessionHeads: changedSessions.map(({ session }) => ({ agentName, session })),
-      removedSessionRefs: removedSessionIds.map((sessionId) => ({ agentName, sessionId }))
-    }
-  };
-}
-function restoreAgentCacheMeta(agent, meta) {
-  agent.setSessionMetaMap?.(new Map(Object.entries(meta)));
-}
 function toAbsolutePath(path) {
   return isAbsolute(path) ? path : resolve2(path);
 }
@@ -1225,36 +996,6 @@ function isSameOrChildPath(parentPath, childPath) {
 function isRelatedPath(changedPath, targetPath) {
   return isSameOrChildPath(targetPath, changedPath) || isSameOrChildPath(changedPath, targetPath);
 }
-function mergeEvents(previous, next) {
-  const changedSessionHeads = /* @__PURE__ */ new Map();
-  const removedSessionRefs = /* @__PURE__ */ new Map();
-  const sessionKey = (agentName, sessionId) => `${agentName}\0${sessionId}`;
-  const addChanged = (item) => {
-    const key = sessionKey(item.agentName, item.session.id);
-    removedSessionRefs.delete(key);
-    changedSessionHeads.set(key, item);
-  };
-  const addRemoved = (item) => {
-    const key = sessionKey(item.agentName, item.sessionId);
-    changedSessionHeads.delete(key);
-    removedSessionRefs.set(key, item);
-  };
-  for (const item of previous.changedSessionHeads) addChanged(item);
-  for (const item of previous.removedSessionRefs) addRemoved(item);
-  for (const item of next.changedSessionHeads) addChanged(item);
-  for (const item of next.removedSessionRefs) addRemoved(item);
-  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,
-    changedSessionHeads: [...changedSessionHeads.values()],
-    removedSessionRefs: [...removedSessionRefs.values()]
-  };
-}
 function mergeScopes(target, scopes) {
   for (const scope of scopes) {
     if (!target.some(
@@ -1312,165 +1053,446 @@ function resolveAgentWatchTargets(agentName) {
       return [];
   }
 }
-var LiveScanStore = class {
-  constructor(watchEnabled = true, scanOptions = {}, startupScanOptions = {}, storeOptions = {}) {
-    this.watchEnabled = watchEnabled;
-    this.scanOptions = scanOptions;
-    this.startupScanOptions = startupScanOptions;
-    this.storeOptions = storeOptions;
-  }
-  watchEnabled;
-  scanOptions;
-  startupScanOptions;
-  storeOptions;
-  agents = [];
-  byAgent = {};
-  sessions = [];
-  listeners = /* @__PURE__ */ new Set();
-  scanStatusListeners = /* @__PURE__ */ new Set();
-  scanStatus = {
-    active: false,
-    phase: "idle",
-    pendingAgents: [],
-    scanningAgents: [],
-    completedAgents: [],
-    agentStatuses: {},
-    totalAgents: 0,
-    updatedAt: Date.now()
-  };
-  refreshTimers = /* @__PURE__ */ new Map();
-  refreshTimestamps = /* @__PURE__ */ new Map();
-  refreshInFlight = /* @__PURE__ */ new Set();
-  pendingRefreshes = /* @__PURE__ */ new Set();
-  pendingRefreshPathCounts = /* @__PURE__ */ new Map();
+var SessionWatcher = class {
   watchers = [];
   fallbackWatchScopes = /* @__PURE__ */ new Map();
   stablePaths = /* @__PURE__ */ new Map();
-  pendingEvent = null;
-  pendingEventTimer = null;
-  backgroundRefreshTimer = null;
-  searchIndexWorker = null;
-  pendingSearchIndexJobs = [];
-  shuttingDown = false;
-  async initialize() {
-    const startedAt = performance.now();
-    const deferInitialRefresh = this.storeOptions.deferInitialRefresh === true;
-    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,
-      deferred: deferInitialRefresh || void 0
-    });
-    const initialResult = await scanSessions({
-      ...this.scanOptions,
-      ...deferInitialRefresh ? this.startupScanOptions : {},
-      useCache: this.scanOptions.useCache ?? true,
-      smartRefresh: false,
-      cacheOnly: deferInitialRefresh,
-      writeCache: deferInitialRefresh ? false : this.scanOptions.writeCache,
-      smartTagWorkerUrl: this.getSmartTagWorkerUrl() ?? void 0,
-      includeSmartTags: deferInitialRefresh ? false : void 0
-    });
-    this.applyScanResult(initialResult);
-    const indexStartedAt = performance.now();
-    if (!deferInitialRefresh) {
-      await this.enqueueSearchIndexJobs(
-        "scan.initial",
-        this.buildFullSearchIndexJobs("scan.initial")
-      );
-    }
-    const indexDuration = performance.now() - indexStartedAt;
-    appLogger.info("scan.initial.done", {
-      duration_ms: Math.round(performance.now() - startedAt),
-      index_ms: deferInitialRefresh ? void 0 : Math.round(indexDuration),
-      deferred: deferInitialRefresh || void 0,
-      sessions: this.sessions.length,
-      agents: Object.fromEntries(
-        Object.entries(this.byAgent).map(([key, value]) => [key, value.length])
-      ),
-      agent_timings: initialResult.timings ? Object.fromEntries(
-        Object.entries(initialResult.timings).map(([name, t]) => [
-          name,
-          {
-            total_ms: Math.round(t.total),
-            cache_load_ms: t.cacheLoad != null ? Math.round(t.cacheLoad) : void 0,
-            check_changes_ms: t.checkChanges != null ? Math.round(t.checkChanges) : void 0,
-            scan_ms: t.scan != null ? Math.round(t.scan) : void 0,
-            identity_ms: t.identity != null ? Math.round(t.identity) : void 0,
-            tags_ms: t.tags != null ? Math.round(t.tags) : void 0
-          }
-        ])
-      ) : void 0
-    });
-    if (this.watchEnabled) {
-      this.startWatching();
-    }
-  }
-  startBackgroundRefresh() {
-    if (this.backgroundRefreshTimer) {
-      return;
-    }
-    const agentNames = this.agents.map((agent) => agent.name);
-    this.startScanBatch(agentNames, "scanning");
-    this.backgroundRefreshTimer = setTimeout(() => {
-      this.backgroundRefreshTimer = null;
-      for (const agentName of agentNames) {
-        this.scheduleRefresh(agentName, 0);
-      }
-      if (agentNames.length === 0) {
-        this.finishScanBatch();
-      }
-    }, 0);
-  }
-  getSnapshot() {
-    return {
-      sessions: this.sessions,
-      byAgent: this.byAgent,
-      agents: this.agents
-    };
-  }
-  getScanStatus() {
-    return {
-      type: "scan-status",
-      ...this.scanStatus,
-      pendingAgents: [...this.scanStatus.pendingAgents],
-      scanningAgents: [...this.scanStatus.scanningAgents],
-      completedAgents: [...this.scanStatus.completedAgents],
-      agentStatuses: Object.fromEntries(
-        Object.entries(this.scanStatus.agentStatuses).map(([agentName, status]) => [
-          agentName,
-          { ...status }
-        ])
-      )
-    };
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  subscribeScanStatus(listener) {
-    this.scanStatusListeners.add(listener);
+  listeners = /* @__PURE__ */ new Set();
+  /** Register a listener fired (after write-stability polling) with the changed agent set. */
+  onAgentsChanged(cb) {
+    this.listeners.add(cb);
     return () => {
-      this.scanStatusListeners.delete(listener);
+      this.listeners.delete(cb);
     };
   }
-  async shutdown() {
-    this.shuttingDown = true;
-    for (const timer of this.refreshTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.refreshTimers.clear();
-    this.pendingRefreshPathCounts.clear();
-    for (const state of this.stablePaths.values()) {
-      if (state.timer) {
-        clearTimeout(state.timer);
+  /** Begin watching the given agent names' data directories. */
+  start(agentNames) {
+    const scopesByRoot = /* @__PURE__ */ new Map();
+    for (const agentName of agentNames) {
+      const watchTargets = resolveAgentWatchTargets(agentName);
+      if (watchTargets.length === 0) {
+        appLogger.debug("watch.skip", { agent: agentName });
+        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 === agentName && scope.targetPath === targetPath)) {
+          scopes.push({ agentName, targetPath });
+        }
+        scopesByRoot.set(rootPath, scopes);
       }
     }
-    this.stablePaths.clear();
+    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);
+    }
+  }
+  /** Stop all watchers and clear pending stability polls. */
+  async dispose() {
+    for (const state of this.stablePaths.values()) {
+      if (state.timer) {
+        clearTimeout(state.timer);
+      }
+    }
+    this.stablePaths.clear();
+    await Promise.all(this.watchers.map((watcher) => watcher.close()));
+    this.watchers = [];
+    this.fallbackWatchScopes.clear();
+    this.listeners.clear();
+  }
+  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) => {
+        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;
+    }
+  }
+  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.emitAgentsChanged(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.emitAgentsChanged(state.agentNames);
+      return;
+    }
+    state.timer = setTimeout(() => this.pollStablePath(path), WRITE_STABILITY_POLL_MS);
+  }
+  emitAgentsChanged(agentNames) {
+    if (agentNames.size === 0) return;
+    for (const listener of this.listeners) {
+      listener(new Set(agentNames));
+    }
+  }
+  reportWatchError(event, data) {
+    appLogger.error(event, data);
+    console.error("[watch] File watcher failed:", data.error);
+  }
+};
+
+// src/live-scan.ts
+var REFRESH_DEBOUNCE_MS = 200;
+var EMPTY_AGENT_REFRESH_DEBOUNCE_MS = 3e4;
+var PENDING_REFRESH_DELAY_MS = 100;
+var NEW_SESSION_EVENT_WINDOW_MS = 250;
+var SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD = 100;
+function buildRefreshDiff(agentName, previousSessions, nextSessions, candidateChangedIds = []) {
+  const { changes, removedSessionIds, counts } = computeSessionDiff(
+    previousSessions,
+    nextSessions,
+    candidateChangedIds,
+    sessionSignature
+  );
+  if (counts.new === 0 && counts.updated === 0 && counts.removed === 0) {
+    return { event: null, changedSessions: changes, removedSessionIds };
+  }
+  return {
+    changedSessions: changes,
+    removedSessionIds,
+    event: {
+      type: "sessions-updated",
+      changedAgents: [agentName],
+      newSessions: counts.new,
+      updatedSessions: counts.updated,
+      removedSessions: counts.removed,
+      totalSessions: nextSessions.length,
+      timestamp: Date.now(),
+      changedSessionHeads: changes.map(({ session }) => ({ agentName, session })),
+      removedSessionRefs: removedSessionIds.map((sessionId) => ({ agentName, sessionId }))
+    }
+  };
+}
+function restoreAgentCacheMeta(agent, meta) {
+  agent.setSessionMetaMap(new Map(Object.entries(meta)));
+}
+function mergeEvents(previous, next) {
+  const changedSessionHeads = /* @__PURE__ */ new Map();
+  const removedSessionRefs = /* @__PURE__ */ new Map();
+  const sessionKey = (agentName, sessionId) => `${agentName}\0${sessionId}`;
+  const addChanged = (item) => {
+    const key = sessionKey(item.agentName, item.session.id);
+    removedSessionRefs.delete(key);
+    changedSessionHeads.set(key, item);
+  };
+  const addRemoved = (item) => {
+    const key = sessionKey(item.agentName, item.sessionId);
+    changedSessionHeads.delete(key);
+    removedSessionRefs.set(key, item);
+  };
+  for (const item of previous.changedSessionHeads) addChanged(item);
+  for (const item of previous.removedSessionRefs) addRemoved(item);
+  for (const item of next.changedSessionHeads) addChanged(item);
+  for (const item of next.removedSessionRefs) addRemoved(item);
+  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,
+    changedSessionHeads: [...changedSessionHeads.values()],
+    removedSessionRefs: [...removedSessionRefs.values()]
+  };
+}
+var LiveScanStore = class {
+  constructor(watchEnabled = true, scanOptions = {}, startupScanOptions = {}, storeOptions = {}) {
+    this.watchEnabled = watchEnabled;
+    this.scanOptions = scanOptions;
+    this.startupScanOptions = startupScanOptions;
+    this.storeOptions = storeOptions;
+  }
+  watchEnabled;
+  scanOptions;
+  startupScanOptions;
+  storeOptions;
+  agents = [];
+  byAgent = {};
+  sessions = [];
+  listeners = /* @__PURE__ */ new Set();
+  scanStatusListeners = /* @__PURE__ */ new Set();
+  scanStatus = {
+    active: false,
+    phase: "idle",
+    pendingAgents: [],
+    scanningAgents: [],
+    completedAgents: [],
+    agentStatuses: {},
+    totalAgents: 0,
+    updatedAt: Date.now()
+  };
+  refreshTimers = /* @__PURE__ */ new Map();
+  refreshTimestamps = /* @__PURE__ */ new Map();
+  refreshInFlight = /* @__PURE__ */ new Set();
+  pendingRefreshes = /* @__PURE__ */ new Set();
+  pendingRefreshPathCounts = /* @__PURE__ */ new Map();
+  watcher = null;
+  pendingEvent = null;
+  pendingEventTimer = null;
+  backgroundRefreshTimer = null;
+  searchIndexWorker = null;
+  pendingSearchIndexJobs = [];
+  shuttingDown = false;
+  async initialize() {
+    const startedAt = performance.now();
+    const deferInitialRefresh = this.storeOptions.deferInitialRefresh === true;
+    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,
+      deferred: deferInitialRefresh || void 0
+    });
+    const initialResult = await scanSessions({
+      ...this.scanOptions,
+      ...deferInitialRefresh ? this.startupScanOptions : {},
+      useCache: this.scanOptions.useCache ?? true,
+      smartRefresh: false,
+      cacheOnly: deferInitialRefresh,
+      writeCache: deferInitialRefresh ? false : this.scanOptions.writeCache,
+      smartTagWorkerUrl: this.getSmartTagWorkerUrl() ?? void 0,
+      includeSmartTags: deferInitialRefresh ? false : void 0
+    });
+    this.applyScanResult(initialResult);
+    const indexStartedAt = performance.now();
+    if (!deferInitialRefresh) {
+      await this.enqueueSearchIndexJobs(
+        "scan.initial",
+        this.buildFullSearchIndexJobs("scan.initial")
+      );
+    }
+    const indexDuration = performance.now() - indexStartedAt;
+    appLogger.info("scan.initial.done", {
+      duration_ms: Math.round(performance.now() - startedAt),
+      index_ms: deferInitialRefresh ? void 0 : Math.round(indexDuration),
+      deferred: deferInitialRefresh || void 0,
+      sessions: this.sessions.length,
+      agents: Object.fromEntries(
+        Object.entries(this.byAgent).map(([key, value]) => [key, value.length])
+      ),
+      agent_timings: initialResult.timings ? Object.fromEntries(
+        Object.entries(initialResult.timings).map(([name, t]) => [
+          name,
+          {
+            total_ms: Math.round(t.total),
+            cache_load_ms: t.cacheLoad != null ? Math.round(t.cacheLoad) : void 0,
+            check_changes_ms: t.checkChanges != null ? Math.round(t.checkChanges) : void 0,
+            scan_ms: t.scan != null ? Math.round(t.scan) : void 0,
+            identity_ms: t.identity != null ? Math.round(t.identity) : void 0,
+            tags_ms: t.tags != null ? Math.round(t.tags) : void 0
+          }
+        ])
+      ) : void 0
+    });
+    if (this.watchEnabled) {
+      this.watcher = new SessionWatcher();
+      this.watcher.onAgentsChanged((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);
+        }
+      });
+      this.watcher.start(this.agents.map((agent) => agent.name));
+    }
+  }
+  startBackgroundRefresh() {
+    if (this.backgroundRefreshTimer) {
+      return;
+    }
+    const agentNames = this.agents.map((agent) => agent.name);
+    this.startScanBatch(agentNames, "scanning");
+    this.backgroundRefreshTimer = setTimeout(() => {
+      this.backgroundRefreshTimer = null;
+      for (const agentName of agentNames) {
+        this.scheduleRefresh(agentName, 0);
+      }
+      if (agentNames.length === 0) {
+        this.finishScanBatch();
+      }
+    }, 0);
+  }
+  getSnapshot() {
+    return {
+      sessions: this.sessions,
+      byAgent: this.byAgent,
+      agents: this.agents
+    };
+  }
+  getScanStatus() {
+    return {
+      type: "scan-status",
+      ...this.scanStatus,
+      pendingAgents: [...this.scanStatus.pendingAgents],
+      scanningAgents: [...this.scanStatus.scanningAgents],
+      completedAgents: [...this.scanStatus.completedAgents],
+      agentStatuses: Object.fromEntries(
+        Object.entries(this.scanStatus.agentStatuses).map(([agentName, status]) => [
+          agentName,
+          { ...status }
+        ])
+      )
+    };
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  subscribeScanStatus(listener) {
+    this.scanStatusListeners.add(listener);
+    return () => {
+      this.scanStatusListeners.delete(listener);
+    };
+  }
+  async shutdown() {
+    this.shuttingDown = true;
+    for (const timer of this.refreshTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.refreshTimers.clear();
+    this.pendingRefreshPathCounts.clear();
     if (this.pendingEventTimer) {
       clearTimeout(this.pendingEventTimer);
       this.pendingEventTimer = null;
@@ -1488,9 +1510,10 @@ var LiveScanStore = class {
     }
     this.pendingSearchIndexJobs = [];
     this.pendingEvent = null;
-    await Promise.all(this.watchers.map((watcher) => watcher.close()));
-    this.watchers = [];
-    this.fallbackWatchScopes.clear();
+    if (this.watcher) {
+      await this.watcher.dispose();
+      this.watcher = null;
+    }
   }
   emit(event) {
     if (this.pendingEvent || event.newSessions > 0) {
@@ -1674,14 +1697,14 @@ var LiveScanStore = class {
   }
   getSearchIndexWorkerUrl() {
     const workerUrl = new URL("./search-index-worker.js", import.meta.url);
-    if (workerUrl.protocol === "file:" && !existsSync3(fileURLToPath2(workerUrl))) {
+    if (workerUrl.protocol === "file:" && !existsSync4(fileURLToPath2(workerUrl))) {
       return null;
     }
     return workerUrl;
   }
   getSmartTagWorkerUrl() {
     const workerUrl = new URL("./smart-tag-worker.js", import.meta.url);
-    if (workerUrl.protocol === "file:" && !existsSync3(fileURLToPath2(workerUrl))) {
+    if (workerUrl.protocol === "file:" && !existsSync4(fileURLToPath2(workerUrl))) {
       return null;
     }
     return workerUrl;
@@ -1861,9 +1884,6 @@ var LiveScanStore = class {
   applyFilters(sessions) {
     return filterSessions(sessions, { ...this.scanOptions, ...this.startupScanOptions });
   }
-  canSyncSources(agent) {
-    return Boolean(agent.listSessionSources && agent.scanSessionSource);
-  }
   async refreshInitialIndex() {
     const startedAt = performance.now();
     const context = "scan.initial.background";
@@ -1881,195 +1901,6 @@ var LiveScanStore = class {
       console.error("[search] Background index sync failed:", error);
     }
   }
-  startWatching() {
-    const scopesByRoot = /* @__PURE__ */ new Map();
-    for (const agent of this.agents) {
-      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", {
-        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) => {
-        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;
-    }
-  }
-  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);
@@ -2149,7 +1980,7 @@ var LiveScanStore = class {
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
       this.refreshTimestamps.set(agentName, Date.now());
-    } else if (cached && this.canSyncSources(agent)) {
+    } else if (cached && agent instanceof FileSystemSessionSource) {
       const scanStartedAt = performance.now();
       const result = await this.scanAgentInWorker(
         agent,
@@ -2162,7 +1993,7 @@ var LiveScanStore = class {
         }
       );
       nextSessions = result.sessions;
-      agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
+      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
       preciseChangedIds = result.changedIds ?? [];
       usedIncrementalScan = true;
       persistenceDiff = buildRefreshDiff(
@@ -2179,7 +2010,7 @@ var LiveScanStore = class {
           duration_ms: Math.round(performance.now() - startedAt)
         });
       }
-    } else if (refreshBaseline.length > 0 && agent.checkForChanges && agent.incrementalScan) {
+    } else if (refreshBaseline.length > 0) {
       const checkStartedAt = performance.now();
       const checkResult = await Promise.resolve(
         agent.checkForChanges(cacheTimestamp, refreshBaseline)
@@ -2212,7 +2043,7 @@ var LiveScanStore = class {
       const scanStartedAt = performance.now();
       const result = await this.scanAgentInWorker(agent, previousSessions, null, {});
       nextSessions = result.sessions;
-      agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
+      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
       fullScanSessions = attachMissingProjectIdentities(nextSessions);
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
@@ -2445,7 +2276,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-VEIV33FR.js");
+      const { clearCache: clear } = await import("./dist-GZSUB4NY.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");