codesesh 0.12.0 → 0.14.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
-  BookmarkStorageUnavailableError,
   FileSystemSessionSource,
+  StateStorageUnavailableError,
   attachMissingProjectIdentities,
   buildAgentCacheMeta,
   buildDashboard,
@@ -11,8 +11,9 @@ import {
   createProjectScopeMatcher,
   createRegisteredAgents,
   deleteBookmark,
+  deleteSessionAlias,
+  executeSessionSearch,
   extractSessionFileActivity,
-  filterSessions,
   getAgentInfoMap,
   getAgentLastFullSyncAt,
   getCursorDataPath,
@@ -22,33 +23,36 @@ import {
   getTotalTokens,
   importBookmarks,
   isAgentCacheInitialized,
+  isProjectIdentityKind,
   listBookmarks,
   listCachedProjectGroups,
   listFileActivity,
+  listSessionAliases,
   listSessionFileActivity,
   loadCachedSessionData,
   loadCachedSessions,
   markAgentFullSyncCompleted,
+  matchesProjectIdentity,
   matchesProjectScope,
-  parseSearchQuery,
+  mergeSearchQueryOptions,
   perf,
   realFs,
   refreshPricingCache,
   resolveProviderRoots,
   scanSessions,
-  searchFileActivitySessions,
-  searchSessions,
   sessionSignature,
   sortSessions,
   startOfLocalDay,
-  upsertBookmark
-} from "./chunk-GCOAE7KI.js";
+  upsertBookmark,
+  upsertSessionAlias
+} from "./chunk-VRVZJDNL.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
 
 // src/server.ts
 import { Hono as Hono2 } from "hono";
+import { bodyLimit } from "hono/body-limit";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { existsSync as existsSync2 } from "fs";
@@ -207,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;
 }
@@ -227,7 +355,7 @@ function parseBookmarkPayload(value) {
     title: value.title,
     directory: value.directory,
     time_created: value.time_created,
-    time_updated: value.time_updated,
+    time_updated: value.time_updated ?? void 0,
     stats: value.stats
   };
 }
@@ -265,13 +393,14 @@ function parseSmartTags(values) {
   );
   return tags.length > 0 ? [...new Set(tags)] : void 0;
 }
-function parseSearchOptions(c, defaults) {
+function parseSearchOptions(c, defaults, projectIdentity) {
   const params = searchParams(c);
   const limitValue = parseNumberParam(params.get("limit") ?? void 0);
   return {
     agent: optionalQueryValue(params.get("agent") ?? void 0),
     project: optionalQueryValue(params.get("project") ?? void 0),
-    projectKey: optionalQueryValue(params.get("projectKey") ?? void 0),
+    projectKind: projectIdentity?.kind,
+    projectKey: projectIdentity?.key,
     cwd: optionalQueryValue(params.get("cwd") ?? void 0),
     tags: parseSmartTags(queryValues(params, "tag", "tags", "signal")),
     tools: queryValues(params, "tool", "tools").map((tool) => tool.toLowerCase()),
@@ -286,9 +415,6 @@ function parseSearchOptions(c, defaults) {
     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) => {
@@ -310,49 +436,6 @@ function sanitizeClientLogData(value) {
     })
   );
 }
-function sessionMatchesCostFilter(session, options) {
-  const cost = session.stats.total_cost;
-  if (options.costMin != null) {
-    if (options.costMinExclusive ? cost <= options.costMin : cost < options.costMin) return false;
-  }
-  if (options.costMax != null) {
-    if (options.costMaxExclusive ? cost >= options.costMax : cost > options.costMax) return false;
-  }
-  return true;
-}
-function mergeSearchLists(left, right) {
-  const values = [...left ?? [], ...right ?? []];
-  return values.length > 0 ? [...new Set(values)] : void 0;
-}
-function mergeSearchOptions(options, filters) {
-  return {
-    ...options,
-    agent: options.agent ?? filters.agent,
-    project: options.project ?? filters.project,
-    projectKey: options.projectKey ?? filters.projectKey,
-    cwd: options.cwd ?? filters.cwd,
-    tags: mergeSearchLists(options.tags, filters.tags),
-    tools: mergeSearchLists(options.tools, filters.tools),
-    file: options.file ?? filters.file,
-    fileKind: options.fileKind ?? filters.fileKind,
-    costMin: options.costMin ?? filters.costMin,
-    costMax: options.costMax ?? filters.costMax,
-    costMinExclusive: options.costMinExclusive ?? filters.costMinExclusive,
-    costMaxExclusive: options.costMaxExclusive ?? filters.costMaxExclusive
-  };
-}
-function mergeSearchResults(results, limit) {
-  const seen = /* @__PURE__ */ new Set();
-  const merged = [];
-  for (const result of results) {
-    const key = `${result.agentName}/${result.session.id}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    merged.push(result);
-    if (merged.length >= limit) break;
-  }
-  return merged;
-}
 function getProjectGroupKey(identityKind, identityKey) {
   return `${identityKind}:${identityKey}`;
 }
@@ -408,65 +491,35 @@ function attachProjectMetrics(projects, sessions) {
     };
   });
 }
-function matchesRecentSearchFilters(session, options, projectScope) {
-  if (options.projectKey && session.project_identity?.key !== options.projectKey) return false;
-  if (projectScope && !matchesProjectScope(session, projectScope)) return false;
-  if (options.project) {
-    const projectNeedle = options.project.toLowerCase();
-    const projectText = [
-      session.project_identity?.key,
-      session.project_identity?.displayName,
-      session.directory
-    ].filter(Boolean).join("\n").toLowerCase();
-    if (!projectText.includes(projectNeedle)) return false;
-  }
-  if (options.tags?.length && !options.tags.every((tag) => session.smart_tags?.includes(tag))) {
-    return false;
-  }
-  if (!sessionMatchesCostFilter(session, options)) return false;
-  return true;
-}
-function recentSearchSessions(scanResult, options) {
-  const projectScope = options.cwd ? createProjectScopeMatcher(options.cwd) : null;
-  const entries = options.agent ? [[options.agent, scanResult.byAgent[options.agent] ?? []]] : Object.entries(scanResult.byAgent);
-  return entries.flatMap(
-    ([agentName, sessions]) => filterSessionsByActivityWindow(sessions, options.from, options.to).filter((session) => matchesRecentSearchFilters(session, options, projectScope)).map((session) => ({ agentName, session }))
-  ).toSorted(
-    (a, b) => (b.session.time_updated ?? b.session.time_created) - (a.session.time_updated ?? a.session.time_created)
-  ).slice(0, options.limit).map(({ agentName, session }) => ({
-    agentName,
-    session,
-    snippet: `Recent session \xB7 ${session.directory}`,
-    matchType: "recent"
-  }));
-}
 function handleGetConfig(c, defaults) {
-  return c.json({
+  const payload = {
     window: {
       from: defaults.from,
       to: defaults.to,
       days: defaults.days
     }
-  });
+  };
+  return c.json(payload);
 }
 function handleGetScanStatus(c, scanSource) {
   return c.json(scanSource.getScanStatus());
 }
 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)
@@ -477,7 +530,13 @@ function handleGetSessions(c, scanSource, defaults = {}) {
   const agent = c.req.query("agent");
   const q = c.req.query("q")?.toLowerCase();
   const cwd = c.req.query("cwd");
-  const projectKey = c.req.query("projectKey");
+  const projectIdentity = parseProjectIdentityFilter(
+    c.req.query("projectKind"),
+    c.req.query("projectKey")
+  );
+  if (projectIdentity === null) {
+    return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
+  }
   const tag = c.req.query("tag")?.toLowerCase();
   const from = parseDateParam(c.req.query("from"), defaults.from);
   const to = parseDateParam(c.req.query("to"), defaults.to);
@@ -487,8 +546,10 @@ function handleGetSessions(c, scanSource, defaults = {}) {
   } else {
     sessions = [...scanResult.sessions];
   }
-  if (projectKey) {
-    sessions = sessions.filter((s) => s.project_identity?.key === projectKey);
+  if (projectIdentity) {
+    sessions = sessions.filter(
+      (session) => matchesProjectIdentity(session.project_identity, projectIdentity)
+    );
   } else if (cwd) {
     const projectScope = createProjectScopeMatcher(cwd);
     sessions = sessions.filter((s) => matchesProjectScope(s, projectScope));
@@ -497,38 +558,41 @@ 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() ?? "";
   const scanResult = scanSource.getSnapshot();
-  const searchOptions = parseSearchOptions(c, defaults);
-  const parsedQuery = parseSearchQuery(query);
-  const mergedSearchOptions = mergeSearchOptions(searchOptions, parsedQuery.filters);
-  const textQuery = parsedQuery.text || (parsedQuery.hasQualifiers ? "" : query);
-  const needsIndexedSearch = Boolean(
-    textQuery || mergedSearchOptions.file || mergedSearchOptions.fileKind || mergedSearchOptions.tools?.length
+  const projectIdentity = parseProjectIdentityFilter(
+    c.req.query("projectKind"),
+    c.req.query("projectKey")
   );
-  if (!needsIndexedSearch) {
-    return c.json({
-      results: recentSearchSessions(
-        scanResult,
-        mergedSearchOptions
-      )
-    });
+  if (projectIdentity === null) {
+    return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
+  }
+  const searchOptions = parseSearchOptions(c, defaults, projectIdentity);
+  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);
   }
-  const fileQuery = mergedSearchOptions.file ?? (!parsedQuery.text ? parsedQuery.filters.file : void 0) ?? (!parsedQuery.hasQualifiers && query ? parsedQuery.text || query : "");
-  const results = mergeSearchResults(
-    [
-      ...fileQuery ? searchFileActivitySessions(fileQuery, mergedSearchOptions) : [],
-      ...searchSessions(query, mergedSearchOptions)
-    ],
-    mergedSearchOptions.limit ?? 50
-  );
-  return c.json({ results });
+  return c.json({ results: [...deduped.values()].slice(0, searchOptions.limit ?? 50) });
 }
 function parseFileActivityKind(value) {
   if (value === "read" || value === "edit" || value === "write" || value === "delete") {
@@ -540,14 +604,30 @@ function optionalQueryValue(value) {
   const normalized = value?.trim();
   return normalized ? normalized : void 0;
 }
+function parseProjectIdentityFilter(kindValue, keyValue) {
+  const kind = optionalQueryValue(kindValue);
+  const key = optionalQueryValue(keyValue);
+  if (!kind && !key) return void 0;
+  if (!kind || !key || !isProjectIdentityKind(kind)) return null;
+  return { kind, key };
+}
 function handleGetFileActivity(c, defaults = {}) {
   const limitValue = Number(c.req.query("limit"));
   const limit = Number.isFinite(limitValue) && limitValue > 0 ? Math.min(limitValue, 200) : 50;
+  const projectIdentity = parseProjectIdentityFilter(
+    c.req.query("projectKind"),
+    c.req.query("projectKey")
+  );
+  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")),
       sessionId: optionalQueryValue(c.req.query("sessionId")),
-      projectKey: optionalQueryValue(c.req.query("projectKey")),
+      projectKind: projectIdentity?.kind,
+      projectKey: projectIdentity?.key,
       project: optionalQueryValue(c.req.query("project")),
       cwd: optionalQueryValue(c.req.query("cwd")),
       path: optionalQueryValue(c.req.query("path")),
@@ -555,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) {
@@ -563,6 +643,9 @@ async function handleGetSessionData(c, scanSource) {
   const scanResult = scanSource.getSnapshot();
   const agentName = c.req.param("agent");
   const sessionId = c.req.param("id");
+  if (!agentName) {
+    return c.json({ error: "Missing agent name" }, 400);
+  }
   if (!sessionId) {
     return c.json({ error: "Missing session ID" }, 400);
   }
@@ -599,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),
@@ -629,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;
@@ -645,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;
@@ -663,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;
@@ -679,49 +767,69 @@ 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();
-  const { from, to, days } = resolveDashboardWindow(
-    defaults,
-    c.req.query("days"),
-    c.req.query("from"),
-    c.req.query("to")
+  const projectIdentity = parseProjectIdentityFilter(
+    c.req.query("projectKind"),
+    c.req.query("projectKey")
   );
+  if (projectIdentity === null) {
+    return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
+  }
+  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: optionalQueryValue(c.req.query("projectKind")),
-    projectKey: optionalQueryValue(c.req.query("projectKey"))
+    projectKind: projectIdentity?.kind,
+    projectKey: projectIdentity?.key
   };
   const agentInfo = getAgentInfoMap({});
   const agentInfoMap = new Map(agentInfo.map((a) => [a.name, a]));
@@ -736,6 +844,7 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
     ...aggregate,
     recentFileActivities: listFileActivity({
       agent: scope.agent,
+      projectKind: scope.projectKind,
       projectKey: scope.projectKey,
       from,
       to,
@@ -743,16 +852,29 @@ 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 = () => {
+  };
   return new Response(
     new ReadableStream({
       start(controller) {
+        let isClosed = false;
         const write = (event, data) => {
+          if (isClosed) return;
           controller.enqueue(encoder.encode(`event: ${event}
 `));
           controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
@@ -760,26 +882,36 @@ 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(() => {
-          controller.enqueue(encoder.encode(": keepalive\n\n"));
+          if (!isClosed) controller.enqueue(encoder.encode(": keepalive\n\n"));
         }, 15e3);
-        const close = () => {
+        const cleanup = () => {
+          if (isClosed) return false;
+          isClosed = true;
           clearInterval(heartbeat);
           unsubscribeSessions();
           unsubscribeScanStatus();
-          controller.close();
+          signal.removeEventListener("abort", abortStream);
+          return true;
+        };
+        const abortStream = () => {
+          if (cleanup()) controller.close();
+        };
+        cancelStream = () => {
+          cleanup();
         };
-        signal.addEventListener("abort", close, { once: true });
+        if (signal.aborted) abortStream();
+        else signal.addEventListener("abort", abortStream, { once: true });
       },
       cancel() {
-        return;
+        cancelStream();
       }
     }),
     {
@@ -791,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,
@@ -799,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));
@@ -813,14 +945,55 @@ 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;
 }
 
+// src/remote-access.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+import { isIP } from "net";
+var REMOTE_ACCESS_QUERY_PARAM = "access_token";
+function createRemoteAccessToken() {
+  return randomBytes(32).toString("base64url");
+}
+function isLoopbackHostname(hostname) {
+  const normalized = hostname.toLowerCase().replace(/^\[(.*)\]$/, "$1");
+  if (normalized === "localhost" || normalized === "::1") return true;
+  return isIP(normalized) === 4 && normalized.startsWith("127.");
+}
+function tokenMatches(actual, expected) {
+  if (!actual) return false;
+  const actualBuffer = Buffer.from(actual);
+  const expectedBuffer = Buffer.from(expected);
+  return actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer);
+}
+function bearerToken(c) {
+  const authorization = c.req.header("Authorization");
+  if (!authorization?.startsWith("Bearer ")) return void 0;
+  return authorization.slice("Bearer ".length);
+}
+function requestToken(c) {
+  const bearer = bearerToken(c);
+  if (bearer) return bearer;
+  if (c.req.method !== "GET") return void 0;
+  return c.req.query(REMOTE_ACCESS_QUERY_PARAM);
+}
+function remoteAccessAuth(expectedToken) {
+  return async (c, next) => {
+    if (!tokenMatches(requestToken(c), expectedToken)) {
+      return c.json({ error: "Remote access authentication required" }, 401);
+    }
+    await next();
+  };
+}
+
 // src/server.ts
+var MAX_API_REQUEST_BYTES = 1024 * 1024;
 function findWebDistPath() {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
   const packagedPath = resolve(__dirname2, "web");
@@ -862,6 +1035,14 @@ function getListeningPort(server, fallback) {
 }
 async function createServer(port, store, options = {}) {
   const app = new Hono2();
+  const hostname = options.hostname ?? "127.0.0.1";
+  const isLoopback = isLoopbackHostname(hostname);
+  const remoteAccessToken = !isLoopback ? options.remoteAccessToken ?? (options.remoteAccess ? createRemoteAccessToken() : null) : null;
+  if (!isLoopback && !remoteAccessToken) {
+    throw new Error(
+      `Refusing to expose CodeSesh on ${hostname} without authentication. Add --remote-access to continue.`
+    );
+  }
   app.use("*", async (c, next) => {
     const startedAt = performance.now();
     let thrown;
@@ -882,26 +1063,28 @@ async function createServer(port, store, options = {}) {
       });
     }
   });
+  if (remoteAccessToken) {
+    app.use("/api/*", remoteAccessAuth(remoteAccessToken));
+  }
+  app.use(
+    "/api/*",
+    bodyLimit({
+      maxSize: MAX_API_REQUEST_BYTES,
+      onError: (c) => c.json({ error: "Request body too large" }, 413)
+    })
+  );
   const routeOptions = {
     defaultSessionFrom: options.defaultSessionFrom,
     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 }));
     app.get("/*", serveStatic({ root: webDistPath, path: "index.html" }));
   }
   const attempts = Math.max(1, options.portFallbackAttempts ?? 1);
-  const hostname = options.hostname ?? "127.0.0.1";
   let server = null;
   let actualPort = port;
   for (let offset = 0; offset < attempts; offset += 1) {
@@ -917,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`
@@ -928,16 +1109,19 @@ async function createServer(port, store, options = {}) {
       throw new Error(getServerStartupErrorMessage(error, candidatePort));
     }
   }
-  const isLoopback = hostname === "127.0.0.1" || hostname === "localhost";
-  const url = isLoopback ? `http://localhost:${actualPort}` : `http://${hostname}:${actualPort}`;
-  appLogger.info("server.listen", { port: actualPort, requested_port: port, hostname, url });
+  const baseUrl = isLoopback ? `http://localhost:${actualPort}` : `http://${hostname}:${actualPort}`;
+  const url = remoteAccessToken ? `${baseUrl}/?${REMOTE_ACCESS_QUERY_PARAM}=${encodeURIComponent(remoteAccessToken)}` : baseUrl;
+  appLogger.info("server.listen", {
+    port: actualPort,
+    requested_port: port,
+    hostname,
+    remote_access: Boolean(remoteAccessToken)
+  });
   if (!isLoopback) {
-    appLogger.warn("server.listen.exposed", { hostname, port: actualPort });
-    console.warn(
-      `
-\u26A0 \u670D\u52A1\u76D1\u542C ${hostname}\uFF0C\u5C40\u57DF\u7F51\u5185\u5176\u4ED6\u8BBE\u5907\u53EF\u8BFB\u53D6\u4F60\u7684\u5168\u90E8 AI \u4F1A\u8BDD\u8BB0\u5F55\uFF08\u65E0\u9274\u6743\uFF09\u3002
-`
-    );
+    appLogger.warn("server.listen.remote_access", { hostname, port: actualPort });
+    console.warn(`
+\u26A0 \u8FDC\u7A0B\u8BBF\u95EE\u5DF2\u542F\u7528\u3002\u4EFB\u4F55\u6301\u6709\u542F\u52A8 URL \u7684\u4EBA\u90FD\u53EF\u4EE5\u8BFB\u53D6\u4F60\u7684 AI \u4F1A\u8BDD\u8BB0\u5F55\u3002
+`);
   }
   return {
     url,
@@ -950,148 +1134,1228 @@ async function createServer(port, store, options = {}) {
         }
         server.close(() => resolve4());
       });
-      if (store.shutdown) {
-        await store.shutdown();
-      }
+      await store.shutdown();
     }
   };
 }
 
 // src/live-scan.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/search-index-job-runner.ts
+import { existsSync as existsSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Worker } from "worker_threads";
 
-// 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;
-function toAbsolutePath(path) {
-  return isAbsolute(path) ? path : resolve2(path);
-}
-function closestWatchablePath(targetPath) {
-  if (!isAbsolute(targetPath) && !existsSync3(targetPath)) {
-    return null;
+// src/pending-search-index-jobs.ts
+var PendingSearchIndexJobBatch = class {
+  constructor(id, context, jobs, waiter) {
+    this.id = id;
+    this.context = context;
+    this.merge(context, jobs, waiter);
+  }
+  id;
+  context;
+  jobsByAgent = /* @__PURE__ */ new Map();
+  waiters = [];
+  settled = false;
+  get jobs() {
+    const jobs = [];
+    for (const pending of this.jobsByAgent.values()) {
+      if (pending.full) jobs.push(pending.full);
+      if (pending.changes) jobs.push(changesJobFromPending(pending.changes));
+    }
+    return jobs;
+  }
+  get changeCount() {
+    let count = 0;
+    for (const pending of this.jobsByAgent.values()) {
+      if (!pending.changes) continue;
+      count += pending.changes.changesBySessionId.size + pending.changes.removedSessionIds.size;
+    }
+    return count;
+  }
+  merge(context, jobs, waiter) {
+    this.context = context;
+    this.waiters.push(waiter);
+    for (const job of jobs) this.mergeJob(job);
+  }
+  settle(error) {
+    if (this.settled) return false;
+    this.settled = true;
+    for (const waiter of this.waiters) {
+      if (error) waiter.reject(error);
+      else waiter.resolve();
+    }
+    this.waiters.length = 0;
+    return true;
   }
-  let current = toAbsolutePath(targetPath);
-  while (!existsSync3(current)) {
-    const parent = dirname2(current);
-    if (parent === current) {
-      return null;
+  mergeJob(job) {
+    const pending = this.jobsByAgent.get(job.agentName) ?? {};
+    this.jobsByAgent.set(job.agentName, pending);
+    if (job.kind === "full") {
+      pending.full = job;
+      pending.changes = void 0;
+      return;
     }
-    current = parent;
+    pending.changes ??= createPendingChanges(job);
+    mergeChanges(pending.changes, job);
   }
-  return current;
-}
-function getWatchRoot(path) {
-  const stat = statSync2(path);
-  return stat.isDirectory() ? path : dirname2(path);
-}
-function isRecursiveWatchSupported(platform = process.platform, nodeVersion = process.versions.node) {
-  if (platform === "darwin" || platform === "win32") {
-    return true;
+};
+var PendingSearchIndexJobs = class {
+  pendingBatch = null;
+  get batchCount() {
+    return this.pendingBatch ? 1 : 0;
   }
-  if (platform !== "linux" && platform !== "aix" && platform !== "ibmi") {
-    return false;
+  get jobCount() {
+    return this.pendingBatch?.jobs.length ?? 0;
   }
-  const [major = 0, minor = 0] = nodeVersion.split(".").map((part) => Number(part));
-  return major > 19 || major === 19 && minor >= 1;
+  get changeCount() {
+    return this.pendingBatch?.changeCount ?? 0;
+  }
+  enqueue(id, context, jobs) {
+    if (jobs.length === 0) return Promise.resolve();
+    return new Promise((resolve4, reject) => {
+      const waiter = { resolve: resolve4, reject };
+      if (this.pendingBatch) {
+        this.pendingBatch.merge(context, jobs, waiter);
+      } else {
+        this.pendingBatch = new PendingSearchIndexJobBatch(id, context, jobs, waiter);
+      }
+    });
+  }
+  take() {
+    const batch = this.pendingBatch;
+    this.pendingBatch = null;
+    return batch;
+  }
+  settle(batch, error) {
+    return batch instanceof PendingSearchIndexJobBatch && batch.settle(error);
+  }
+  rejectAll(error) {
+    const batch = this.take();
+    if (batch) this.settle(batch, error);
+  }
+};
+function createPendingChanges(job) {
+  return {
+    context: job.context,
+    agentName: job.agentName,
+    changesBySessionId: /* @__PURE__ */ new Map(),
+    removedSessionIds: /* @__PURE__ */ new Set(),
+    meta: {},
+    searchIndexOptions: job.searchIndexOptions
+  };
 }
-function isRecursiveWatchUnavailable(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+function mergeChanges(pending, job) {
+  pending.context = job.context;
+  pending.searchIndexOptions = mergeSearchIndexOptions(
+    pending.searchIndexOptions,
+    job.searchIndexOptions
+  );
+  for (const sessionId of job.removedSessionIds) {
+    pending.changesBySessionId.delete(sessionId);
+    pending.removedSessionIds.add(sessionId);
+    delete pending.meta[sessionId];
+  }
+  for (const change of job.changes) {
+    const sessionId = change.session.id;
+    pending.removedSessionIds.delete(sessionId);
+    pending.changesBySessionId.set(sessionId, change);
+    if (Object.hasOwn(job.meta, sessionId)) pending.meta[sessionId] = job.meta[sessionId];
+    else delete pending.meta[sessionId];
+  }
+  for (const [sessionId, meta] of Object.entries(job.meta)) {
+    if (!pending.removedSessionIds.has(sessionId)) pending.meta[sessionId] = meta;
+  }
 }
-function isSameOrChildPath(parentPath, childPath) {
-  const path = relative(parentPath, childPath);
-  return path === "" || !path.startsWith("..") && !isAbsolute(path);
+function mergeSearchIndexOptions(current, incoming) {
+  if (!current) return incoming;
+  if (!incoming) return current;
+  return { ...current, ...incoming };
 }
-function isRelatedPath(changedPath, targetPath) {
-  return isSameOrChildPath(targetPath, changedPath) || isSameOrChildPath(changedPath, targetPath);
+function changesJobFromPending(pending) {
+  return {
+    kind: "changes",
+    context: pending.context,
+    agentName: pending.agentName,
+    changes: [...pending.changesBySessionId.values()],
+    removedSessionIds: [...pending.removedSessionIds],
+    meta: pending.meta,
+    ...pending.searchIndexOptions ? { searchIndexOptions: pending.searchIndexOptions } : {}
+  };
 }
-function mergeScopes(target, scopes) {
-  for (const scope of scopes) {
-    if (!target.some(
-      (item) => item.agentName === scope.agentName && item.targetPath === scope.targetPath
-    )) {
-      target.push(scope);
+
+// src/search-index-job-runner.ts
+var SHUTDOWN_ERROR_MESSAGE = "Live scan store shut down";
+var SearchIndexJobRunner = class {
+  worker = null;
+  activeBatch = null;
+  nextBatchId = 1;
+  pendingJobs = new PendingSearchIndexJobs();
+  isShuttingDown = false;
+  hasCheckedFtsIntegrity = false;
+  enqueue(context, jobs) {
+    if (jobs.length === 0) return Promise.resolve();
+    if (this.isShuttingDown) return Promise.reject(new Error(SHUTDOWN_ERROR_MESSAGE));
+    const batchId = this.nextBatchId++;
+    const completion = this.pendingJobs.enqueue(batchId, context, jobs);
+    if (this.worker) {
+      const snapshot = this.snapshot();
+      appLogger.debug("search_index.worker_queued", {
+        batch_id: batchId,
+        context,
+        jobs: jobs.length,
+        pending_batches: snapshot.pendingBatches,
+        pending_jobs: snapshot.pendingJobs,
+        pending_changes: snapshot.pendingChanges
+      });
+    } else {
+      this.startNextBatch();
     }
+    return completion;
   }
-}
-function resolveWatchEventPath(watchPath, filename) {
-  const filenameText = filename?.toString();
-  if (!filenameText) {
-    return watchPath;
-  }
-  return isAbsolute(filenameText) ? filenameText : join2(watchPath, filenameText);
-}
-function resolveAgentWatchTargets(agentName) {
-  const roots = resolveProviderRoots();
-  const cursorDataPath = getCursorDataPath();
-  switch (agentName) {
-    case "claudecode":
-      return [
-        { root: roots.claudeRoot, path: join2(roots.claudeRoot, "projects") },
-        { path: "data/claudecode" }
-      ];
-    case "codex":
-      return [
-        { path: join2(roots.codexRoot, "sessions") },
-        { path: join2(roots.codexRoot, "session_index.jsonl") }
-      ];
-    case "pi":
-      return [
-        { root: roots.piRoot, path: join2(roots.piRoot, "agent", "sessions") },
-        { root: "data/pi", path: "data/pi" }
-      ];
-    case "cursor":
-      return cursorDataPath ? [
-        {
-          root: cursorDataPath,
-          path: join2(cursorDataPath, "globalStorage", "state.vscdb")
-        },
-        { root: cursorDataPath, path: join2(cursorDataPath, "workspaceStorage") }
-      ] : [];
-    case "kimi":
-      return [
-        { root: roots.kimiRoot, path: join2(roots.kimiRoot, "sessions") },
-        { path: "data/kimi" }
-      ];
-    case "opencode":
-      return [
-        { root: roots.opencodeRoot, path: join2(roots.opencodeRoot, "opencode.db") },
-        { root: "data/opencode", path: "data/opencode/opencode.db" }
-      ];
-    case "zcode":
-      return roots.zcodeRoot ? [{ root: roots.zcodeRoot, path: join2(roots.zcodeRoot, "cli", "db", "db.sqlite") }] : [];
-    default:
-      return [];
-  }
-}
-var SessionWatcher = class {
-  watchers = [];
-  fallbackWatchScopes = /* @__PURE__ */ new Map();
-  stablePaths = /* @__PURE__ */ new Map();
-  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.listeners.delete(cb);
+  snapshot() {
+    return {
+      activeBatchId: this.activeBatch?.id,
+      pendingBatches: this.pendingJobs.batchCount,
+      pendingJobs: this.pendingJobs.jobCount,
+      pendingChanges: this.pendingJobs.changeCount
     };
   }
-  /** 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;
+  async shutdown() {
+    this.isShuttingDown = true;
+    const activeBatch = this.activeBatch;
+    const worker = this.worker;
+    this.activeBatch = null;
+    this.worker = null;
+    const shutdownError = new Error(SHUTDOWN_ERROR_MESSAGE);
+    if (activeBatch) this.settle(activeBatch, shutdownError);
+    this.pendingJobs.rejectAll(shutdownError);
+    if (worker) await worker.terminate();
+  }
+  startNextBatch() {
+    if (this.isShuttingDown || this.worker) return;
+    const batch = this.pendingJobs.take();
+    if (!batch) return;
+    appLogger.info("search_index.worker_dequeued", {
+      batch_id: batch.id,
+      context: batch.context,
+      pending_batches: this.pendingJobs.batchCount
+    });
+    this.startBatch(batch);
+  }
+  startBatch(batch) {
+    if (this.isShuttingDown) {
+      this.settle(batch, new Error(SHUTDOWN_ERROR_MESSAGE));
+      return;
+    }
+    const workerUrl = this.workerUrl();
+    if (!workerUrl) {
+      appLogger.warn("search_index.worker_missing", { context: batch.context });
+      this.settle(batch);
+      return;
+    }
+    appLogger.info("search_index.worker_started", {
+      batch_id: batch.id,
+      context: batch.context,
+      jobs: batch.jobs.length
+    });
+    const worker = new Worker(workerUrl, {
+      workerData: {
+        context: batch.context,
+        jobs: batch.jobs,
+        agentNames: [],
+        sessionsByAgent: {},
+        metaByAgent: {},
+        skipFtsIntegrityCheck: this.hasCheckedFtsIntegrity
+      }
+    });
+    worker.unref();
+    this.worker = worker;
+    this.activeBatch = batch;
+    worker.on("message", (message) => {
+      if (message.type === "sync-result") {
+        logSearchIndexSync(message.context, message.result);
+        return;
+      }
+      if (message.type !== "done") return;
+      appLogger.info(`${message.context}.done`, {
+        duration_ms: Math.round(message.durationMs),
+        sessions: message.sessions
+      });
+      this.hasCheckedFtsIntegrity = true;
+      this.settle(batch);
+    });
+    worker.on("error", (error) => {
+      appLogger.error("search_index.worker_error", { context: batch.context, error });
+      this.settle(batch, error);
+    });
+    worker.on("exit", (code) => this.finishWorker(worker, batch, code));
+  }
+  finishWorker(worker, batch, code) {
+    appLogger.info("search_index.worker_exited", {
+      batch_id: batch.id,
+      context: batch.context,
+      code,
+      shutting_down: this.isShuttingDown || void 0
+    });
+    if (this.worker === worker) this.worker = null;
+    if (this.activeBatch === batch) this.activeBatch = null;
+    const error = code === 0 ? new Error("Search index worker exited before completing its batch") : new Error(`Search index worker exited with code ${code}`);
+    if (code !== 0) appLogger.warn("search_index.worker_exit", { context: batch.context, code });
+    this.settle(batch, error);
+    this.startNextBatch();
+  }
+  settle(batch, error) {
+    if (!this.pendingJobs.settle(batch, error)) return;
+    appLogger.info("search_index.worker_settled", {
+      batch_id: batch.id,
+      context: batch.context,
+      result: error ? "rejected" : "resolved"
+    });
+  }
+  workerUrl() {
+    const workerUrl = new URL("./search-index-worker.js", import.meta.url);
+    if (workerUrl.protocol === "file:" && !existsSync3(fileURLToPath2(workerUrl))) return null;
+    return workerUrl;
+  }
+};
+
+// src/scan-status-model.ts
+var ScanStatusModel = class {
+  status = {
+    active: false,
+    phase: "idle",
+    pendingAgents: [],
+    scanningAgents: [],
+    completedAgents: [],
+    agentStatuses: {},
+    totalAgents: 0,
+    updatedAt: Date.now(),
+    backfill: { active: false, pendingAgents: [], completedAgents: [], failedAgents: [] }
+  };
+  snapshot() {
+    return {
+      type: "scan-status",
+      ...this.status,
+      pendingAgents: [...this.status.pendingAgents],
+      scanningAgents: [...this.status.scanningAgents],
+      completedAgents: [...this.status.completedAgents],
+      agentStatuses: Object.fromEntries(
+        Object.entries(this.status.agentStatuses).map(([agentName, status]) => [
+          agentName,
+          { ...status }
+        ])
+      ),
+      backfill: {
+        ...this.status.backfill,
+        pendingAgents: [...this.status.backfill.pendingAgents],
+        completedAgents: [...this.status.backfill.completedAgents],
+        failedAgents: [...this.status.backfill.failedAgents]
+      }
+    };
+  }
+  startBatch(agentNames, phase, sessionCounts) {
+    const uniqueAgentNames = [...new Set(agentNames)];
+    const now = Date.now();
+    const agentStatuses = Object.fromEntries(
+      uniqueAgentNames.map((agentName) => [
+        agentName,
+        {
+          agentName,
+          status: "pending",
+          processed: 0,
+          sessions: sessionCounts[agentName] ?? 0,
+          updatedAt: now
+        }
+      ])
+    );
+    return this.set({
+      ...this.status,
+      active: uniqueAgentNames.length > 0,
+      phase: uniqueAgentNames.length > 0 ? phase : "idle",
+      pendingAgents: uniqueAgentNames,
+      scanningAgents: [],
+      completedAgents: [],
+      agentStatuses,
+      totalAgents: uniqueAgentNames.length,
+      startedAt: uniqueAgentNames.length > 0 ? now : void 0,
+      updatedAt: now,
+      completedAt: uniqueAgentNames.length > 0 ? void 0 : now
+    });
+  }
+  setPhase(phase) {
+    if (!this.status.active) return null;
+    return this.set({ ...this.status, phase, updatedAt: Date.now() });
+  }
+  beginAgent(agentName, sessionCount) {
+    if (!this.status.active)
+      this.startBatch([agentName], "scanning", { [agentName]: sessionCount });
+    const pendingAgents = this.status.pendingAgents.filter((agent) => agent !== agentName);
+    const scanningAgents = [.../* @__PURE__ */ new Set([...this.status.scanningAgents, agentName])];
+    const completedAgents = this.status.completedAgents.filter((agent) => agent !== agentName);
+    const existingStatus = this.status.agentStatuses[agentName];
+    const now = Date.now();
+    return this.set({
+      ...this.status,
+      active: true,
+      phase: this.status.phase === "initializing" ? "initializing" : "scanning",
+      pendingAgents,
+      scanningAgents,
+      completedAgents,
+      agentStatuses: {
+        ...this.status.agentStatuses,
+        [agentName]: {
+          agentName,
+          status: "scanning",
+          total: existingStatus?.total,
+          processed: existingStatus?.processed ?? 0,
+          sessions: existingStatus?.sessions ?? sessionCount,
+          startedAt: existingStatus?.startedAt ?? now,
+          updatedAt: now
+        }
+      },
+      totalAgents: Math.max(this.status.totalAgents, pendingAgents.length + scanningAgents.length),
+      updatedAt: now,
+      completedAt: void 0
+    });
+  }
+  updateAgent(agentName, progress) {
+    const status = this.status.agentStatuses[agentName];
+    if (!status || status.status !== "scanning") return null;
+    const now = Date.now();
+    return this.set({
+      ...this.status,
+      agentStatuses: {
+        ...this.status.agentStatuses,
+        [agentName]: {
+          ...status,
+          total: progress.total ?? status.total,
+          processed: progress.processed ?? status.processed,
+          sessions: progress.sessions ?? status.sessions,
+          updatedAt: now
+        }
+      },
+      updatedAt: now
+    });
+  }
+  finishAgent(agentName, sessionCount) {
+    const pendingAgents = this.status.pendingAgents.filter((agent) => agent !== agentName);
+    const scanningAgents = this.status.scanningAgents.filter((agent) => agent !== agentName);
+    const completedAgents = [.../* @__PURE__ */ new Set([...this.status.completedAgents, agentName])];
+    const isActive = pendingAgents.length > 0 || scanningAgents.length > 0;
+    const now = Date.now();
+    const previousStatus = this.status.agentStatuses[agentName];
+    const total = previousStatus?.total ?? previousStatus?.processed;
+    return this.set({
+      ...this.status,
+      active: isActive,
+      phase: isActive ? "scanning" : "idle",
+      pendingAgents,
+      scanningAgents,
+      completedAgents,
+      agentStatuses: {
+        ...this.status.agentStatuses,
+        [agentName]: {
+          agentName,
+          status: "complete",
+          total,
+          processed: total,
+          sessions: sessionCount ?? previousStatus?.sessions ?? 0,
+          startedAt: previousStatus?.startedAt,
+          updatedAt: now,
+          completedAt: now
+        }
+      },
+      updatedAt: now,
+      completedAt: isActive ? void 0 : now
+    });
+  }
+  finishBatch() {
+    const now = Date.now();
+    return this.set({
+      ...this.status,
+      active: false,
+      phase: "idle",
+      pendingAgents: [],
+      scanningAgents: [],
+      agentStatuses: Object.fromEntries(
+        Object.entries(this.status.agentStatuses).map(([agentName, status]) => [
+          agentName,
+          { ...status, status: "complete", completedAt: status.completedAt ?? now, updatedAt: now }
+        ])
+      ),
+      updatedAt: now,
+      completedAt: now
+    });
+  }
+  updateBackfill(patch) {
+    return this.set({
+      ...this.status,
+      backfill: { ...this.status.backfill, ...patch },
+      updatedAt: Date.now()
+    });
+  }
+  set(status) {
+    this.status = status;
+    return this.snapshot();
+  }
+};
+
+// 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 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;
+  initialize(cacheTimestamps = {}) {
+    for (const agent of this.options.snapshot().agents) {
+      this.state(agent.name).lastRefreshAt = cacheTimestamps[agent.name] ?? Date.now();
+    }
+  }
+  status() {
+    return this.scanStatus.snapshot();
+  }
+  subscribeSessionsChanged(listener) {
+    this.sessionsChangedListeners.add(listener);
+    return () => this.sessionsChangedListeners.delete(listener);
+  }
+  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());
+  }
+  publishBackfillStatus() {
+    this.publishStatus(this.scanStatus.updateBackfill(this.backfillStatus()));
+  }
+  publishStatus(event) {
+    if (!event || this.isShuttingDown) return;
+    for (const listener of this.statusChangedListeners) listener(event);
+  }
+  emitSessionsChanged(change) {
+    if (this.isShuttingDown) return;
+    for (const listener of this.sessionsChangedListeners) listener(change);
+  }
+  scheduleRefresh(agentName, delayMs) {
+    if (this.isShuttingDown) return;
+    const state = this.state(agentName);
+    const adaptiveDelayMs = Math.min(
+      state.lastRefreshDurationMs * ADAPTIVE_REFRESH_DELAY_MULTIPLIER,
+      MAX_ADAPTIVE_REFRESH_DELAY_MS
+    );
+    const effectiveDelayMs = Math.max(delayMs, adaptiveDelayMs);
+    const deadline = Date.now() + effectiveDelayMs;
+    if (state.timer) {
+      if (deadline >= state.timerDeadline) return;
+      clearTimeout(state.timer);
+    }
+    appLogger.debug("scan.refresh.schedule", { agent: agentName, delay_ms: effectiveDelayMs });
+    state.timerDeadline = deadline;
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      void this.runCoalescedRefresh(agentName);
+    }, effectiveDelayMs);
+  }
+  async runCoalescedRefresh(agentName) {
+    const state = this.state(agentName);
+    if (state.isRunning) {
+      appLogger.debug("scan.refresh.pending", { agent: agentName });
+      state.hasPendingRerun = true;
+      return;
+    }
+    state.isRunning = true;
+    try {
+      await this.serialize(agentName, "refresh", () => this.performRefresh(agentName));
+    } finally {
+      state.isRunning = false;
+      if (state.hasPendingRerun && !this.isShuttingDown) {
+        state.hasPendingRerun = false;
+        this.scheduleRefresh(agentName, PENDING_REFRESH_DELAY_MS);
+      }
+    }
+  }
+  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);
+    }
+  }
+  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)
+    });
+  }
+};
+
+// src/session-watcher.ts
+import { existsSync as existsSync4, 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;
+function toAbsolutePath(path) {
+  return isAbsolute(path) ? path : resolve2(path);
+}
+function closestWatchablePath(targetPath) {
+  if (!isAbsolute(targetPath) && !existsSync4(targetPath)) {
+    return null;
+  }
+  let current = toAbsolutePath(targetPath);
+  while (!existsSync4(current)) {
+    const parent = dirname2(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+  return current;
+}
+function getWatchRoot(path) {
+  const stat = statSync2(path);
+  return stat.isDirectory() ? path : dirname2(path);
+}
+function isRecursiveWatchSupported(platform = process.platform, nodeVersion = process.versions.node) {
+  if (platform === "darwin" || platform === "win32") {
+    return true;
+  }
+  if (platform !== "linux" && platform !== "aix" && platform !== "ibmi") {
+    return false;
+  }
+  const [major = 0, minor = 0] = nodeVersion.split(".").map((part) => Number(part));
+  return major > 19 || major === 19 && minor >= 1;
+}
+function isRecursiveWatchUnavailable(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+}
+function isSameOrChildPath(parentPath, childPath) {
+  const path = relative(parentPath, childPath);
+  return path === "" || !path.startsWith("..") && !isAbsolute(path);
+}
+function isRelatedPath(changedPath, targetPath) {
+  return isSameOrChildPath(targetPath, changedPath) || isSameOrChildPath(changedPath, targetPath);
+}
+function mergeScopes(target, scopes) {
+  for (const scope of scopes) {
+    if (!target.some(
+      (item) => item.agentName === scope.agentName && item.targetPath === scope.targetPath
+    )) {
+      target.push(scope);
+    }
+  }
+}
+function resolveWatchEventPath(watchPath, filename) {
+  const filenameText = filename?.toString();
+  if (!filenameText) {
+    return watchPath;
+  }
+  return isAbsolute(filenameText) ? filenameText : join2(watchPath, filenameText);
+}
+function resolveAgentWatchTargets(agentName) {
+  const roots = resolveProviderRoots();
+  const cursorDataPath = getCursorDataPath();
+  switch (agentName) {
+    case "claudecode":
+      return [
+        { root: roots.claudeRoot, path: join2(roots.claudeRoot, "projects") },
+        { path: "data/claudecode" }
+      ];
+    case "codex":
+      return [
+        { path: join2(roots.codexRoot, "sessions") },
+        { path: join2(roots.codexRoot, "session_index.jsonl") }
+      ];
+    case "pi":
+      return [
+        { root: roots.piRoot, path: join2(roots.piRoot, "agent", "sessions") },
+        { root: "data/pi", path: "data/pi" }
+      ];
+    case "cursor":
+      return cursorDataPath ? [
+        {
+          root: cursorDataPath,
+          path: join2(cursorDataPath, "globalStorage", "state.vscdb")
+        },
+        { root: cursorDataPath, path: join2(cursorDataPath, "workspaceStorage") }
+      ] : [];
+    case "kimi":
+      return [
+        { root: roots.kimiRoot, path: join2(roots.kimiRoot, "sessions") },
+        { path: "data/kimi" }
+      ];
+    case "opencode":
+      return [
+        { root: roots.opencodeRoot, path: join2(roots.opencodeRoot, "opencode.db") },
+        { root: "data/opencode", path: "data/opencode/opencode.db" }
+      ];
+    case "zcode":
+      return roots.zcodeRoot ? [{ root: roots.zcodeRoot, path: join2(roots.zcodeRoot, "cli", "db", "db.sqlite") }] : [];
+    default:
+      return [];
+  }
+}
+var SessionWatcher = class {
+  watchers = [];
+  fallbackWatchScopes = /* @__PURE__ */ new Map();
+  stablePaths = /* @__PURE__ */ new Map();
+  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.listeners.delete(cb);
+    };
+  }
+  /** 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) {
@@ -1280,44 +2544,78 @@ var SessionWatcher = class {
   }
 };
 
-// src/live-scan.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 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;
+  }
+  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
+        );
+      });
+    });
   }
-  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)));
-}
+  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();
@@ -1349,957 +2647,172 @@ 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 = {
-    active: false,
-    phase: "idle",
-    pendingAgents: [],
-    scanningAgents: [],
-    completedAgents: [],
-    agentStatuses: {},
-    totalAgents: 0,
-    updatedAt: Date.now(),
-    backfill: { active: false, pendingAgents: [], completedAgents: [] }
-  };
-  backfillQueue = [];
-  backfillRunning = false;
-  refreshStates = /* @__PURE__ */ new Map();
   watcher = null;
   pendingEvent = null;
   pendingEventTimer = null;
-  backgroundRefreshTimer = null;
-  searchIndexWorker = null;
-  pendingSearchIndexJobs = [];
+  shutdownPromise = null;
   shuttingDown = false;
-  /** Set once a search-index worker in this process has completed the FTS integrity check. */
-  ftsIntegrityChecked = false;
-  getRefreshState(agentName) {
-    let state = this.refreshStates.get(agentName);
-    if (!state) {
-      state = {
-        timer: null,
-        timerDeadline: 0,
-        inFlight: false,
-        pendingRerun: false,
-        lastRefreshAt: 0,
-        lastRefreshDurationMs: 0,
-        pendingPathCount: 0
-      };
-      this.refreshStates.set(agentName, state);
-    }
-    return state;
+  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.enqueueSearchIndexJobs(
-        "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.getRefreshState(agentName).pendingPathCount += 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));
-    }
+    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 {
-      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 }
-        ])
-      ),
-      backfill: {
-        ...this.scanStatus.backfill,
-        pendingAgents: [...this.scanStatus.backfill.pendingAgents],
-        completedAgents: [...this.scanStatus.backfill.completedAgents]
-      }
-    };
+    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);
   }
-  async shutdown() {
+  shutdown() {
+    this.shutdownPromise ??= this.performShutdown();
+    return this.shutdownPromise;
+  }
+  async performShutdown() {
     this.shuttingDown = true;
-    for (const state of this.refreshStates.values()) {
-      if (state.timer) {
-        clearTimeout(state.timer);
-        state.timer = null;
-        state.timerDeadline = 0;
-      }
-    }
     if (this.pendingEventTimer) {
       clearTimeout(this.pendingEventTimer);
       this.pendingEventTimer = null;
     }
-    if (this.backgroundRefreshTimer) {
-      clearTimeout(this.backgroundRefreshTimer);
-      this.backgroundRefreshTimer = null;
-    }
-    if (this.searchIndexWorker) {
-      await this.searchIndexWorker.terminate();
-      this.searchIndexWorker = null;
-    }
-    for (const batch of this.pendingSearchIndexJobs) {
-      batch.reject(new Error("Live scan store shut down"));
-    }
-    this.pendingSearchIndexJobs = [];
+    await this.syncEngine.shutdown();
     this.pendingEvent = null;
     if (this.watcher) {
       await this.watcher.dispose();
       this.watcher = null;
     }
   }
-  emit(event) {
-    if (this.pendingEvent || event.newSessions > 0) {
-      this.queueEvent(event);
-      return;
-    }
-    this.emitNow(event);
-  }
-  emitNow(event) {
-    for (const listener of this.listeners) {
-      listener(event);
-    }
-  }
-  emitScanStatus() {
-    const event = this.getScanStatus();
-    for (const listener of this.scanStatusListeners) {
-      listener(event);
-    }
-  }
-  updateScanStatus(next) {
-    this.scanStatus = next;
-    this.emitScanStatus();
-  }
-  startScanBatch(agentNames, phase) {
-    const uniqueAgentNames = [...new Set(agentNames)];
-    const now = Date.now();
-    const agentStatuses = Object.fromEntries(
-      uniqueAgentNames.map((agentName) => [
-        agentName,
-        {
-          agentName,
-          status: "pending",
-          processed: 0,
-          sessions: this.byAgent[agentName]?.length ?? 0,
-          updatedAt: now
-        }
-      ])
-    );
-    this.updateScanStatus({
-      ...this.scanStatus,
-      active: uniqueAgentNames.length > 0,
-      phase: uniqueAgentNames.length > 0 ? phase : "idle",
-      pendingAgents: uniqueAgentNames,
-      scanningAgents: [],
-      completedAgents: [],
-      agentStatuses,
-      totalAgents: uniqueAgentNames.length,
-      startedAt: uniqueAgentNames.length > 0 ? now : void 0,
-      updatedAt: now,
-      completedAt: uniqueAgentNames.length > 0 ? void 0 : now
-    });
-  }
-  setScanPhase(phase) {
-    if (!this.scanStatus.active) return;
-    this.updateScanStatus({
-      ...this.scanStatus,
-      phase,
-      updatedAt: Date.now()
-    });
-  }
-  beginAgentScan(agentName) {
-    if (!this.scanStatus.active) {
-      this.startScanBatch([agentName], "scanning");
-    }
-    const pendingAgents = this.scanStatus.pendingAgents.filter((agent) => agent !== agentName);
-    const scanningAgents = [.../* @__PURE__ */ new Set([...this.scanStatus.scanningAgents, agentName])];
-    const completedAgents = this.scanStatus.completedAgents.filter((agent) => agent !== agentName);
-    const existingStatus = this.scanStatus.agentStatuses[agentName];
-    const agentStatuses = {
-      ...this.scanStatus.agentStatuses,
-      [agentName]: {
-        agentName,
-        status: "scanning",
-        total: existingStatus?.total,
-        processed: existingStatus?.processed ?? 0,
-        sessions: existingStatus?.sessions ?? this.byAgent[agentName]?.length ?? 0,
-        startedAt: existingStatus?.startedAt ?? Date.now(),
-        updatedAt: Date.now()
-      }
-    };
-    this.updateScanStatus({
-      ...this.scanStatus,
-      active: true,
-      phase: this.scanStatus.phase === "initializing" ? "initializing" : "scanning",
-      pendingAgents,
-      scanningAgents,
-      completedAgents,
-      agentStatuses,
-      totalAgents: Math.max(
-        this.scanStatus.totalAgents,
-        pendingAgents.length + scanningAgents.length
-      ),
-      updatedAt: Date.now(),
-      completedAt: void 0
-    });
-  }
-  updateAgentScanProgress(agentName, progress) {
-    const status = this.scanStatus.agentStatuses[agentName];
-    if (!status || status.status !== "scanning") return;
-    this.updateScanStatus({
-      ...this.scanStatus,
-      agentStatuses: {
-        ...this.scanStatus.agentStatuses,
-        [agentName]: {
-          ...status,
-          total: progress.total ?? status.total,
-          processed: progress.processed ?? status.processed,
-          sessions: progress.sessions ?? status.sessions,
-          updatedAt: Date.now()
-        }
-      },
-      updatedAt: Date.now()
-    });
-  }
-  finishAgentScan(agentName) {
-    const pendingAgents = this.scanStatus.pendingAgents.filter((agent) => agent !== agentName);
-    const scanningAgents = this.scanStatus.scanningAgents.filter((agent) => agent !== agentName);
-    const completedAgents = [.../* @__PURE__ */ new Set([...this.scanStatus.completedAgents, agentName])];
-    const active = pendingAgents.length > 0 || scanningAgents.length > 0;
-    const now = Date.now();
-    const previousStatus = this.scanStatus.agentStatuses[agentName];
-    const sessions = this.byAgent[agentName]?.length ?? previousStatus?.sessions ?? 0;
-    const total = previousStatus?.total ?? previousStatus?.processed;
-    this.updateScanStatus({
-      ...this.scanStatus,
-      active,
-      phase: active ? "scanning" : "idle",
-      pendingAgents,
-      scanningAgents,
-      completedAgents,
-      agentStatuses: {
-        ...this.scanStatus.agentStatuses,
-        [agentName]: {
-          agentName,
-          status: "complete",
-          total,
-          processed: total,
-          sessions,
-          startedAt: previousStatus?.startedAt,
-          updatedAt: now,
-          completedAt: now
-        }
-      },
-      updatedAt: now,
-      completedAt: active ? void 0 : now
-    });
-  }
-  finishScanBatch() {
-    const now = Date.now();
-    this.updateScanStatus({
-      ...this.scanStatus,
-      active: false,
-      phase: "idle",
-      pendingAgents: [],
-      scanningAgents: [],
-      agentStatuses: Object.fromEntries(
-        Object.entries(this.scanStatus.agentStatuses).map(([agentName, status]) => [
-          agentName,
-          { ...status, status: "complete", completedAt: status.completedAt ?? now, updatedAt: now }
-        ])
-      ),
-      updatedAt: now,
-      completedAt: now
-    });
-  }
-  updateBackfillStatus(patch) {
-    this.updateScanStatus({
-      ...this.scanStatus,
-      backfill: { ...this.scanStatus.backfill, ...patch },
-      updatedAt: Date.now()
-    });
-  }
-  /**
-   * 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.backfillQueue.includes(agentName) || this.scanStatus.backfill.currentAgent === agentName) {
-      return;
-    }
-    this.backfillQueue.push(agentName);
-    this.updateBackfillStatus({ active: true, pendingAgents: [...this.backfillQueue] });
-    this.pumpBackfillQueue();
-  }
-  pumpBackfillQueue() {
-    if (this.backfillRunning) return;
-    const agentName = this.backfillQueue.shift();
-    if (!agentName) return;
-    this.backfillRunning = true;
-    this.updateBackfillStatus({ currentAgent: agentName, pendingAgents: [...this.backfillQueue] });
-    void this.runBackfill(agentName).finally(() => {
-      this.backfillRunning = false;
-      this.updateBackfillStatus({
-        currentAgent: void 0,
-        completedAgents: [.../* @__PURE__ */ new Set([...this.scanStatus.backfill.completedAgents, agentName])],
-        active: this.backfillQueue.length > 0
-      });
-      this.pumpBackfillQueue();
-    });
+  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);
   }
-  /** Unbounded per-source sync to reconcile the full session history, not just the display window. */
-  async runBackfill(agentName) {
-    const startedAt = performance.now();
-    const agent = this.agents.find((item) => item.name === agentName);
-    if (!agent || !(agent instanceof FileSystemSessionSource) || !agent.isAvailable()) {
-      return;
-    }
-    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.enqueueSearchIndexJobs("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
-      });
-    } catch (error) {
-      appLogger.error("scan.backfill.error", { agent: agentName, error });
-      console.error(`[${agentName}] Backfill failed:`, error);
+  emit(event) {
+    if (this.shuttingDown) return;
+    if (this.pendingEvent || event.newSessions > 0) {
+      this.queueEvent(event);
+      return;
     }
+    this.emitNow(event);
+  }
+  emitNow(event) {
+    for (const listener of this.listeners) listener(event);
   }
   queueEvent(event) {
     this.pendingEvent = this.pendingEvent ? mergeEvents(this.pendingEvent, event) : event;
-    if (this.pendingEventTimer) {
-      return;
-    }
+    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() {
     this.sessions = sortSessions(Object.values(this.byAgent).flat());
   }
-  getSearchIndexWorkerUrl() {
-    const workerUrl = new URL("./search-index-worker.js", import.meta.url);
-    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:" && !existsSync4(fileURLToPath2(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 Worker(workerUrl, {
-        workerData: {
-          agentName: agent.name,
-          previousSessions,
-          changedIds,
-          sourceSync: workerOptions.sourceSync,
-          scanOptions,
-          meta: workerOptions.meta ?? buildAgentCacheMeta(agent)
-        }
-      });
-      worker.unref();
-      let settled = false;
-      const finish = (callback) => {
-        if (settled) return;
-        settled = true;
-        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 && code !== 0) {
-          finish(() => reject(new Error(`Scan refresh worker exited with code ${code}`)));
-        }
-      });
-    });
-  }
-  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)
-      };
-    });
-  }
-  enqueueSearchIndexJobs(context, jobs) {
-    if (jobs.length === 0) return Promise.resolve();
-    return new Promise((resolve4, reject) => {
-      const batch = { context, jobs, resolve: resolve4, reject };
-      if (this.searchIndexWorker) {
-        this.pendingSearchIndexJobs.push(batch);
-        appLogger.debug("search_index.worker_queued", {
-          context,
-          jobs: jobs.length,
-          pending_jobs: this.pendingSearchIndexJobs.length
-        });
-        return;
-      }
-      this.startSearchIndexJobBatch(batch);
-    });
-  }
-  startSearchIndexJobBatch(batch) {
-    const workerUrl = this.getSearchIndexWorkerUrl();
-    if (!workerUrl) {
-      appLogger.warn("search_index.worker_missing", { context: batch.context });
-      batch.resolve();
-      return;
-    }
-    let settled = false;
-    const worker = new Worker(workerUrl, {
-      workerData: {
-        context: batch.context,
-        jobs: batch.jobs,
-        agentNames: [],
-        sessionsByAgent: {},
-        metaByAgent: {},
-        skipFtsIntegrityCheck: this.ftsIntegrityChecked
-      }
-    });
-    worker.unref();
-    this.searchIndexWorker = worker;
-    worker.on("message", (message) => {
-      if (message.type === "sync-result") {
-        logSearchIndexSync(message.context, message.result);
-      } else if (message.type === "done") {
-        appLogger.info(`${message.context}.done`, {
-          duration_ms: Math.round(message.durationMs),
-          sessions: message.sessions
-        });
-        settled = true;
-        this.ftsIntegrityChecked = true;
-        batch.resolve();
-      }
-    });
-    worker.on("error", (error) => {
-      appLogger.error("search_index.worker_error", { context: batch.context, error });
-      if (!settled) {
-        settled = true;
-        batch.reject(error);
-      }
-    });
-    worker.on("exit", (code) => {
-      this.searchIndexWorker = null;
-      if (code !== 0) {
-        appLogger.warn("search_index.worker_exit", { context: batch.context, code });
-        if (!settled) {
-          settled = true;
-          batch.reject(new Error(`Search index worker exited with code ${code}`));
-        }
-      }
-      if (this.pendingSearchIndexJobs.length > 0) {
-        const pendingBatch = this.pendingSearchIndexJobs.shift();
-        this.startSearchIndexJobBatch(pendingBatch);
-      }
-    });
-  }
   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.getRefreshState(agent.name).lastRefreshAt = 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.enqueueSearchIndexJobs(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) {
-    const state = this.getRefreshState(agentName);
-    const adaptiveDelayMs = Math.min(
-      state.lastRefreshDurationMs * ADAPTIVE_REFRESH_DELAY_MULTIPLIER,
-      MAX_ADAPTIVE_REFRESH_DELAY_MS
-    );
-    const effectiveDelayMs = Math.max(delayMs, adaptiveDelayMs);
-    const deadline = Date.now() + effectiveDelayMs;
-    if (state.timer !== null) {
-      if (deadline >= state.timerDeadline) {
-        return;
-      }
-      clearTimeout(state.timer);
-    }
-    appLogger.debug("scan.refresh.schedule", { agent: agentName, delay_ms: effectiveDelayMs });
-    state.timerDeadline = deadline;
-    state.timer = setTimeout(() => {
-      state.timer = null;
-      void this.refreshAgent(agentName);
-    }, effectiveDelayMs);
-  }
-  async refreshAgent(agentName) {
-    const state = this.getRefreshState(agentName);
-    if (state.inFlight) {
-      appLogger.debug("scan.refresh.pending", { agent: agentName });
-      state.pendingRerun = true;
-      return;
-    }
-    state.inFlight = true;
-    this.beginAgentScan(agentName);
-    try {
-      await this.runRefresh(agentName);
-    } catch (error) {
-      appLogger.error("scan.refresh.error", { agent: agentName, error });
-      console.error(`[${agentName}] Session refresh failed:`, error);
-    } finally {
-      state.inFlight = false;
-      this.finishAgentScan(agentName);
-      if (state.pendingRerun) {
-        state.pendingRerun = false;
-        this.scheduleRefresh(agentName, PENDING_REFRESH_DELAY_MS);
-      }
-    }
-  }
-  async runRefresh(agentName) {
-    const startedAt = performance.now();
-    const state = this.getRefreshState(agentName);
-    const pendingPathCount = state.pendingPathCount;
-    state.pendingPathCount = 0;
-    const agent = this.agents.find((item) => item.name === agentName);
-    if (!agent) {
-      appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
-      return;
-    }
-    const previousSessions = this.byAgent[agentName] ?? [];
-    const cached = loadCachedSessions(agentName);
-    const refreshBaseline = cached?.sessions ?? previousSessions;
-    const cacheTimestamp = cached?.timestamp ?? state.lastRefreshAt;
-    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 = [];
-      state.lastRefreshAt = 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;
-      state.lastRefreshAt = 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;
-      state.lastRefreshAt = 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;
-      state.lastRefreshAt = checkResult.timestamp;
-      if (!checkResult.hasChanges) {
-        appLogger.debug("scan.refresh.unchanged", {
-          agent: agentName,
-          duration_ms: Math.round(performance.now() - startedAt)
-        });
-        return;
-      }
-      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;
-      state.lastRefreshAt = 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.enqueueSearchIndexJobs("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;
-    state.lastRefreshDurationMs = 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
-    });
-  }
 };
 
 // src/output.ts
@@ -2308,8 +2821,8 @@ import { consola } from "consola";
 // src/version.ts
 import { readFileSync } from "fs";
 import { resolve as resolve3, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname = dirname3(fileURLToPath3(import.meta.url));
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __dirname = dirname3(fileURLToPath4(import.meta.url));
 var pkg = JSON.parse(readFileSync(resolve3(__dirname, "../package.json"), "utf-8"));
 var VERSION = pkg.version;
 
@@ -2347,18 +2860,23 @@ 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;
   return { agent: match[1], sessionId: match[2] };
 }
+function appendStartupPath(startupUrl, path) {
+  const url = new URL(startupUrl);
+  url.pathname = path;
+  return url.toString();
+}
+function redactStartupUrl(startupUrl) {
+  const url = new URL(startupUrl);
+  for (const key of url.searchParams.keys()) {
+    url.searchParams.set(key, "[redacted]");
+  }
+  return url.toString();
+}
 var main = defineCommand({
   meta: {
     name: "codesesh",
@@ -2377,6 +2895,11 @@ var main = defineCommand({
       description: "HTTP server bind address (default 127.0.0.1, local access only)",
       default: "127.0.0.1"
     },
+    "remote-access": {
+      type: "boolean",
+      description: "Allow authenticated access when binding to a non-loopback address",
+      default: false
+    },
     agent: {
       type: "string",
       alias: "a",
@@ -2441,6 +2964,14 @@ var main = defineCommand({
     const trace = args.trace;
     const useCache = args.cache;
     const clearCache = args["clear-cache"];
+    const hostname = args.host;
+    const remoteAccess = args["remote-access"];
+    if (!isLoopbackHostname(hostname) && !remoteAccess) {
+      console.error(
+        `Refusing to expose CodeSesh on ${hostname} without authentication. Add --remote-access to continue.`
+      );
+      process.exit(1);
+    }
     if (trace) {
       perf.enable();
     }
@@ -2454,7 +2985,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-TZTL6VP4.js");
+      const { clearCache: clear } = await import("./dist-C3KC3XKJ.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");
@@ -2472,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();
@@ -2544,7 +3074,8 @@ var main = defineCommand({
         defaultSessionTo: listDefaultTo,
         defaultSessionDays: listDefaultDays,
         portFallbackAttempts: explicitPort ? 1 : DEFAULT_PORT_FALLBACK_ATTEMPTS,
-        hostname: args.host
+        hostname,
+        remoteAccess
       });
     } catch (error) {
       console.error(getServerStartupErrorMessage(error, port));
@@ -2571,14 +3102,14 @@ var main = defineCommand({
     console.log(`  ${url}`);
     console.log("");
     appLogger.info("cli.ready", {
-      url,
+      url: redactStartupUrl(url),
       duration_ms: Math.round(performance.now() - startedAt),
       log_path: appLogger.getLogPath()
     });
     if (!noOpen) {
       const open = (await import("open")).default;
-      const targetUrl = targetSession ? `${url}/${targetSession.agent.toLowerCase()}/${targetSession.sessionId}` : url;
-      appLogger.info("browser.open", { url: targetUrl });
+      const targetUrl = targetSession ? appendStartupPath(url, `/${targetSession.agent.toLowerCase()}/${targetSession.sessionId}`) : url;
+      appLogger.info("browser.open", { url: redactStartupUrl(targetUrl) });
       await open(targetUrl);
     }
   }