codesesh 0.13.0 → 0.15.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
-  BookmarkStorageUnavailableError,
   FileSystemSessionSource,
+  StateStorageUnavailableError,
   attachMissingProjectIdentities,
   buildAgentCacheMeta,
   buildDashboard,
@@ -11,9 +11,9 @@ import {
   createProjectScopeMatcher,
   createRegisteredAgents,
   deleteBookmark,
+  deleteSessionAlias,
   executeSessionSearch,
   extractSessionFileActivity,
-  filterSessions,
   getAgentInfoMap,
   getAgentLastFullSyncAt,
   getCursorDataPath,
@@ -27,12 +27,14 @@ import {
   listBookmarks,
   listCachedProjectGroups,
   listFileActivity,
+  listSessionAliases,
   listSessionFileActivity,
   loadCachedSessionData,
   loadCachedSessions,
   markAgentFullSyncCompleted,
   matchesProjectIdentity,
   matchesProjectScope,
+  mergeSearchQueryOptions,
   perf,
   realFs,
   refreshPricingCache,
@@ -41,8 +43,9 @@ import {
   sessionSignature,
   sortSessions,
   startOfLocalDay,
-  upsertBookmark
-} from "./chunk-BV65IEWZ.js";
+  upsertBookmark,
+  upsertSessionAlias
+} from "./chunk-NBCLV4CX.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -208,7 +211,131 @@ function logSearchIndexSync(context, result, data = {}) {
   });
 }
 
+// src/time-window-resolution.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_DASHBOARD_DAYS = 30;
+function resolveTimeWindow(request) {
+  return request.mode === "cli" ? resolveCliWindow(request) : resolveDashboardWindow(request);
+}
+function resolveCliWindow(request) {
+  const now = request.now ?? Date.now();
+  const from = parseRequiredDate(request.from);
+  const to = parseRequiredDate(request.to);
+  if (from != null) return { from, to };
+  const days = parseDays(request.days);
+  if (days === 0) return { to, days };
+  if (days == null || days < 0) return { to };
+  const rollingFrom = now - days * DAY_MS;
+  return Number.isFinite(rollingFrom) ? { from: rollingFrom, to, days } : { to };
+}
+function resolveDashboardWindow(request) {
+  const now = request.now ?? Date.now();
+  const defaults = request.defaults ?? {};
+  const to = parseOptionalDate(request.query.to) ?? defaults.to ?? now;
+  const hasQueryDays = Boolean(request.query.days?.trim());
+  const parsedDays = hasQueryDays ? parseDays(request.query.days) : void 0;
+  let days = parsedDays != null && parsedDays > 0 ? parsedDays : defaults.days;
+  const queryFrom = parseOptionalDate(request.query.from);
+  if (queryFrom != null) {
+    days ??= elapsedDays(queryFrom, to);
+    return { from: queryFrom, to, days };
+  }
+  if (parsedDays === 0 || !hasQueryDays && defaults.days === 0) {
+    return { to, days: 0 };
+  }
+  if (defaults.from != null) {
+    days ??= elapsedDays(defaults.from, to);
+    return { from: defaults.from, to, days };
+  }
+  const resolvedDays = days != null && days > 0 ? days : DEFAULT_DASHBOARD_DAYS;
+  return {
+    from: startOfLocalDay(to) - (resolvedDays - 1) * DAY_MS,
+    to,
+    days: resolvedDays
+  };
+}
+function parseRequiredDate(value) {
+  if (!value) return void 0;
+  const timestamp = new Date(value).getTime();
+  if (Number.isNaN(timestamp)) throw new Error(`Invalid date: ${value}`);
+  return timestamp;
+}
+function parseOptionalDate(value) {
+  if (value == null) return void 0;
+  const timestamp = new Date(value).getTime();
+  return Number.isNaN(timestamp) ? void 0 : timestamp;
+}
+function parseDays(value) {
+  if (value == null) return void 0;
+  const days = Number.parseInt(value, 10);
+  return Number.isSafeInteger(days) && Number.isSafeInteger(days * DAY_MS) ? days : void 0;
+}
+function elapsedDays(from, to) {
+  return Math.max(1, Math.ceil((to - from) / DAY_MS));
+}
+
 // src/api/handlers.ts
+function getSessionAliasKey(agentKey, sessionId) {
+  return `${agentKey.toLowerCase()}\0${sessionId}`;
+}
+function getSessionAgentKey(session) {
+  return session.slug.split("/")[0]?.toLowerCase() ?? "";
+}
+function loadSessionAliasMap() {
+  try {
+    return new Map(
+      listSessionAliases().map((alias) => [
+        getSessionAliasKey(alias.agentKey, alias.sessionId),
+        alias.alias
+      ])
+    );
+  } catch (error) {
+    if (!(error instanceof StateStorageUnavailableError)) {
+      appLogger.warn("api.session_aliases.load_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return /* @__PURE__ */ new Map();
+  }
+}
+function isStateStorageUnavailable(error) {
+  return error instanceof StateStorageUnavailableError;
+}
+function withDisplayTitle(session, agentKey, aliases) {
+  const alias = aliases.get(getSessionAliasKey(agentKey, session.id));
+  return alias ? { ...session, display_title: alias } : session;
+}
+function withBookmarkDisplayTitle(bookmark, aliases) {
+  const alias = aliases.get(getSessionAliasKey(bookmark.agentKey, bookmark.sessionId));
+  return alias ? { ...bookmark, display_title: alias } : bookmark;
+}
+function withFileActivityDisplayTitle(activity, aliases) {
+  return {
+    ...activity,
+    session: withDisplayTitle(activity.session, activity.agent_name, aliases)
+  };
+}
+function findAliasSearchResults(query, options, scanResult, aliases) {
+  const search = mergeSearchQueryOptions(query, options);
+  const needle = search.text.trim().toLowerCase();
+  if (!needle || aliases.size === 0) return [];
+  return executeSessionSearch(
+    "",
+    { ...search.options, limit: Math.max(scanResult.sessions.length, 1) },
+    scanResult
+  ).flatMap((result) => {
+    const alias = aliases.get(getSessionAliasKey(result.agentName, result.session.id));
+    if (!alias || !alias.toLowerCase().includes(needle)) return [];
+    return [
+      {
+        agentName: result.agentName,
+        session: withDisplayTitle(result.session, result.agentName, aliases),
+        snippet: `Alias \xB7 ${result.session.directory}`,
+        matchType: "title"
+      }
+    ];
+  });
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -288,9 +415,6 @@ function parseSearchOptions(c, defaults, projectIdentity) {
     limit: limitValue && limitValue > 0 ? Math.min(limitValue, 100) : 50
   };
 }
-function filterSessionsByWindow(sessions, from, to) {
-  return filterSessionsByActivityWindow(sessions, from, to);
-}
 function filterSessionsByActivityWindow(sessions, from, to) {
   if (from == null && to == null) return sessions;
   return sessions.filter((session) => {
@@ -382,19 +506,20 @@ function handleGetScanStatus(c, scanSource) {
 }
 function handleGetAgents(c, scanSource, defaults = {}) {
   const scanResult = scanSource.getSnapshot();
-  const { from, to } = defaults;
+  const from = parseDateParam(c.req.query("from"), defaults.from);
+  const to = parseDateParam(c.req.query("to"), defaults.to);
   const counts = Object.fromEntries(
     Object.entries(scanResult.byAgent).map(([agentName, sessions]) => [
       agentName,
-      filterSessionsByWindow(sessions, from, to).length
+      filterSessionsByActivityWindow(sessions, from, to).length
     ])
   );
-  const info = getAgentInfoMap(counts).filter((agent) => agent.count > 0);
-  return c.json(info);
+  return c.json(getAgentInfoMap(counts));
 }
 function handleGetProjects(c, scanSource, defaults = {}) {
   const scanResult = scanSource.getSnapshot();
-  const { from, to } = defaults;
+  const from = parseDateParam(c.req.query("from"), defaults.from);
+  const to = parseDateParam(c.req.query("to"), defaults.to);
   const sessions = filterSessionsByActivityWindow(scanResult.sessions, from, to);
   return c.json({
     projects: attachProjectMetrics(listCachedProjectGroups(sessions), sessions)
@@ -433,10 +558,18 @@ function handleGetSessions(c, scanSource, defaults = {}) {
   if (tag) {
     sessions = sessions.filter((s) => s.smart_tags?.includes(tag));
   }
+  const aliases = loadSessionAliasMap();
   if (q) {
-    sessions = sessions.filter((s) => s.title.toLowerCase().includes(q));
+    sessions = sessions.filter((session) => {
+      const alias = aliases.get(getSessionAliasKey(getSessionAgentKey(session), session.id));
+      return session.title.toLowerCase().includes(q) || alias?.toLowerCase().includes(q);
+    });
   }
-  return c.json({ sessions });
+  return c.json({
+    sessions: sessions.map(
+      (session) => withDisplayTitle(session, getSessionAgentKey(session), aliases)
+    )
+  });
 }
 function handleSearchSessions(c, scanSource, defaults = {}) {
   const query = c.req.query("q")?.trim() ?? "";
@@ -449,8 +582,17 @@ function handleSearchSessions(c, scanSource, defaults = {}) {
     return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
   }
   const searchOptions = parseSearchOptions(c, defaults, projectIdentity);
-  const results = executeSessionSearch(query, searchOptions, scanResult);
-  return c.json({ results });
+  const aliases = loadSessionAliasMap();
+  const results = executeSessionSearch(query, searchOptions, scanResult).map((result) => ({
+    ...result,
+    session: withDisplayTitle(result.session, result.agentName, aliases)
+  }));
+  const aliasResults = findAliasSearchResults(query, searchOptions, scanResult, aliases);
+  const deduped = /* @__PURE__ */ new Map();
+  for (const result of [...aliasResults, ...results]) {
+    deduped.set(`${result.agentName}\0${result.session.id}`, result);
+  }
+  return c.json({ results: [...deduped.values()].slice(0, searchOptions.limit ?? 50) });
 }
 function parseFileActivityKind(value) {
   if (value === "read" || value === "edit" || value === "write" || value === "delete") {
@@ -479,6 +621,7 @@ function handleGetFileActivity(c, defaults = {}) {
   if (projectIdentity === null) {
     return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
   }
+  const aliases = loadSessionAliasMap();
   return c.json({
     activity: listFileActivity({
       agent: optionalQueryValue(c.req.query("agent")),
@@ -492,7 +635,7 @@ function handleGetFileActivity(c, defaults = {}) {
       from: parseDateParam(c.req.query("from"), defaults.from),
       to: parseDateParam(c.req.query("to"), defaults.to),
       limit
-    })
+    }).map((activity) => withFileActivityDisplayTitle(activity, aliases))
   });
 }
 async function handleGetSessionData(c, scanSource) {
@@ -539,8 +682,9 @@ async function handleGetSessionData(c, scanSource) {
       tag_duration_ms: Math.round(tagDuration),
       duration_ms: Math.round(performance.now() - startedAt)
     });
+    const aliases = loadSessionAliasMap();
     return c.json({
-      ...data,
+      ...withDisplayTitle(data, agentName, aliases),
       project_identity: projectIdentity,
       smart_tags: smartTags,
       smart_tags_source_updated_at: getSmartTagSourceTimestamp(data),
@@ -569,9 +713,13 @@ async function handlePostClientLog(c) {
 }
 function handleGetBookmarks(c) {
   try {
-    return c.json({ bookmarks: listBookmarks(), storageAvailable: true });
+    const aliases = loadSessionAliasMap();
+    return c.json({
+      bookmarks: listBookmarks().map((bookmark) => withBookmarkDisplayTitle(bookmark, aliases)),
+      storageAvailable: true
+    });
   } catch (error) {
-    if (error instanceof BookmarkStorageUnavailableError) {
+    if (error instanceof StateStorageUnavailableError) {
       return c.json({ bookmarks: [], storageAvailable: false });
     }
     throw error;
@@ -585,7 +733,7 @@ async function handlePutBookmark(c) {
   try {
     return c.json({ bookmark: upsertBookmark(payload), storageAvailable: true });
   } catch (error) {
-    if (error instanceof BookmarkStorageUnavailableError) {
+    if (error instanceof StateStorageUnavailableError) {
       return c.json({ error: "Bookmark storage is unavailable" }, 503);
     }
     throw error;
@@ -603,7 +751,7 @@ async function handleImportBookmarks(c) {
   try {
     return c.json({ bookmarks: importBookmarks(bookmarks), storageAvailable: true });
   } catch (error) {
-    if (error instanceof BookmarkStorageUnavailableError) {
+    if (error instanceof StateStorageUnavailableError) {
       return c.json({ error: "Bookmark storage is unavailable" }, 503);
     }
     throw error;
@@ -619,36 +767,46 @@ function handleDeleteBookmark(c) {
     deleteBookmark(agentKey, sessionId);
     return c.json({ ok: true, storageAvailable: true });
   } catch (error) {
-    if (error instanceof BookmarkStorageUnavailableError) {
+    if (error instanceof StateStorageUnavailableError) {
       return c.json({ error: "Bookmark storage is unavailable" }, 503);
     }
     throw error;
   }
 }
-function resolveDashboardWindow(defaults, queryDays, queryFrom, queryTo) {
-  const now = Date.now();
-  const toTs = parseDateParam(queryTo, defaults.to) ?? now;
-  const hasQueryDays = queryDays != null && queryDays.trim() !== "";
-  const parsedDays = hasQueryDays ? 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 = fromFromQuery;
-    days ??= Math.max(1, Math.ceil((toTs - fromTs) / 864e5));
-  } else if (parsedDays === 0 || !hasQueryDays && defaults.days === 0) {
-    days = 0;
-    return { to: toTs, days };
-  } else if (defaults.from != null) {
-    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 = startOfLocalDay(toTs) - (days - 1) * 864e5;
+async function handlePutSessionAlias(c) {
+  const agentKey = c.req.param("agent");
+  const sessionId = c.req.param("id");
+  const payload = await c.req.json().catch(() => null);
+  if (!agentKey || !sessionId || typeof payload?.alias !== "string") {
+    return c.json({ error: "Invalid session alias payload" }, 400);
+  }
+  try {
+    return c.json({ alias: upsertSessionAlias(agentKey, sessionId, payload.alias) });
+  } catch (error) {
+    if (error instanceof TypeError) {
+      return c.json({ error: "Session alias must be non-empty and at most 160 characters" }, 400);
+    }
+    if (isStateStorageUnavailable(error)) {
+      return c.json({ error: "Session alias storage is unavailable" }, 503);
+    }
+    throw error;
+  }
+}
+function handleDeleteSessionAlias(c) {
+  const agentKey = c.req.param("agent");
+  const sessionId = c.req.param("id");
+  if (!agentKey || !sessionId) {
+    return c.json({ error: "Missing session alias identifier" }, 400);
+  }
+  try {
+    deleteSessionAlias(agentKey, sessionId);
+    return c.json({ ok: true });
+  } catch (error) {
+    if (isStateStorageUnavailable(error)) {
+      return c.json({ error: "Session alias storage is unavailable" }, 503);
+    }
+    throw error;
   }
-  return { from: fromTs, to: toTs, days };
 }
 function handleGetDashboard(c, scanSource, defaults = {}) {
   const scanResult = scanSource.getSnapshot();
@@ -659,12 +817,15 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
   if (projectIdentity === null) {
     return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
   }
-  const { from, to, days } = resolveDashboardWindow(
-    defaults,
-    c.req.query("days"),
-    c.req.query("from"),
-    c.req.query("to")
-  );
+  const { from, to, days } = resolveTimeWindow({
+    mode: "dashboard",
+    query: {
+      days: c.req.query("days"),
+      from: c.req.query("from"),
+      to: c.req.query("to")
+    },
+    defaults
+  });
   const scope = {
     agent: optionalQueryValue(c.req.query("agent"))?.toLowerCase(),
     projectKind: projectIdentity?.kind,
@@ -691,11 +852,20 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
     }),
     window: { from, to, days }
   };
-  return c.json(data);
+  const aliases = loadSessionAliasMap();
+  return c.json({
+    ...data,
+    recentSessions: data.recentSessions.map(
+      (session) => withDisplayTitle(session, session.agentName, aliases)
+    ),
+    recentFileActivities: data.recentFileActivities.map(
+      (activity) => withFileActivityDisplayTitle(activity, aliases)
+    )
+  });
 }
 
 // src/api/routes.ts
-function createSseResponse(store, signal) {
+function createSseResponse(eventSource, signal) {
   const encoder = new TextEncoder();
   let cancelStream = () => {
   };
@@ -712,11 +882,11 @@ function createSseResponse(store, signal) {
 `));
         };
         write("connected", { timestamp: Date.now() });
-        write("scan-status", store.getScanStatus());
-        const unsubscribeSessions = store.subscribe((event) => {
+        write("scan-status", eventSource.getScanStatus());
+        const unsubscribeSessions = eventSource.subscribe((event) => {
           write(event.type, event);
         });
-        const unsubscribeScanStatus = store.subscribeScanStatus((event) => {
+        const unsubscribeScanStatus = eventSource.subscribeScanStatus((event) => {
           write(event.type, event);
         });
         const heartbeat = setInterval(() => {
@@ -753,7 +923,7 @@ function createSseResponse(store, signal) {
     }
   );
 }
-function createApiRoutes(scanSource, store, options = {}) {
+function createApiRoutes(scanSource, eventSource, options = {}) {
   const api = new Hono();
   const listDefaults = {
     from: options.defaultSessionFrom,
@@ -761,8 +931,8 @@ function createApiRoutes(scanSource, store, options = {}) {
     days: options.defaultSessionDays
   };
   api.get("/config", (c) => handleGetConfig(c, listDefaults));
-  if (store) {
-    api.get("/status", (c) => handleGetScanStatus(c, store));
+  if (eventSource) {
+    api.get("/status", (c) => handleGetScanStatus(c, eventSource));
   }
   api.get("/agents", (c) => handleGetAgents(c, scanSource, listDefaults));
   api.get("/projects", (c) => handleGetProjects(c, scanSource, listDefaults));
@@ -775,9 +945,11 @@ function createApiRoutes(scanSource, store, options = {}) {
   api.put("/bookmarks", (c) => handlePutBookmark(c));
   api.post("/bookmarks/import", (c) => handleImportBookmarks(c));
   api.delete("/bookmarks/:agent/:id", (c) => handleDeleteBookmark(c));
+  api.put("/session-aliases/:agent/:id", (c) => handlePutSessionAlias(c));
+  api.delete("/session-aliases/:agent/:id", (c) => handleDeleteSessionAlias(c));
   api.post("/logs", (c) => handlePostClientLog(c));
-  if (store) {
-    api.get("/events", (c) => createSseResponse(store, c.req.raw.signal));
+  if (eventSource) {
+    api.get("/events", (c) => createSseResponse(eventSource, c.req.raw.signal));
   }
   return api;
 }
@@ -906,14 +1078,7 @@ async function createServer(port, store, options = {}) {
     defaultSessionTo: options.defaultSessionTo,
     defaultSessionDays: options.defaultSessionDays
   };
-  app.route(
-    "/api",
-    createApiRoutes(
-      store,
-      "subscribe" in store ? store : void 0,
-      routeOptions
-    )
-  );
+  app.route("/api", createApiRoutes(store, store, routeOptions));
   const webDistPath = findWebDistPath();
   if (webDistPath) {
     app.use("/*", serveStatic({ root: webDistPath }));
@@ -935,9 +1100,7 @@ async function createServer(port, store, options = {}) {
       if (isAddressInUse(error) && offset < attempts - 1) {
         continue;
       }
-      if (store.shutdown) {
-        await store.shutdown();
-      }
+      await store.shutdown();
       if (isAddressInUse(error) && attempts > 1) {
         throw new Error(
           `\u7AEF\u53E3 ${port}-${port + attempts - 1} \u5747\u5DF2\u88AB\u5360\u7528\uFF0C\u8BF7\u5173\u95ED\u73B0\u6709\u8FDB\u7A0B\u6216\u6539\u7528 --port \u6307\u5B9A\u5176\u4ED6\u7AEF\u53E3\u3002`
@@ -971,9 +1134,7 @@ async function createServer(port, store, options = {}) {
         }
         server.close(() => resolve4());
       });
-      if (store.shutdown) {
-        await store.shutdown();
-      }
+      await store.shutdown();
     }
   };
 }
@@ -981,7 +1142,6 @@ async function createServer(port, store, options = {}) {
 // src/live-scan.ts
 import { existsSync as existsSync5 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { Worker as Worker2 } from "worker_threads";
 
 // src/search-index-job-runner.ts
 import { existsSync as existsSync3 } from "fs";
@@ -1274,7 +1434,7 @@ var ScanStatusModel = class {
     agentStatuses: {},
     totalAgents: 0,
     updatedAt: Date.now(),
-    backfill: { active: false, pendingAgents: [], completedAgents: [] }
+    backfill: { active: false, pendingAgents: [], completedAgents: [], failedAgents: [] }
   };
   snapshot() {
     return {
@@ -1292,7 +1452,8 @@ var ScanStatusModel = class {
       backfill: {
         ...this.status.backfill,
         pendingAgents: [...this.status.backfill.pendingAgents],
-        completedAgents: [...this.status.backfill.completedAgents]
+        completedAgents: [...this.status.backfill.completedAgents],
+        failedAgents: [...this.status.backfill.failedAgents]
       }
     };
   }
@@ -1443,79 +1604,180 @@ var ScanStatusModel = class {
   }
 };
 
-// src/backfill-coordinator.ts
-var BackfillCoordinator = class {
-  queue = [];
-  currentAgent;
-  completedAgents = [];
-  get isRunning() {
-    return this.currentAgent != null;
-  }
-  enqueue(agentName) {
-    if (this.currentAgent === agentName || this.queue.includes(agentName)) return null;
-    this.queue.push(agentName);
-    return this.snapshot();
-  }
-  take() {
-    if (this.currentAgent) return null;
-    const agentName = this.queue.shift();
-    if (!agentName) return null;
-    this.currentAgent = agentName;
-    return { agentName, status: this.snapshot() };
-  }
-  complete(agentName) {
-    if (this.currentAgent === agentName) this.currentAgent = void 0;
-    if (!this.completedAgents.includes(agentName)) this.completedAgents.push(agentName);
-    return this.snapshot();
-  }
-  clear() {
-    this.queue.length = 0;
-    this.currentAgent = void 0;
-  }
-  snapshot() {
-    return {
-      active: this.currentAgent != null || this.queue.length > 0,
-      pendingAgents: [...this.queue],
-      currentAgent: this.currentAgent,
-      completedAgents: [...this.completedAgents]
-    };
-  }
-};
-
-// src/refresh-coordinator.ts
+// src/agent-sync-engine.ts
+var REFRESH_DEBOUNCE_MS = 200;
+var EMPTY_AGENT_REFRESH_DEBOUNCE_MS = 3e4;
 var PENDING_REFRESH_DELAY_MS = 100;
 var MAX_ADAPTIVE_REFRESH_DELAY_MS = 3e4;
 var ADAPTIVE_REFRESH_DELAY_MULTIPLIER = 4;
-var RefreshCoordinator = class {
-  states = /* @__PURE__ */ new Map();
+var SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD = 100;
+var BACKFILL_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+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, cached) {
+  agent.setSessionMetaMap(new Map(Object.entries(cached.meta)));
+}
+var AgentSyncEngine = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  refreshStates = /* @__PURE__ */ new Map();
   operationGenerations = /* @__PURE__ */ new Map();
   operationTails = /* @__PURE__ */ new Map();
+  backfillQueue = [];
+  currentBackfillAgent;
+  completedBackfillAgents = [];
+  failedBackfillAgents = [];
+  sessionsChangedListeners = /* @__PURE__ */ new Set();
+  statusChangedListeners = /* @__PURE__ */ new Set();
+  scanStatus = new ScanStatusModel();
+  searchIndexJobs = new SearchIndexJobRunner();
+  backgroundRefreshTimer = null;
   isShuttingDown = false;
-  get activeOperationCount() {
-    return this.operationTails.size;
+  initialize(cacheTimestamps = {}) {
+    for (const agent of this.options.snapshot().agents) {
+      this.state(agent.name).lastRefreshAt = cacheTimestamps[agent.name] ?? Date.now();
+    }
   }
-  get activeRefreshCount() {
-    return [...this.states.values()].filter((state) => state.isRunning).length;
+  status() {
+    return this.scanStatus.snapshot();
   }
-  recordChangedPaths(agentName, count = 1) {
-    this.state(agentName).pendingPathCount += count;
+  subscribeSessionsChanged(listener) {
+    this.sessionsChangedListeners.add(listener);
+    return () => this.sessionsChangedListeners.delete(listener);
   }
-  takePendingPathCount(agentName) {
-    const state = this.state(agentName);
-    const count = state.pendingPathCount;
-    state.pendingPathCount = 0;
-    return count;
+  subscribeStatusChanged(listener) {
+    this.statusChangedListeners.add(listener);
+    return () => this.statusChangedListeners.delete(listener);
+  }
+  async syncInitialIndex() {
+    await this.searchIndexJobs.enqueue(
+      "scan.initial",
+      this.buildFullSearchIndexJobs("scan.initial")
+    );
+  }
+  handleAgentsChanged(agentNames) {
+    const snapshot = this.options.snapshot();
+    for (const agentName of agentNames) {
+      this.state(agentName).pendingPathCount += 1;
+      const delayMs = (snapshot.byAgent[agentName]?.length ?? 0) === 0 ? EMPTY_AGENT_REFRESH_DEBOUNCE_MS : REFRESH_DEBOUNCE_MS;
+      this.scheduleRefresh(agentName, delayMs);
+    }
+  }
+  startBackgroundRefresh() {
+    if (this.backgroundRefreshTimer) return;
+    const agentNames = this.options.snapshot().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);
+  }
+  async refresh(agentName) {
+    await this.runCoalescedRefresh(agentName);
+  }
+  async shutdown() {
+    this.isShuttingDown = true;
+    const activeOperations = {
+      agent_operations: this.operationTails.size,
+      refreshes: [...this.refreshStates.values()].filter((state) => state.isRunning).length,
+      backfill_running: this.currentBackfillAgent != null || void 0,
+      scan_workers: this.options.workerRunner.activeCount
+    };
+    if (activeOperations.agent_operations > 0 || activeOperations.scan_workers > 0) {
+      appLogger.warn("scan.shutdown.active_operations", activeOperations);
+    }
+    for (const state of this.refreshStates.values()) {
+      if (!state.timer) continue;
+      clearTimeout(state.timer);
+      state.timer = null;
+      state.timerDeadline = 0;
+    }
+    if (this.backgroundRefreshTimer) {
+      clearTimeout(this.backgroundRefreshTimer);
+      this.backgroundRefreshTimer = null;
+    }
+    this.backfillQueue.length = 0;
+    this.currentBackfillAgent = void 0;
+    const searchIndexSnapshot = this.searchIndexJobs.snapshot();
+    appLogger.info("search_index.shutdown.started", {
+      active_batch_id: searchIndexSnapshot.activeBatchId,
+      pending_batches: searchIndexSnapshot.pendingBatches
+    });
+    await this.searchIndexJobs.shutdown();
+    await this.options.workerRunner.shutdown();
+    await Promise.allSettled(this.operationTails.values());
+    const stoppedSearchIndexSnapshot = this.searchIndexJobs.snapshot();
+    appLogger.info("search_index.shutdown.completed", {
+      active_batch_id: searchIndexSnapshot.activeBatchId,
+      pending_batches: stoppedSearchIndexSnapshot.pendingBatches
+    });
+  }
+  startScanBatch(agentNames, phase) {
+    const snapshot = this.options.snapshot();
+    const sessionCounts = Object.fromEntries(
+      agentNames.map((agentName) => [agentName, snapshot.byAgent[agentName]?.length ?? 0])
+    );
+    this.publishStatus(this.scanStatus.startBatch(agentNames, phase, sessionCounts));
+  }
+  setScanPhase(phase) {
+    this.publishStatus(this.scanStatus.setPhase(phase));
+  }
+  beginAgentScan(agentName) {
+    const snapshot = this.options.snapshot();
+    if (!this.scanStatus.snapshot().active) this.startScanBatch([agentName], "scanning");
+    this.publishStatus(
+      this.scanStatus.beginAgent(agentName, snapshot.byAgent[agentName]?.length ?? 0)
+    );
+  }
+  updateAgentScanProgress(agentName, progress) {
+    this.publishStatus(this.scanStatus.updateAgent(agentName, progress));
+  }
+  finishAgentScan(agentName) {
+    const count = this.options.snapshot().byAgent[agentName]?.length;
+    this.publishStatus(this.scanStatus.finishAgent(agentName, count));
+  }
+  finishScanBatch() {
+    this.publishStatus(this.scanStatus.finishBatch());
   }
-  lastRefreshAt(agentName) {
-    return this.state(agentName).lastRefreshAt;
+  publishBackfillStatus() {
+    this.publishStatus(this.scanStatus.updateBackfill(this.backfillStatus()));
   }
-  setLastRefreshAt(agentName, timestamp) {
-    this.state(agentName).lastRefreshAt = timestamp;
+  publishStatus(event) {
+    if (!event || this.isShuttingDown) return;
+    for (const listener of this.statusChangedListeners) listener(event);
   }
-  setLastRefreshDuration(agentName, durationMs) {
-    this.state(agentName).lastRefreshDurationMs = durationMs;
+  emitSessionsChanged(change) {
+    if (this.isShuttingDown) return;
+    for (const listener of this.sessionsChangedListeners) listener(change);
   }
-  schedule(agentName, delayMs, refresh) {
+  scheduleRefresh(agentName, delayMs) {
     if (this.isShuttingDown) return;
     const state = this.state(agentName);
     const adaptiveDelayMs = Math.min(
@@ -1532,10 +1794,10 @@ var RefreshCoordinator = class {
     state.timerDeadline = deadline;
     state.timer = setTimeout(() => {
       state.timer = null;
-      void refresh();
+      void this.runCoalescedRefresh(agentName);
     }, effectiveDelayMs);
   }
-  async runRefresh(agentName, operation) {
+  async runCoalescedRefresh(agentName) {
     const state = this.state(agentName);
     if (state.isRunning) {
       appLogger.debug("scan.refresh.pending", { agent: agentName });
@@ -1544,91 +1806,423 @@ var RefreshCoordinator = class {
     }
     state.isRunning = true;
     try {
-      await this.serialize(agentName, "refresh", operation);
+      await this.serialize(agentName, "refresh", () => this.performRefresh(agentName));
     } finally {
       state.isRunning = false;
       if (state.hasPendingRerun && !this.isShuttingDown) {
         state.hasPendingRerun = false;
-        this.schedule(
-          agentName,
-          PENDING_REFRESH_DELAY_MS,
-          () => this.runRefresh(agentName, operation)
-        );
+        this.scheduleRefresh(agentName, PENDING_REFRESH_DELAY_MS);
       }
     }
   }
-  serialize(agentName, kind, operation) {
-    const previous = this.operationTails.get(agentName) ?? Promise.resolve();
-    const run = previous.then(async () => {
-      if (this.isShuttingDown) return "skipped";
-      const lifecycle = this.beginOperation(agentName, kind);
-      try {
-        const result = await operation();
-        this.completeOperation(lifecycle, result);
-        return result;
-      } catch (error) {
-        this.completeOperation(lifecycle, "failed");
-        throw error;
-      }
-    });
-    const tail = run.then(
-      () => void 0,
-      () => void 0
-    );
-    this.operationTails.set(agentName, tail);
-    void tail.finally(() => {
-      if (this.operationTails.get(agentName) === tail) this.operationTails.delete(agentName);
-    });
-    return run;
-  }
-  async shutdown() {
-    this.isShuttingDown = true;
-    for (const state of this.states.values()) {
-      if (!state.timer) continue;
-      clearTimeout(state.timer);
-      state.timer = null;
-      state.timerDeadline = 0;
+  async performRefresh(agentName) {
+    this.beginAgentScan(agentName);
+    try {
+      return await this.runRefresh(agentName);
+    } catch (error) {
+      appLogger.error("scan.refresh.error", { agent: agentName, error });
+      console.error(`[${agentName}] Session refresh failed:`, error);
+      return "failed";
+    } finally {
+      this.finishAgentScan(agentName);
+      const agent = this.findAgent(agentName);
+      if (agent && this.needsBackfill(agent)) this.enqueueBackfill(agentName);
     }
-    await Promise.allSettled(this.operationTails.values());
-  }
-  state(agentName) {
-    const existing = this.states.get(agentName);
-    if (existing) return existing;
-    const state = {
-      timer: null,
-      timerDeadline: 0,
-      isRunning: false,
-      hasPendingRerun: false,
-      lastRefreshAt: 0,
-      lastRefreshDurationMs: 0,
-      pendingPathCount: 0
-    };
-    this.states.set(agentName, state);
-    return state;
-  }
-  beginOperation(agentName, kind) {
-    const generation = (this.operationGenerations.get(agentName) ?? 0) + 1;
-    const startedAt = Date.now();
-    this.operationGenerations.set(agentName, generation);
-    appLogger.info("scan.agent_operation.started", {
-      agent: agentName,
-      operation: kind,
-      generation,
-      started_at: startedAt
-    });
-    return { agentName, kind, generation, startedAt };
-  }
-  completeOperation(lifecycle, result) {
-    const completedAt = Date.now();
-    appLogger.info("scan.agent_operation.completed", {
-      agent: lifecycle.agentName,
-      operation: lifecycle.kind,
-      generation: lifecycle.generation,
-      started_at: lifecycle.startedAt,
-      completed_at: completedAt,
-      duration_ms: completedAt - lifecycle.startedAt,
-      result
-    });
+  }
+  async runRefresh(agentName) {
+    const startedAt = performance.now();
+    const state = this.state(agentName);
+    const pendingPathCount = state.pendingPathCount;
+    state.pendingPathCount = 0;
+    const agent = this.findAgent(agentName);
+    if (!agent) {
+      appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
+      return "skipped";
+    }
+    const previousSessions = this.options.snapshot().byAgent[agentName] ?? [];
+    const cached = loadCachedSessions(agentName);
+    const refreshBaseline = cached?.sessions ?? previousSessions;
+    const cacheTimestamp = cached?.timestamp ?? state.lastRefreshAt;
+    if (cached) restoreAgentCacheMeta(agent, cached);
+    const isInitialized = isAgentCacheInitialized(agentName);
+    const availabilityStartedAt = performance.now();
+    const isAvailable = agent.isAvailable();
+    const availabilityDuration = performance.now() - availabilityStartedAt;
+    let strategyResult;
+    if (!isAvailable) {
+      strategyResult = this.refreshUnavailableAgent(agentName);
+    } else if (!isInitialized) {
+      strategyResult = await this.initializeAgent(agent, previousSessions);
+    } else if (cached && agent instanceof FileSystemSessionSource) {
+      strategyResult = await this.syncAgentSources(agent, cached, startedAt);
+    } else if (refreshBaseline.length > 0) {
+      strategyResult = await this.refreshChangedAgent(
+        agent,
+        refreshBaseline,
+        cacheTimestamp,
+        startedAt
+      );
+    } else {
+      strategyResult = await this.scanAgentFully(agent, previousSessions);
+    }
+    if (strategyResult.status === "unchanged") return "unchanged";
+    const nextSessions = attachMissingProjectIdentities(strategyResult.nextSessions);
+    const diffStartedAt = performance.now();
+    const diff = buildRefreshDiff(
+      agentName,
+      previousSessions,
+      nextSessions,
+      strategyResult.preciseChangedIds ?? []
+    );
+    const diffDuration = performance.now() - diffStartedAt;
+    const searchIndexOptions = pendingPathCount >= SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD ? { isBulk: true } : void 0;
+    const persistentChanges = strategyResult.persistenceDiff?.changedSessions ?? diff.changedSessions;
+    const persistentRemovedSessionIds = strategyResult.persistenceDiff?.removedSessionIds ?? diff.removedSessionIds;
+    const changedSessionIds = strategyResult.usedIncrementalScan ? new Set(persistentChanges.map(({ session }) => session.id)) : void 0;
+    const persistStartedAt = performance.now();
+    const persistentJob = strategyResult.usedIncrementalScan ? {
+      kind: "changes",
+      context: "scan.refresh",
+      agentName,
+      changes: persistentChanges,
+      removedSessionIds: persistentRemovedSessionIds,
+      meta: buildAgentCacheMeta(agent, changedSessionIds),
+      ...searchIndexOptions ? { searchIndexOptions } : {}
+    } : strategyResult.fullScanSessions ? {
+      kind: "full",
+      context: "scan.refresh",
+      agentName,
+      sessions: strategyResult.fullScanSessions,
+      meta: buildAgentCacheMeta(agent),
+      saveCache: true,
+      ...searchIndexOptions ? { searchIndexOptions } : {}
+    } : null;
+    if (persistentJob) {
+      const persist = this.searchIndexJobs.enqueue("scan.refresh", [persistentJob]);
+      if (!isInitialized && persistentJob.kind === "full") {
+        await persist;
+      } else {
+        void persist.catch((error) => {
+          appLogger.error("scan.refresh.persist.error", { agent: agentName, error });
+          console.error(`[${agentName}] Session persistence failed:`, error);
+        });
+      }
+    }
+    const persistDuration = performance.now() - persistStartedAt;
+    logSearchIndexSync("scan.refresh", null, { pending_paths: pendingPathCount });
+    this.emitSessionsChanged({ agentName, sessions: nextSessions, event: diff.event });
+    const totalDurationMs = performance.now() - startedAt;
+    state.lastRefreshDurationMs = totalDurationMs;
+    appLogger.info("scan.refresh.done", {
+      agent: agentName,
+      duration_ms: Math.round(totalDurationMs),
+      sessions: nextSessions.length,
+      new_sessions: diff.event?.newSessions ?? 0,
+      updated_sessions: diff.event?.updatedSessions ?? 0,
+      removed_sessions: diff.event?.removedSessions ?? 0,
+      pending_paths: pendingPathCount,
+      availability_ms: Math.round(availabilityDuration),
+      check_ms: Math.round(strategyResult.checkDuration),
+      scan_ms: Math.round(strategyResult.scanDuration),
+      diff_ms: Math.round(diffDuration),
+      persist_ms: Math.round(persistDuration),
+      search_index_ms: 0,
+      persistent_index_worker_job: persistentJob?.kind,
+      persistent_index_skipped: !persistentJob || void 0
+    });
+    return "committed";
+  }
+  refreshUnavailableAgent(agentName) {
+    this.state(agentName).lastRefreshAt = Date.now();
+    return this.refreshStrategyResult([]);
+  }
+  async initializeAgent(agent, previousSessions) {
+    this.setScanPhase("initializing");
+    const scanStartedAt = performance.now();
+    const result = await this.runWorker(agent, previousSessions, null, this.startupScanOptions());
+    agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
+    const sessions = attachMissingProjectIdentities(result.sessions);
+    this.state(agent.name).lastRefreshAt = Date.now();
+    return this.refreshStrategyResult(sessions, {
+      fullScanSessions: sessions,
+      scanDuration: performance.now() - scanStartedAt
+    });
+  }
+  async syncAgentSources(agent, cached, refreshStartedAt) {
+    const scanStartedAt = performance.now();
+    const result = await this.runWorker(agent, cached.sessions, null, this.startupScanOptions(), {
+      sourceSync: true,
+      meta: cached.meta
+    });
+    agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
+    const sessions = attachMissingProjectIdentities(result.sessions);
+    const preciseChangedIds = result.changedIds ?? [];
+    const persistenceDiff = buildRefreshDiff(
+      agent.name,
+      cached.sessions,
+      sessions,
+      preciseChangedIds
+    );
+    this.state(agent.name).lastRefreshAt = Date.now();
+    if (preciseChangedIds.length === 0) this.logUnchangedRefresh(agent.name, refreshStartedAt);
+    return this.refreshStrategyResult(sessions, {
+      preciseChangedIds,
+      usedIncrementalScan: true,
+      persistenceDiff,
+      scanDuration: performance.now() - scanStartedAt
+    });
+  }
+  async refreshChangedAgent(agent, baseline, cacheTimestamp, refreshStartedAt) {
+    const checkStartedAt = performance.now();
+    const checkResult = await Promise.resolve(agent.checkForChanges(cacheTimestamp, baseline));
+    const checkDuration = performance.now() - checkStartedAt;
+    this.state(agent.name).lastRefreshAt = checkResult.timestamp;
+    if (!checkResult.hasChanges) {
+      this.logUnchangedRefresh(agent.name, refreshStartedAt);
+      return this.refreshStrategyResult(baseline, { status: "unchanged", checkDuration });
+    }
+    const preciseChangedIds = checkResult.changedIds ?? null;
+    const scanStartedAt = performance.now();
+    const sessions = attachMissingProjectIdentities(
+      await Promise.resolve(agent.incrementalScan(baseline, checkResult.changedIds ?? []))
+    );
+    return this.refreshStrategyResult(sessions, {
+      preciseChangedIds,
+      usedIncrementalScan: Array.isArray(checkResult.changedIds),
+      persistenceDiff: buildRefreshDiff(agent.name, baseline, sessions, preciseChangedIds ?? []),
+      checkDuration,
+      scanDuration: performance.now() - scanStartedAt
+    });
+  }
+  async scanAgentFully(agent, previousSessions) {
+    const scanStartedAt = performance.now();
+    const result = await this.runWorker(agent, previousSessions, null, {});
+    agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
+    const sessions = attachMissingProjectIdentities(result.sessions);
+    this.state(agent.name).lastRefreshAt = Date.now();
+    return this.refreshStrategyResult(sessions, {
+      fullScanSessions: sessions,
+      scanDuration: performance.now() - scanStartedAt
+    });
+  }
+  refreshStrategyResult(nextSessions, overrides = {}) {
+    return {
+      status: "continue",
+      nextSessions,
+      fullScanSessions: null,
+      preciseChangedIds: null,
+      usedIncrementalScan: false,
+      persistenceDiff: null,
+      checkDuration: 0,
+      scanDuration: 0,
+      ...overrides
+    };
+  }
+  runWorker(agent, previousSessions, changedIds, scanOptions, workerOptions = {}) {
+    return this.options.workerRunner.run(agent.name, {
+      previousSessions,
+      changedIds,
+      scanOptions,
+      sourceSync: workerOptions.sourceSync,
+      meta: workerOptions.meta ?? buildAgentCacheMeta(agent),
+      onProgress: (progress) => this.updateAgentScanProgress(agent.name, progress)
+    });
+  }
+  needsBackfill(agent) {
+    const startupScanOptions = this.startupScanOptions();
+    if (startupScanOptions.from == null && startupScanOptions.to == null) return false;
+    if (!agent.isAvailable()) return false;
+    const lastSyncAt = getAgentLastFullSyncAt(agent.name);
+    return lastSyncAt == null || Date.now() - lastSyncAt > BACKFILL_INTERVAL_MS;
+  }
+  enqueueBackfill(agentName) {
+    if (this.isShuttingDown || this.currentBackfillAgent === agentName || this.backfillQueue.includes(agentName)) {
+      return;
+    }
+    this.backfillQueue.push(agentName);
+    this.publishBackfillStatus();
+    this.pumpBackfillQueue();
+  }
+  pumpBackfillQueue() {
+    if (this.isShuttingDown || this.currentBackfillAgent) return;
+    const agentName = this.backfillQueue.shift();
+    if (!agentName) return;
+    this.currentBackfillAgent = agentName;
+    this.publishBackfillStatus();
+    void this.serialize(agentName, "backfill", () => this.performBackfill(agentName)).then(
+      (result) => {
+        if (this.isShuttingDown) return;
+        this.currentBackfillAgent = void 0;
+        if (result === "committed") {
+          if (!this.completedBackfillAgents.includes(agentName)) {
+            this.completedBackfillAgents.push(agentName);
+          }
+          this.failedBackfillAgents = this.failedBackfillAgents.filter(
+            (failedAgent) => failedAgent !== agentName
+          );
+        } else if (!this.failedBackfillAgents.includes(agentName)) {
+          this.failedBackfillAgents.push(agentName);
+        }
+        this.publishBackfillStatus();
+        this.pumpBackfillQueue();
+      }
+    );
+  }
+  async performBackfill(agentName) {
+    const startedAt = performance.now();
+    const agent = this.findAgent(agentName);
+    if (!agent || !agent.isAvailable()) return "skipped";
+    const snapshot = this.options.snapshot();
+    const cached = loadCachedSessions(agentName);
+    const baseline = cached?.sessions ?? snapshot.byAgent[agentName] ?? [];
+    const meta = cached?.meta ?? buildAgentCacheMeta(agent);
+    if (cached) restoreAgentCacheMeta(agent, cached);
+    try {
+      const result = await this.runWorker(
+        agent,
+        baseline,
+        null,
+        {},
+        {
+          sourceSync: agent instanceof FileSystemSessionSource,
+          meta
+        }
+      );
+      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
+      const fullSessions = attachMissingProjectIdentities(result.sessions);
+      const diff = buildRefreshDiff(
+        agentName,
+        snapshot.byAgent[agentName] ?? [],
+        fullSessions,
+        result.changedIds ?? []
+      );
+      await this.searchIndexJobs.enqueue("scan.backfill", [
+        {
+          kind: "full",
+          context: "scan.backfill",
+          agentName,
+          sessions: fullSessions,
+          meta: buildAgentCacheMeta(agent),
+          saveCache: true
+        }
+      ]);
+      markAgentFullSyncCompleted(agentName);
+      this.emitSessionsChanged({ agentName, sessions: fullSessions, event: diff.event });
+      appLogger.info("scan.backfill.done", {
+        agent: agentName,
+        duration_ms: Math.round(performance.now() - startedAt),
+        sessions: fullSessions.length,
+        changed: result.changedIds?.length ?? 0
+      });
+      return "committed";
+    } catch (error) {
+      appLogger.error("scan.backfill.error", { agent: agentName, error });
+      console.error(`[${agentName}] Backfill failed:`, error);
+      return "failed";
+    }
+  }
+  serialize(agentName, kind, operation) {
+    const previous = this.operationTails.get(agentName) ?? Promise.resolve();
+    const run = previous.then(async () => {
+      if (this.isShuttingDown) return "skipped";
+      const lifecycle = this.beginOperation(agentName, kind);
+      try {
+        const result = await operation();
+        this.completeOperation(lifecycle, result);
+        return result;
+      } catch (error) {
+        this.completeOperation(lifecycle, "failed");
+        throw error;
+      }
+    });
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.operationTails.set(agentName, tail);
+    void tail.finally(() => {
+      if (this.operationTails.get(agentName) === tail) this.operationTails.delete(agentName);
+    });
+    return run;
+  }
+  state(agentName) {
+    const existing = this.refreshStates.get(agentName);
+    if (existing) return existing;
+    const state = {
+      timer: null,
+      timerDeadline: 0,
+      isRunning: false,
+      hasPendingRerun: false,
+      lastRefreshAt: 0,
+      lastRefreshDurationMs: 0,
+      pendingPathCount: 0
+    };
+    this.refreshStates.set(agentName, state);
+    return state;
+  }
+  beginOperation(agentName, kind) {
+    const generation = (this.operationGenerations.get(agentName) ?? 0) + 1;
+    const startedAt = Date.now();
+    this.operationGenerations.set(agentName, generation);
+    appLogger.info("scan.agent_operation.started", {
+      agent: agentName,
+      operation: kind,
+      generation,
+      started_at: startedAt
+    });
+    return { agentName, kind, generation, startedAt };
+  }
+  completeOperation(lifecycle, result) {
+    const completedAt = Date.now();
+    appLogger.info("scan.agent_operation.completed", {
+      agent: lifecycle.agentName,
+      operation: lifecycle.kind,
+      generation: lifecycle.generation,
+      started_at: lifecycle.startedAt,
+      completed_at: completedAt,
+      duration_ms: completedAt - lifecycle.startedAt,
+      result
+    });
+  }
+  backfillStatus() {
+    return {
+      active: this.currentBackfillAgent != null || this.backfillQueue.length > 0,
+      pendingAgents: [...this.backfillQueue],
+      currentAgent: this.currentBackfillAgent,
+      completedAgents: [...this.completedBackfillAgents],
+      failedAgents: [...this.failedBackfillAgents]
+    };
+  }
+  buildFullSearchIndexJobs(context) {
+    const snapshot = this.options.snapshot();
+    return snapshot.agents.map((agent) => {
+      const cached = loadCachedSessions(agent.name);
+      return cached ? {
+        kind: "full",
+        context,
+        agentName: agent.name,
+        sessions: cached.sessions,
+        meta: cached.meta
+      } : {
+        kind: "full",
+        context,
+        agentName: agent.name,
+        sessions: snapshot.byAgent[agent.name] ?? [],
+        meta: buildAgentCacheMeta(agent)
+      };
+    });
+  }
+  findAgent(agentName) {
+    return this.options.snapshot().agents.find((agent) => agent.name === agentName);
+  }
+  startupScanOptions() {
+    return this.options.startupScanOptions ?? {};
+  }
+  logUnchangedRefresh(agentName, startedAt) {
+    appLogger.debug("scan.refresh.unchanged", {
+      agent: agentName,
+      duration_ms: Math.round(performance.now() - startedAt)
+    });
   }
 };
 
@@ -1950,41 +2544,78 @@ var SessionWatcher = class {
   }
 };
 
-// src/live-scan.ts
-var REFRESH_DEBOUNCE_MS = 200;
-var EMPTY_AGENT_REFRESH_DEBOUNCE_MS = 3e4;
-var NEW_SESSION_EVENT_WINDOW_MS = 250;
-var SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD = 100;
-var BACKFILL_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-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 };
+// src/worker-runner.ts
+import { Worker as Worker2 } from "worker_threads";
+var ThreadWorkerRunner = class {
+  constructor(workerUrl) {
+    this.workerUrl = workerUrl;
   }
-  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)));
-}
+  workerUrl;
+  workers = /* @__PURE__ */ new Set();
+  get activeCount() {
+    return this.workers.size;
+  }
+  run(agentName, payload) {
+    return new Promise((resolve4, reject) => {
+      const worker = new Worker2(this.workerUrl, {
+        workerData: {
+          agentName,
+          previousSessions: payload.previousSessions,
+          changedIds: payload.changedIds,
+          sourceSync: payload.sourceSync,
+          scanOptions: payload.scanOptions,
+          meta: payload.meta
+        }
+      });
+      worker.unref();
+      this.workers.add(worker);
+      let settled = false;
+      const finish = (callback, terminate = true) => {
+        if (settled) return;
+        settled = true;
+        this.workers.delete(worker);
+        if (terminate) void worker.terminate();
+        callback();
+      };
+      worker.on("message", (message) => {
+        if (message.type === "progress") {
+          payload.onProgress?.(message.progress);
+          return;
+        }
+        if (message.type === "done") {
+          finish(
+            () => resolve4({
+              sessions: message.sessions,
+              meta: message.meta,
+              changedIds: message.changedIds
+            })
+          );
+          return;
+        }
+        finish(() => reject(new Error(message.error)));
+      });
+      worker.once("error", (error) => {
+        finish(() => reject(error));
+      });
+      worker.once("exit", (code) => {
+        if (settled) return;
+        appLogger.warn("scan.refresh_worker.exit_before_done", { agent: agentName, code });
+        finish(
+          () => reject(new Error(`Scan refresh worker exited before completing (code ${code})`)),
+          false
+        );
+      });
+    });
+  }
+  async shutdown() {
+    const workers = [...this.workers];
+    await Promise.allSettled(workers.map((worker) => worker.terminate()));
+    this.workers.clear();
+  }
+};
+
+// src/live-scan.ts
+var NEW_SESSION_EVENT_WINDOW_MS = 250;
 function mergeEvents(previous, next) {
   const changedSessionHeads = /* @__PURE__ */ new Map();
   const removedSessionRefs = /* @__PURE__ */ new Map();
@@ -2016,138 +2647,99 @@ function mergeEvents(previous, next) {
   };
 }
 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;
+  deferInitialRefresh;
+  syncEngine;
   agents = [];
   byAgent = {};
   sessions = [];
   listeners = /* @__PURE__ */ new Set();
-  scanStatusListeners = /* @__PURE__ */ new Set();
-  scanStatus = new ScanStatusModel();
-  backfills = new BackfillCoordinator();
-  refreshes = new RefreshCoordinator();
   watcher = null;
   pendingEvent = null;
   pendingEventTimer = null;
-  backgroundRefreshTimer = null;
-  scanRefreshWorkers = /* @__PURE__ */ new Set();
-  searchIndexJobs = new SearchIndexJobRunner();
   shutdownPromise = null;
   shuttingDown = false;
+  constructor(options = {}) {
+    this.watchEnabled = options.watchEnabled ?? true;
+    this.scanOptions = options.scanOptions ?? {};
+    this.startupScanOptions = options.startupScanOptions ?? {};
+    this.deferInitialRefresh = options.deferInitialRefresh === true;
+    const workerRunner = options.workerRunner ?? new ThreadWorkerRunner(new URL("./scan-refresh-worker.js", import.meta.url));
+    this.syncEngine = new AgentSyncEngine({
+      snapshot: () => this.getSnapshot(),
+      startupScanOptions: this.startupScanOptions,
+      workerRunner
+    });
+    this.syncEngine.subscribeSessionsChanged((change) => this.applySessionsChanged(change));
+  }
   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
+      deferred: this.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,
+      cacheOnly: this.deferInitialRefresh,
+      writeCache: this.deferInitialRefresh ? false : this.scanOptions.writeCache,
       smartTagWorkerUrl: this.getSmartTagWorkerUrl() ?? void 0,
-      includeSmartTags: deferInitialRefresh ? false : void 0
+      includeSmartTags: this.deferInitialRefresh ? false : void 0
     });
     this.applyScanResult(initialResult);
+    this.syncEngine.initialize(initialResult.cacheTimestamps);
     const indexStartedAt = performance.now();
-    if (!deferInitialRefresh) {
-      await this.searchIndexJobs.enqueue(
-        "scan.initial",
-        this.buildFullSearchIndexJobs("scan.initial")
-      );
-    }
+    if (!this.deferInitialRefresh) await this.syncEngine.syncInitialIndex();
     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,
+      index_ms: this.deferInitialRefresh ? void 0 : Math.round(indexDuration),
+      deferred: this.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]) => [
+        Object.entries(initialResult.timings).map(([name, timing]) => [
           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
+            total_ms: Math.round(timing.total),
+            cache_load_ms: timing.cacheLoad != null ? Math.round(timing.cacheLoad) : void 0,
+            check_changes_ms: timing.checkChanges != null ? Math.round(timing.checkChanges) : void 0,
+            scan_ms: timing.scan != null ? Math.round(timing.scan) : void 0,
+            identity_ms: timing.identity != null ? Math.round(timing.identity) : void 0,
+            tags_ms: timing.tags != null ? Math.round(timing.tags) : void 0
           }
         ])
       ) : void 0
     });
-    if (this.watchEnabled) {
-      this.watcher = new SessionWatcher();
-      this.watcher.onAgentsChanged((agentNames) => {
-        for (const agentName of agentNames) {
-          this.refreshes.recordChangedPaths(agentName);
-          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));
-    }
+    if (!this.watchEnabled) return;
+    this.watcher = new SessionWatcher();
+    this.watcher.onAgentsChanged((agentNames) => this.syncEngine.handleAgentsChanged(agentNames));
+    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();
-      }
-      for (const agent of this.agents) {
-        if (this.needsBackfill(agent)) {
-          this.enqueueBackfill(agent.name);
-        }
-      }
-    }, 0);
+    this.syncEngine.startBackgroundRefresh();
   }
   getSnapshot() {
-    return {
-      sessions: this.sessions,
-      byAgent: this.byAgent,
-      agents: this.agents
-    };
+    return { sessions: this.sessions, byAgent: this.byAgent, agents: this.agents };
   }
   getScanStatus() {
-    return this.scanStatus.snapshot();
+    return this.syncEngine.status();
   }
   subscribe(listener) {
     this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
+    return () => this.listeners.delete(listener);
   }
   subscribeScanStatus(listener) {
-    this.scanStatusListeners.add(listener);
-    return () => {
-      this.scanStatusListeners.delete(listener);
-    };
+    return this.syncEngine.subscribeStatusChanged(listener);
   }
   shutdown() {
     this.shutdownPromise ??= this.performShutdown();
@@ -2155,43 +2747,23 @@ var LiveScanStore = class {
   }
   async performShutdown() {
     this.shuttingDown = true;
-    const activeOperations = {
-      agent_operations: this.refreshes.activeOperationCount,
-      refreshes: this.refreshes.activeRefreshCount,
-      backfill_running: this.backfills.isRunning || void 0,
-      scan_workers: this.scanRefreshWorkers.size
-    };
-    if (activeOperations.agent_operations > 0 || activeOperations.scan_workers > 0) {
-      appLogger.warn("scan.shutdown.active_operations", activeOperations);
-    }
-    const searchIndexSnapshot = this.searchIndexJobs.snapshot();
-    appLogger.info("search_index.shutdown.started", {
-      active_batch_id: searchIndexSnapshot.activeBatchId,
-      pending_batches: searchIndexSnapshot.pendingBatches
-    });
     if (this.pendingEventTimer) {
       clearTimeout(this.pendingEventTimer);
       this.pendingEventTimer = null;
     }
-    if (this.backgroundRefreshTimer) {
-      clearTimeout(this.backgroundRefreshTimer);
-      this.backgroundRefreshTimer = null;
-    }
-    this.backfills.clear();
-    await this.searchIndexJobs.shutdown();
-    const scanWorkers = [...this.scanRefreshWorkers];
-    await Promise.allSettled(scanWorkers.map((scanWorker) => scanWorker.terminate()));
-    await this.refreshes.shutdown();
+    await this.syncEngine.shutdown();
     this.pendingEvent = null;
     if (this.watcher) {
       await this.watcher.dispose();
       this.watcher = null;
     }
-    const stoppedSearchIndexSnapshot = this.searchIndexJobs.snapshot();
-    appLogger.info("search_index.shutdown.completed", {
-      active_batch_id: searchIndexSnapshot.activeBatchId,
-      pending_batches: stoppedSearchIndexSnapshot.pendingBatches
-    });
+  }
+  applySessionsChanged(change) {
+    this.byAgent[change.agentName] = sortSessions(change.sessions);
+    this.rebuildSessions();
+    if (!change.event) return;
+    change.event.totalSessions = this.sessions.length;
+    this.emit(change.event);
   }
   emit(event) {
     if (this.shuttingDown) return;
@@ -2202,147 +2774,16 @@ var LiveScanStore = class {
     this.emitNow(event);
   }
   emitNow(event) {
-    for (const listener of this.listeners) {
-      listener(event);
-    }
-  }
-  startScanBatch(agentNames, phase) {
-    const sessionCounts = Object.fromEntries(
-      agentNames.map((agentName) => [agentName, this.byAgent[agentName]?.length ?? 0])
-    );
-    this.publishScanStatus(this.scanStatus.startBatch(agentNames, phase, sessionCounts));
-  }
-  setScanPhase(phase) {
-    this.publishScanStatus(this.scanStatus.setPhase(phase));
-  }
-  beginAgentScan(agentName) {
-    if (!this.scanStatus.snapshot().active) this.startScanBatch([agentName], "scanning");
-    this.publishScanStatus(
-      this.scanStatus.beginAgent(agentName, this.byAgent[agentName]?.length ?? 0)
-    );
-  }
-  updateAgentScanProgress(agentName, progress) {
-    this.publishScanStatus(this.scanStatus.updateAgent(agentName, progress));
-  }
-  finishAgentScan(agentName) {
-    this.publishScanStatus(this.scanStatus.finishAgent(agentName, this.byAgent[agentName]?.length));
-  }
-  finishScanBatch() {
-    this.publishScanStatus(this.scanStatus.finishBatch());
-  }
-  updateBackfillStatus(patch) {
-    this.publishScanStatus(this.scanStatus.updateBackfill(patch));
-  }
-  publishScanStatus(event) {
-    if (!event || this.shuttingDown) return;
-    for (const listener of this.scanStatusListeners) listener(event);
-  }
-  /**
-   * Only FileSystemSessionSource agents pay the O(history) enumeration cost this
-   * guards against: database agents already do a cheap single-file mtime check.
-   * With no startup window configured, the regular refresh path already walks
-   * full history, so backfill would be redundant.
-   */
-  needsBackfill(agent) {
-    if (this.startupScanOptions.from == null && this.startupScanOptions.to == null) return false;
-    if (!(agent instanceof FileSystemSessionSource)) return false;
-    if (!agent.isAvailable()) return false;
-    const lastSyncAt = getAgentLastFullSyncAt(agent.name);
-    return lastSyncAt == null || Date.now() - lastSyncAt > BACKFILL_INTERVAL_MS;
-  }
-  enqueueBackfill(agentName) {
-    if (this.shuttingDown) return;
-    const status = this.backfills.enqueue(agentName);
-    if (!status) return;
-    this.updateBackfillStatus(status);
-    this.pumpBackfillQueue();
-  }
-  pumpBackfillQueue() {
-    if (this.shuttingDown) return;
-    const work = this.backfills.take();
-    if (!work) return;
-    this.updateBackfillStatus(work.status);
-    void this.runBackfill(work.agentName).finally(() => {
-      if (this.shuttingDown) return;
-      this.updateBackfillStatus(this.backfills.complete(work.agentName));
-      this.pumpBackfillQueue();
-    });
-  }
-  /** Unbounded per-source sync to reconcile the full session history, not just the display window. */
-  async runBackfill(agentName) {
-    await this.refreshes.serialize(agentName, "backfill", () => this.performBackfill(agentName));
-  }
-  async performBackfill(agentName) {
-    const startedAt = performance.now();
-    const agent = this.agents.find((item) => item.name === agentName);
-    if (!agent || !(agent instanceof FileSystemSessionSource) || !agent.isAvailable()) {
-      return "skipped";
-    }
-    const cached = loadCachedSessions(agentName);
-    const baseline = cached?.sessions ?? this.byAgent[agentName] ?? [];
-    const meta = cached?.meta ?? buildAgentCacheMeta(agent);
-    if (cached) {
-      restoreAgentCacheMeta(agent, cached.meta);
-    }
-    try {
-      const result = await this.scanAgentInWorker(
-        agent,
-        baseline,
-        null,
-        {},
-        { sourceSync: true, meta }
-      );
-      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
-      const fullSessions = attachMissingProjectIdentities(result.sessions);
-      const filtered = this.applyFilters(fullSessions);
-      const diff = buildRefreshDiff(
-        agentName,
-        this.byAgent[agentName] ?? [],
-        filtered,
-        result.changedIds ?? []
-      );
-      this.byAgent[agentName] = sortSessions(filtered);
-      this.rebuildSessions();
-      await this.searchIndexJobs.enqueue("scan.backfill", [
-        {
-          kind: "full",
-          context: "scan.backfill",
-          agentName,
-          sessions: fullSessions,
-          meta: buildAgentCacheMeta(agent),
-          saveCache: true
-        }
-      ]);
-      markAgentFullSyncCompleted(agentName);
-      if (diff.event) {
-        diff.event.totalSessions = this.sessions.length;
-        this.emit(diff.event);
-      }
-      appLogger.info("scan.backfill.done", {
-        agent: agentName,
-        duration_ms: Math.round(performance.now() - startedAt),
-        sessions: fullSessions.length,
-        changed: result.changedIds?.length ?? 0
-      });
-      return "committed";
-    } catch (error) {
-      appLogger.error("scan.backfill.error", { agent: agentName, error });
-      console.error(`[${agentName}] Backfill failed:`, error);
-      return "failed";
-    }
+    for (const listener of this.listeners) listener(event);
   }
   queueEvent(event) {
     this.pendingEvent = this.pendingEvent ? mergeEvents(this.pendingEvent, event) : event;
-    if (this.pendingEventTimer) {
-      return;
-    }
+    if (this.pendingEventTimer) return;
     this.pendingEventTimer = setTimeout(() => {
       const pending = this.pendingEvent;
       this.pendingEvent = null;
       this.pendingEventTimer = null;
-      if (pending) {
-        this.emitNow(pending);
-      }
+      if (pending) this.emitNow(pending);
     }, NEW_SESSION_EVENT_WINDOW_MS);
   }
   rebuildSessions() {
@@ -2350,369 +2791,28 @@ var LiveScanStore = class {
   }
   getSmartTagWorkerUrl() {
     const workerUrl = new URL("./smart-tag-worker.js", import.meta.url);
-    if (workerUrl.protocol === "file:" && !existsSync5(fileURLToPath3(workerUrl))) {
-      return null;
-    }
+    if (workerUrl.protocol === "file:" && !existsSync5(fileURLToPath3(workerUrl))) return null;
     return workerUrl;
   }
-  getScanRefreshWorkerUrl() {
-    return new URL("./scan-refresh-worker.js", import.meta.url);
-  }
-  scanAgentInWorker(agent, previousSessions, changedIds, scanOptions, workerOptions = {}) {
-    const workerUrl = this.getScanRefreshWorkerUrl();
-    return new Promise((resolve4, reject) => {
-      const worker = new Worker2(workerUrl, {
-        workerData: {
-          agentName: agent.name,
-          previousSessions,
-          changedIds,
-          sourceSync: workerOptions.sourceSync,
-          scanOptions,
-          meta: workerOptions.meta ?? buildAgentCacheMeta(agent)
-        }
-      });
-      worker.unref();
-      this.scanRefreshWorkers.add(worker);
-      let settled = false;
-      const finish = (callback, terminate = true) => {
-        if (settled) return;
-        settled = true;
-        this.scanRefreshWorkers.delete(worker);
-        if (terminate) void worker.terminate();
-        callback();
-      };
-      worker.on("message", (message) => {
-        if (message.type === "progress") {
-          this.updateAgentScanProgress(agent.name, message.progress);
-          return;
-        }
-        if (message.type === "done") {
-          finish(
-            () => resolve4({
-              sessions: message.sessions,
-              meta: message.meta,
-              changedIds: message.changedIds
-            })
-          );
-          return;
-        }
-        finish(() => reject(new Error(message.error)));
-      });
-      worker.once("error", (error) => {
-        finish(() => reject(error));
-      });
-      worker.once("exit", (code) => {
-        if (!settled) {
-          appLogger.warn("scan.refresh_worker.exit_before_done", {
-            agent: agent.name,
-            code
-          });
-          finish(
-            () => reject(new Error(`Scan refresh worker exited before completing (code ${code})`)),
-            false
-          );
-        }
-      });
-    });
-  }
-  buildFullSearchIndexJobs(context) {
-    return this.agents.map((agent) => {
-      const cached = loadCachedSessions(agent.name);
-      if (cached) {
-        return {
-          kind: "full",
-          context,
-          agentName: agent.name,
-          sessions: cached.sessions,
-          meta: cached.meta
-        };
-      }
-      return {
-        kind: "full",
-        context,
-        agentName: agent.name,
-        sessions: this.byAgent[agent.name] ?? [],
-        meta: buildAgentCacheMeta(agent)
-      };
-    });
-  }
   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.refreshes.setLastRefreshAt(
-        agent.name,
-        result.cacheTimestamps?.[agent.name] ?? Date.now()
-      );
+    for (const agent of result.agents) agentMap.set(agent.name, agent);
+    for (const agent of createRegisteredAgents()) {
+      if (!agentMap.has(agent.name)) agentMap.set(agent.name, agent);
     }
+    this.agents = [...agentMap.values()].filter(
+      (agent) => !allowedAgents || allowedAgents.has(agent.name.toLowerCase())
+    );
+    this.byAgent = Object.fromEntries(
+      this.agents.map((agent) => [agent.name, sortSessions(result.byAgent[agent.name] ?? [])])
+    );
     this.rebuildSessions();
   }
   getAllowedAgents() {
-    if (!this.scanOptions.agents?.length) {
-      return null;
-    }
+    if (!this.scanOptions.agents?.length) return null;
     return new Set(this.scanOptions.agents.map((agent) => agent.toLowerCase()));
   }
-  applyFilters(sessions) {
-    return filterSessions(sessions, { ...this.scanOptions, ...this.startupScanOptions });
-  }
-  async refreshInitialIndex() {
-    const startedAt = performance.now();
-    const context = "scan.initial.background";
-    try {
-      await this.searchIndexJobs.enqueue(context, this.buildFullSearchIndexJobs(context));
-      appLogger.info(`${context}.complete`, {
-        duration_ms: Math.round(performance.now() - startedAt),
-        sessions: this.sessions.length
-      });
-    } catch (error) {
-      if (this.shuttingDown) {
-        return;
-      }
-      appLogger.error(`${context}.error`, { error });
-      console.error("[search] Background index sync failed:", error);
-    }
-  }
-  /**
-   * Throttles rather than debounces: a pending timer only gets replaced by a
-   * request with an earlier deadline. Plain debounce (reset on every call)
-   * would let a steady stream of events — each arriving before the adaptive
-   * backoff elapses — push the deadline out forever and starve the refresh.
-   */
-  scheduleRefresh(agentName, delayMs = REFRESH_DEBOUNCE_MS) {
-    this.refreshes.schedule(agentName, delayMs, () => this.refreshAgent(agentName));
-  }
-  async refreshAgent(agentName) {
-    await this.refreshes.runRefresh(agentName, async () => {
-      this.beginAgentScan(agentName);
-      try {
-        return await this.runRefresh(agentName);
-      } catch (error) {
-        appLogger.error("scan.refresh.error", { agent: agentName, error });
-        console.error(`[${agentName}] Session refresh failed:`, error);
-        return "failed";
-      } finally {
-        this.finishAgentScan(agentName);
-      }
-    });
-  }
-  async runRefresh(agentName) {
-    const startedAt = performance.now();
-    const pendingPathCount = this.refreshes.takePendingPathCount(agentName);
-    const agent = this.agents.find((item) => item.name === agentName);
-    if (!agent) {
-      appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
-      return "skipped";
-    }
-    const previousSessions = this.byAgent[agentName] ?? [];
-    const cached = loadCachedSessions(agentName);
-    const refreshBaseline = cached?.sessions ?? previousSessions;
-    const cacheTimestamp = cached?.timestamp ?? this.refreshes.lastRefreshAt(agentName);
-    if (cached) {
-      restoreAgentCacheMeta(agent, cached.meta);
-    }
-    const isInitialized = isAgentCacheInitialized(agentName);
-    let nextSessions = previousSessions;
-    let fullScanSessions = null;
-    let preciseChangedIds = null;
-    let usedIncrementalScan = false;
-    let persistenceDiff = null;
-    let availabilityDuration = 0;
-    let checkDuration = 0;
-    let scanDuration = 0;
-    let filterDuration = 0;
-    let diffDuration = 0;
-    let persistDuration = 0;
-    let searchIndexDuration = 0;
-    let persistentJobKind;
-    const availabilityStartedAt = performance.now();
-    const isAvailable = agent.isAvailable();
-    availabilityDuration = performance.now() - availabilityStartedAt;
-    if (!isAvailable) {
-      nextSessions = [];
-      this.refreshes.setLastRefreshAt(agentName, Date.now());
-    } else if (!isInitialized) {
-      this.setScanPhase("initializing");
-      const scanStartedAt = performance.now();
-      const result = await this.scanAgentInWorker(
-        agent,
-        previousSessions,
-        null,
-        this.startupScanOptions
-      );
-      nextSessions = result.sessions;
-      agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
-      fullScanSessions = attachMissingProjectIdentities(nextSessions);
-      nextSessions = fullScanSessions;
-      scanDuration = performance.now() - scanStartedAt;
-      this.refreshes.setLastRefreshAt(agentName, Date.now());
-    } else if (cached && agent instanceof FileSystemSessionSource) {
-      const scanStartedAt = performance.now();
-      const result = await this.scanAgentInWorker(
-        agent,
-        cached.sessions,
-        null,
-        this.startupScanOptions,
-        {
-          sourceSync: true,
-          meta: cached.meta
-        }
-      );
-      nextSessions = result.sessions;
-      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
-      preciseChangedIds = result.changedIds ?? [];
-      usedIncrementalScan = true;
-      persistenceDiff = buildRefreshDiff(
-        agentName,
-        cached.sessions,
-        attachMissingProjectIdentities(nextSessions),
-        preciseChangedIds
-      );
-      scanDuration = performance.now() - scanStartedAt;
-      this.refreshes.setLastRefreshAt(agentName, Date.now());
-      if (preciseChangedIds.length === 0) {
-        appLogger.debug("scan.refresh.unchanged", {
-          agent: agentName,
-          duration_ms: Math.round(performance.now() - startedAt)
-        });
-      }
-    } else if (refreshBaseline.length > 0) {
-      const checkStartedAt = performance.now();
-      const checkResult = await Promise.resolve(
-        agent.checkForChanges(cacheTimestamp, refreshBaseline)
-      );
-      checkDuration = performance.now() - checkStartedAt;
-      this.refreshes.setLastRefreshAt(agentName, checkResult.timestamp);
-      if (!checkResult.hasChanges) {
-        appLogger.debug("scan.refresh.unchanged", {
-          agent: agentName,
-          duration_ms: Math.round(performance.now() - startedAt)
-        });
-        return "unchanged";
-      }
-      preciseChangedIds = checkResult.changedIds ?? null;
-      usedIncrementalScan = Array.isArray(checkResult.changedIds);
-      const scanStartedAt = performance.now();
-      nextSessions = await Promise.resolve(
-        agent.incrementalScan(refreshBaseline, checkResult.changedIds ?? [])
-      );
-      const nextBaseline = attachMissingProjectIdentities(nextSessions);
-      persistenceDiff = buildRefreshDiff(
-        agentName,
-        refreshBaseline,
-        nextBaseline,
-        preciseChangedIds ?? []
-      );
-      nextSessions = nextBaseline;
-      scanDuration = performance.now() - scanStartedAt;
-    } else {
-      const scanStartedAt = performance.now();
-      const result = await this.scanAgentInWorker(agent, previousSessions, null, {});
-      nextSessions = result.sessions;
-      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
-      fullScanSessions = attachMissingProjectIdentities(nextSessions);
-      nextSessions = fullScanSessions;
-      scanDuration = performance.now() - scanStartedAt;
-      this.refreshes.setLastRefreshAt(agentName, Date.now());
-    }
-    nextSessions = attachMissingProjectIdentities(nextSessions);
-    const filterStartedAt = performance.now();
-    nextSessions = this.applyFilters(nextSessions);
-    filterDuration = performance.now() - filterStartedAt;
-    const diffStartedAt = performance.now();
-    const diff = buildRefreshDiff(
-      agentName,
-      previousSessions,
-      nextSessions,
-      preciseChangedIds ?? []
-    );
-    diffDuration = performance.now() - diffStartedAt;
-    const searchIndexOptions = pendingPathCount >= SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD ? { isBulk: true } : void 0;
-    const canPersistIncrementally = usedIncrementalScan;
-    const persistentChanges = persistenceDiff?.changedSessions ?? diff.changedSessions;
-    const persistentRemovedSessionIds = persistenceDiff?.removedSessionIds ?? diff.removedSessionIds;
-    const changedSessionIds = canPersistIncrementally ? new Set(persistentChanges.map(({ session }) => session.id)) : void 0;
-    const cacheMeta = buildAgentCacheMeta(agent, changedSessionIds);
-    const persistStartedAt = performance.now();
-    const persistentJob = canPersistIncrementally ? {
-      kind: "changes",
-      context: "scan.refresh",
-      agentName,
-      changes: persistentChanges,
-      removedSessionIds: persistentRemovedSessionIds,
-      meta: cacheMeta,
-      ...searchIndexOptions ? { searchIndexOptions } : {}
-    } : fullScanSessions ? {
-      kind: "full",
-      context: "scan.refresh",
-      agentName,
-      sessions: fullScanSessions,
-      meta: buildAgentCacheMeta(agent),
-      saveCache: true,
-      ...searchIndexOptions ? { searchIndexOptions } : {}
-    } : null;
-    if (persistentJob) {
-      persistentJobKind = persistentJob.kind;
-      const persist = this.searchIndexJobs.enqueue("scan.refresh", [persistentJob]);
-      if (!isInitialized && persistentJob.kind === "full") {
-        await persist;
-      } else {
-        void persist.catch((error) => {
-          appLogger.error("scan.refresh.persist.error", { agent: agentName, error });
-          console.error(`[${agentName}] Session persistence failed:`, error);
-        });
-      }
-    }
-    persistDuration = performance.now() - persistStartedAt;
-    const searchIndexStartedAt = performance.now();
-    searchIndexDuration = performance.now() - searchIndexStartedAt;
-    logSearchIndexSync("scan.refresh", null, { pending_paths: pendingPathCount });
-    const event = diff.event;
-    this.byAgent[agentName] = sortSessions(nextSessions);
-    this.rebuildSessions();
-    if (event) {
-      event.totalSessions = this.sessions.length;
-      this.emit(event);
-    }
-    const totalDurationMs = performance.now() - startedAt;
-    this.refreshes.setLastRefreshDuration(agentName, totalDurationMs);
-    appLogger.info("scan.refresh.done", {
-      agent: agentName,
-      duration_ms: Math.round(totalDurationMs),
-      sessions: nextSessions.length,
-      new_sessions: event?.newSessions ?? 0,
-      updated_sessions: event?.updatedSessions ?? 0,
-      removed_sessions: event?.removedSessions ?? 0,
-      pending_paths: pendingPathCount,
-      availability_ms: Math.round(availabilityDuration),
-      check_ms: Math.round(checkDuration),
-      scan_ms: Math.round(scanDuration),
-      filter_ms: Math.round(filterDuration),
-      diff_ms: Math.round(diffDuration),
-      persist_ms: Math.round(persistDuration),
-      search_index_ms: Math.round(searchIndexDuration),
-      persistent_index_worker_job: persistentJobKind,
-      persistent_index_skipped: !persistentJob || void 0
-    });
-    return "committed";
-  }
 };
 
 // src/output.ts
@@ -2760,13 +2860,6 @@ function hasExplicitPortArg(argv) {
 }
 
 // src/index.ts
-function parseDateToTimestamp(dateStr) {
-  const date = new Date(dateStr);
-  if (Number.isNaN(date.getTime())) {
-    throw new Error(`Invalid date: ${dateStr}`);
-  }
-  return date.getTime();
-}
 function parseSessionUri(uri) {
   const match = uri.match(/^([a-z]+):\/\/(.+)$/i);
   if (!match) return null;
@@ -2892,7 +2985,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-VD54GDPO.js");
+      const { clearCache: clear } = await import("./dist-5356XOFP.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");
@@ -2910,27 +3003,26 @@ var main = defineCommand({
     if (cwdFilter === ".") {
       cwdFilter = process.cwd();
     }
-    let listDefaultFrom;
-    let listDefaultDays;
-    if (args.from) {
-      listDefaultFrom = parseDateToTimestamp(args.from);
-    } else {
-      const days = parseInt(args.days, 10);
-      if (!Number.isNaN(days) && days > 0) {
-        listDefaultFrom = Date.now() - days * 24 * 60 * 60 * 1e3;
-        listDefaultDays = days;
-      } else if (days === 0) {
-        listDefaultDays = 0;
-      }
-    }
-    const listDefaultTo = args.to ? parseDateToTimestamp(args.to) : void 0;
+    const {
+      from: listDefaultFrom,
+      to: listDefaultTo,
+      days: listDefaultDays
+    } = resolveTimeWindow({
+      mode: "cli",
+      from: args.from,
+      to: args.to,
+      days: args.days
+    });
     const scanOptions = {
       agents: targetSession ? [targetSession.agent] : args.agent ? args.agent.split(",").map((a) => a.trim()) : void 0,
       cwd: cwdFilter,
       useCache
     };
     const startupScanOptions = targetSession || jsonOnly ? {} : { from: listDefaultFrom, to: listDefaultTo };
-    const store = new LiveScanStore(!jsonOnly, scanOptions, startupScanOptions, {
+    const store = new LiveScanStore({
+      watchEnabled: !jsonOnly,
+      scanOptions,
+      startupScanOptions,
       deferInitialRefresh: !jsonOnly
     });
     await store.initialize();