codesesh 0.11.0 → 0.13.0

package/dist/index.js

@@ -11,9 +11,11 @@ import {
   createProjectScopeMatcher,
   createRegisteredAgents,
   deleteBookmark,
+  executeSessionSearch,
   extractSessionFileActivity,
   filterSessions,
   getAgentInfoMap,
+  getAgentLastFullSyncAt,
   getCursorDataPath,
   getSessionActivityTime,
   getSessionAgentName,
@@ -21,32 +23,33 @@ import {
   getTotalTokens,
   importBookmarks,
   isAgentCacheInitialized,
+  isProjectIdentityKind,
   listBookmarks,
   listCachedProjectGroups,
   listFileActivity,
   listSessionFileActivity,
   loadCachedSessionData,
   loadCachedSessions,
+  markAgentFullSyncCompleted,
+  matchesProjectIdentity,
   matchesProjectScope,
-  parseSearchQuery,
   perf,
   realFs,
   refreshPricingCache,
   resolveProviderRoots,
   scanSessions,
-  searchFileActivitySessions,
-  searchSessions,
   sessionSignature,
   sortSessions,
   startOfLocalDay,
   upsertBookmark
-} from "./chunk-BIXOP5QX.js";
+} from "./chunk-BV65IEWZ.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";
@@ -225,7 +228,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
   };
 }
@@ -263,13 +266,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()),
@@ -308,49 +312,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}`;
 }
@@ -406,46 +367,15 @@ 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());
@@ -475,7 +405,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);
@@ -485,8 +421,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));
@@ -503,29 +441,15 @@ function handleGetSessions(c, scanSource, defaults = {}) {
 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 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
-  );
+  const searchOptions = parseSearchOptions(c, defaults, projectIdentity);
+  const results = executeSessionSearch(query, searchOptions, scanResult);
   return c.json({ results });
 }
 function parseFileActivityKind(value) {
@@ -538,14 +462,29 @@ 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);
+  }
   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")),
@@ -561,6 +500,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);
   }
@@ -710,6 +652,13 @@ function resolveDashboardWindow(defaults, queryDays, queryFrom, queryTo) {
 }
 function handleGetDashboard(c, scanSource, defaults = {}) {
   const scanResult = scanSource.getSnapshot();
+  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 } = resolveDashboardWindow(
     defaults,
     c.req.query("days"),
@@ -718,8 +667,8 @@ function handleGetDashboard(c, scanSource, 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]));
@@ -734,6 +683,7 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
     ...aggregate,
     recentFileActivities: listFileActivity({
       agent: scope.agent,
+      projectKind: scope.projectKind,
       projectKey: scope.projectKey,
       from,
       to,
@@ -747,10 +697,14 @@ function handleGetDashboard(c, scanSource, defaults = {}) {
 // src/api/routes.ts
 function createSseResponse(store, 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)}
@@ -766,18 +720,28 @@ function createSseResponse(store, signal) {
           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();
       }
     }),
     {
@@ -818,7 +782,46 @@ function createApiRoutes(scanSource, store, options = {}) {
   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");
@@ -860,6 +863,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;
@@ -880,6 +891,16 @@ 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,
@@ -903,7 +924,7 @@ async function createServer(port, store, options = {}) {
   let actualPort = port;
   for (let offset = 0; offset < attempts; offset += 1) {
     const candidatePort = port + offset;
-    server = serve({ fetch: app.fetch, port: candidatePort });
+    server = serve({ fetch: app.fetch, port: candidatePort, hostname });
     try {
       await waitForListening(server);
       actualPort = getListeningPort(server, candidatePort);
@@ -925,8 +946,20 @@ async function createServer(port, store, options = {}) {
       throw new Error(getServerStartupErrorMessage(error, candidatePort));
     }
   }
-  const url = `http://localhost:${actualPort}`;
-  appLogger.info("server.listen", { port: actualPort, requested_port: port, 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.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,
     shutdown: async () => {
@@ -946,12 +979,661 @@ async function createServer(port, store, options = {}) {
 }
 
 // src/live-scan.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { Worker as Worker2 } from "worker_threads";
+
+// src/search-index-job-runner.ts
+import { existsSync as existsSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Worker } from "worker_threads";
 
+// 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;
+  }
+  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;
+    }
+    pending.changes ??= createPendingChanges(job);
+    mergeChanges(pending.changes, job);
+  }
+};
+var PendingSearchIndexJobs = class {
+  pendingBatch = null;
+  get batchCount() {
+    return this.pendingBatch ? 1 : 0;
+  }
+  get jobCount() {
+    return this.pendingBatch?.jobs.length ?? 0;
+  }
+  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 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 mergeSearchIndexOptions(current, incoming) {
+  if (!current) return incoming;
+  if (!incoming) return current;
+  return { ...current, ...incoming };
+}
+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 } : {}
+  };
+}
+
+// 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;
+  }
+  snapshot() {
+    return {
+      activeBatchId: this.activeBatch?.id,
+      pendingBatches: this.pendingJobs.batchCount,
+      pendingJobs: this.pendingJobs.jobCount,
+      pendingChanges: this.pendingJobs.changeCount
+    };
+  }
+  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: [] }
+  };
+  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]
+      }
+    };
+  }
+  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/backfill-coordinator.ts
+var BackfillCoordinator = class {
+  queue = [];
+  currentAgent;
+  completedAgents = [];
+  get isRunning() {
+    return this.currentAgent != null;
+  }
+  enqueue(agentName) {
+    if (this.currentAgent === agentName || this.queue.includes(agentName)) return null;
+    this.queue.push(agentName);
+    return this.snapshot();
+  }
+  take() {
+    if (this.currentAgent) return null;
+    const agentName = this.queue.shift();
+    if (!agentName) return null;
+    this.currentAgent = agentName;
+    return { agentName, status: this.snapshot() };
+  }
+  complete(agentName) {
+    if (this.currentAgent === agentName) this.currentAgent = void 0;
+    if (!this.completedAgents.includes(agentName)) this.completedAgents.push(agentName);
+    return this.snapshot();
+  }
+  clear() {
+    this.queue.length = 0;
+    this.currentAgent = void 0;
+  }
+  snapshot() {
+    return {
+      active: this.currentAgent != null || this.queue.length > 0,
+      pendingAgents: [...this.queue],
+      currentAgent: this.currentAgent,
+      completedAgents: [...this.completedAgents]
+    };
+  }
+};
+
+// src/refresh-coordinator.ts
+var PENDING_REFRESH_DELAY_MS = 100;
+var MAX_ADAPTIVE_REFRESH_DELAY_MS = 3e4;
+var ADAPTIVE_REFRESH_DELAY_MULTIPLIER = 4;
+var RefreshCoordinator = class {
+  states = /* @__PURE__ */ new Map();
+  operationGenerations = /* @__PURE__ */ new Map();
+  operationTails = /* @__PURE__ */ new Map();
+  isShuttingDown = false;
+  get activeOperationCount() {
+    return this.operationTails.size;
+  }
+  get activeRefreshCount() {
+    return [...this.states.values()].filter((state) => state.isRunning).length;
+  }
+  recordChangedPaths(agentName, count = 1) {
+    this.state(agentName).pendingPathCount += count;
+  }
+  takePendingPathCount(agentName) {
+    const state = this.state(agentName);
+    const count = state.pendingPathCount;
+    state.pendingPathCount = 0;
+    return count;
+  }
+  lastRefreshAt(agentName) {
+    return this.state(agentName).lastRefreshAt;
+  }
+  setLastRefreshAt(agentName, timestamp) {
+    this.state(agentName).lastRefreshAt = timestamp;
+  }
+  setLastRefreshDuration(agentName, durationMs) {
+    this.state(agentName).lastRefreshDurationMs = durationMs;
+  }
+  schedule(agentName, delayMs, refresh) {
+    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 refresh();
+    }, effectiveDelayMs);
+  }
+  async runRefresh(agentName, operation) {
+    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", operation);
+    } finally {
+      state.isRunning = false;
+      if (state.hasPendingRerun && !this.isShuttingDown) {
+        state.hasPendingRerun = false;
+        this.schedule(
+          agentName,
+          PENDING_REFRESH_DELAY_MS,
+          () => this.runRefresh(agentName, operation)
+        );
+      }
+    }
+  }
+  serialize(agentName, kind, operation) {
+    const previous = this.operationTails.get(agentName) ?? Promise.resolve();
+    const run = previous.then(async () => {
+      if (this.isShuttingDown) return "skipped";
+      const lifecycle = this.beginOperation(agentName, kind);
+      try {
+        const result = await operation();
+        this.completeOperation(lifecycle, result);
+        return result;
+      } catch (error) {
+        this.completeOperation(lifecycle, "failed");
+        throw error;
+      }
+    });
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.operationTails.set(agentName, tail);
+    void tail.finally(() => {
+      if (this.operationTails.get(agentName) === tail) this.operationTails.delete(agentName);
+    });
+    return run;
+  }
+  async shutdown() {
+    this.isShuttingDown = true;
+    for (const state of this.states.values()) {
+      if (!state.timer) continue;
+      clearTimeout(state.timer);
+      state.timer = null;
+      state.timerDeadline = 0;
+    }
+    await Promise.allSettled(this.operationTails.values());
+  }
+  state(agentName) {
+    const existing = this.states.get(agentName);
+    if (existing) return existing;
+    const state = {
+      timer: null,
+      timerDeadline: 0,
+      isRunning: false,
+      hasPendingRerun: false,
+      lastRefreshAt: 0,
+      lastRefreshDurationMs: 0,
+      pendingPathCount: 0
+    };
+    this.states.set(agentName, state);
+    return state;
+  }
+  beginOperation(agentName, kind) {
+    const generation = (this.operationGenerations.get(agentName) ?? 0) + 1;
+    const startedAt = Date.now();
+    this.operationGenerations.set(agentName, generation);
+    appLogger.info("scan.agent_operation.started", {
+      agent: agentName,
+      operation: kind,
+      generation,
+      started_at: startedAt
+    });
+    return { agentName, kind, generation, startedAt };
+  }
+  completeOperation(lifecycle, result) {
+    const completedAt = Date.now();
+    appLogger.info("scan.agent_operation.completed", {
+      agent: lifecycle.agentName,
+      operation: lifecycle.kind,
+      generation: lifecycle.generation,
+      started_at: lifecycle.startedAt,
+      completed_at: completedAt,
+      duration_ms: completedAt - lifecycle.startedAt,
+      result
+    });
+  }
+};
+
 // src/session-watcher.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2, watch } from "fs";
+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;
@@ -959,11 +1641,11 @@ function toAbsolutePath(path) {
   return isAbsolute(path) ? path : resolve2(path);
 }
 function closestWatchablePath(targetPath) {
-  if (!isAbsolute(targetPath) && !existsSync3(targetPath)) {
+  if (!isAbsolute(targetPath) && !existsSync4(targetPath)) {
     return null;
   }
   let current = toAbsolutePath(targetPath);
-  while (!existsSync3(current)) {
+  while (!existsSync4(current)) {
     const parent = dirname2(current);
     if (parent === current) {
       return null;
@@ -1271,9 +1953,9 @@ 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 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,
@@ -1349,27 +2031,16 @@ var LiveScanStore = class {
   sessions = [];
   listeners = /* @__PURE__ */ new Set();
   scanStatusListeners = /* @__PURE__ */ new Set();
-  scanStatus = {
-    active: false,
-    phase: "idle",
-    pendingAgents: [],
-    scanningAgents: [],
-    completedAgents: [],
-    agentStatuses: {},
-    totalAgents: 0,
-    updatedAt: Date.now()
-  };
-  refreshTimers = /* @__PURE__ */ new Map();
-  refreshTimestamps = /* @__PURE__ */ new Map();
-  refreshInFlight = /* @__PURE__ */ new Set();
-  pendingRefreshes = /* @__PURE__ */ new Set();
-  pendingRefreshPathCounts = /* @__PURE__ */ new Map();
+  scanStatus = new ScanStatusModel();
+  backfills = new BackfillCoordinator();
+  refreshes = new RefreshCoordinator();
   watcher = null;
   pendingEvent = null;
   pendingEventTimer = null;
   backgroundRefreshTimer = null;
-  searchIndexWorker = null;
-  pendingSearchIndexJobs = [];
+  scanRefreshWorkers = /* @__PURE__ */ new Set();
+  searchIndexJobs = new SearchIndexJobRunner();
+  shutdownPromise = null;
   shuttingDown = false;
   async initialize() {
     const startedAt = performance.now();
@@ -1395,7 +2066,7 @@ var LiveScanStore = class {
     this.applyScanResult(initialResult);
     const indexStartedAt = performance.now();
     if (!deferInitialRefresh) {
-      await this.enqueueSearchIndexJobs(
+      await this.searchIndexJobs.enqueue(
         "scan.initial",
         this.buildFullSearchIndexJobs("scan.initial")
       );
@@ -1427,10 +2098,7 @@ var LiveScanStore = class {
       this.watcher = new SessionWatcher();
       this.watcher.onAgentsChanged((agentNames) => {
         for (const agentName of agentNames) {
-          this.pendingRefreshPathCounts.set(
-            agentName,
-            (this.pendingRefreshPathCounts.get(agentName) ?? 0) + 1
-          );
+          this.refreshes.recordChangedPaths(agentName);
           const delayMs = (this.byAgent[agentName]?.length ?? 0) === 0 ? EMPTY_AGENT_REFRESH_DEBOUNCE_MS : REFRESH_DEBOUNCE_MS;
           this.scheduleRefresh(agentName, delayMs);
         }
@@ -1452,6 +2120,11 @@ var LiveScanStore = class {
       if (agentNames.length === 0) {
         this.finishScanBatch();
       }
+      for (const agent of this.agents) {
+        if (this.needsBackfill(agent)) {
+          this.enqueueBackfill(agent.name);
+        }
+      }
     }, 0);
   }
   getSnapshot() {
@@ -1462,19 +2135,7 @@ var LiveScanStore = class {
     };
   }
   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 }
-        ])
-      )
-    };
+    return this.scanStatus.snapshot();
   }
   subscribe(listener) {
     this.listeners.add(listener);
@@ -1488,13 +2149,26 @@ var LiveScanStore = class {
       this.scanStatusListeners.delete(listener);
     };
   }
-  async shutdown() {
+  shutdown() {
+    this.shutdownPromise ??= this.performShutdown();
+    return this.shutdownPromise;
+  }
+  async performShutdown() {
     this.shuttingDown = true;
-    for (const timer of this.refreshTimers.values()) {
-      clearTimeout(timer);
+    const activeOperations = {
+      agent_operations: this.refreshes.activeOperationCount,
+      refreshes: this.refreshes.activeRefreshCount,
+      backfill_running: this.backfills.isRunning || void 0,
+      scan_workers: this.scanRefreshWorkers.size
+    };
+    if (activeOperations.agent_operations > 0 || activeOperations.scan_workers > 0) {
+      appLogger.warn("scan.shutdown.active_operations", activeOperations);
     }
-    this.refreshTimers.clear();
-    this.pendingRefreshPathCounts.clear();
+    const searchIndexSnapshot = this.searchIndexJobs.snapshot();
+    appLogger.info("search_index.shutdown.started", {
+      active_batch_id: searchIndexSnapshot.activeBatchId,
+      pending_batches: searchIndexSnapshot.pendingBatches
+    });
     if (this.pendingEventTimer) {
       clearTimeout(this.pendingEventTimer);
       this.pendingEventTimer = null;
@@ -1503,21 +2177,24 @@ var LiveScanStore = class {
       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 = [];
+    this.backfills.clear();
+    await this.searchIndexJobs.shutdown();
+    const scanWorkers = [...this.scanRefreshWorkers];
+    await Promise.allSettled(scanWorkers.map((scanWorker) => scanWorker.terminate()));
+    await this.refreshes.shutdown();
     this.pendingEvent = null;
     if (this.watcher) {
       await this.watcher.dispose();
       this.watcher = null;
     }
+    const stoppedSearchIndexSnapshot = this.searchIndexJobs.snapshot();
+    appLogger.info("search_index.shutdown.completed", {
+      active_batch_id: searchIndexSnapshot.activeBatchId,
+      pending_batches: stoppedSearchIndexSnapshot.pendingBatches
+    });
   }
   emit(event) {
+    if (this.shuttingDown) return;
     if (this.pendingEvent || event.newSessions > 0) {
       this.queueEvent(event);
       return;
@@ -1529,157 +2206,131 @@ var LiveScanStore = class {
       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
-        }
-      ])
+    const sessionCounts = Object.fromEntries(
+      agentNames.map((agentName) => [agentName, this.byAgent[agentName]?.length ?? 0])
     );
-    this.updateScanStatus({
-      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
-    });
+    this.publishScanStatus(this.scanStatus.startBatch(agentNames, phase, sessionCounts));
   }
   setScanPhase(phase) {
-    if (!this.scanStatus.active) return;
-    this.updateScanStatus({
-      ...this.scanStatus,
-      phase,
-      updatedAt: Date.now()
-    });
+    this.publishScanStatus(this.scanStatus.setPhase(phase));
   }
   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
-    });
+    if (!this.scanStatus.snapshot().active) this.startScanBatch([agentName], "scanning");
+    this.publishScanStatus(
+      this.scanStatus.beginAgent(agentName, this.byAgent[agentName]?.length ?? 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()
-    });
+    this.publishScanStatus(this.scanStatus.updateAgent(agentName, progress));
   }
   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
-    });
+    this.publishScanStatus(this.scanStatus.finishAgent(agentName, this.byAgent[agentName]?.length));
   }
   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
+    this.publishScanStatus(this.scanStatus.finishBatch());
+  }
+  updateBackfillStatus(patch) {
+    this.publishScanStatus(this.scanStatus.updateBackfill(patch));
+  }
+  publishScanStatus(event) {
+    if (!event || this.shuttingDown) return;
+    for (const listener of this.scanStatusListeners) listener(event);
+  }
+  /**
+   * Only FileSystemSessionSource agents pay the O(history) enumeration cost this
+   * guards against: database agents already do a cheap single-file mtime check.
+   * With no startup window configured, the regular refresh path already walks
+   * full history, so backfill would be redundant.
+   */
+  needsBackfill(agent) {
+    if (this.startupScanOptions.from == null && this.startupScanOptions.to == null) return false;
+    if (!(agent instanceof FileSystemSessionSource)) return false;
+    if (!agent.isAvailable()) return false;
+    const lastSyncAt = getAgentLastFullSyncAt(agent.name);
+    return lastSyncAt == null || Date.now() - lastSyncAt > BACKFILL_INTERVAL_MS;
+  }
+  enqueueBackfill(agentName) {
+    if (this.shuttingDown) return;
+    const status = this.backfills.enqueue(agentName);
+    if (!status) return;
+    this.updateBackfillStatus(status);
+    this.pumpBackfillQueue();
+  }
+  pumpBackfillQueue() {
+    if (this.shuttingDown) return;
+    const work = this.backfills.take();
+    if (!work) return;
+    this.updateBackfillStatus(work.status);
+    void this.runBackfill(work.agentName).finally(() => {
+      if (this.shuttingDown) return;
+      this.updateBackfillStatus(this.backfills.complete(work.agentName));
+      this.pumpBackfillQueue();
     });
   }
+  /** Unbounded per-source sync to reconcile the full session history, not just the display window. */
+  async runBackfill(agentName) {
+    await this.refreshes.serialize(agentName, "backfill", () => this.performBackfill(agentName));
+  }
+  async performBackfill(agentName) {
+    const startedAt = performance.now();
+    const agent = this.agents.find((item) => item.name === agentName);
+    if (!agent || !(agent instanceof FileSystemSessionSource) || !agent.isAvailable()) {
+      return "skipped";
+    }
+    const cached = loadCachedSessions(agentName);
+    const baseline = cached?.sessions ?? this.byAgent[agentName] ?? [];
+    const meta = cached?.meta ?? buildAgentCacheMeta(agent);
+    if (cached) {
+      restoreAgentCacheMeta(agent, cached.meta);
+    }
+    try {
+      const result = await this.scanAgentInWorker(
+        agent,
+        baseline,
+        null,
+        {},
+        { sourceSync: true, meta }
+      );
+      agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
+      const fullSessions = attachMissingProjectIdentities(result.sessions);
+      const filtered = this.applyFilters(fullSessions);
+      const diff = buildRefreshDiff(
+        agentName,
+        this.byAgent[agentName] ?? [],
+        filtered,
+        result.changedIds ?? []
+      );
+      this.byAgent[agentName] = sortSessions(filtered);
+      this.rebuildSessions();
+      await this.searchIndexJobs.enqueue("scan.backfill", [
+        {
+          kind: "full",
+          context: "scan.backfill",
+          agentName,
+          sessions: fullSessions,
+          meta: buildAgentCacheMeta(agent),
+          saveCache: true
+        }
+      ]);
+      markAgentFullSyncCompleted(agentName);
+      if (diff.event) {
+        diff.event.totalSessions = this.sessions.length;
+        this.emit(diff.event);
+      }
+      appLogger.info("scan.backfill.done", {
+        agent: agentName,
+        duration_ms: Math.round(performance.now() - startedAt),
+        sessions: fullSessions.length,
+        changed: result.changedIds?.length ?? 0
+      });
+      return "committed";
+    } catch (error) {
+      appLogger.error("scan.backfill.error", { agent: agentName, error });
+      console.error(`[${agentName}] Backfill failed:`, error);
+      return "failed";
+    }
+  }
   queueEvent(event) {
     this.pendingEvent = this.pendingEvent ? mergeEvents(this.pendingEvent, event) : event;
     if (this.pendingEventTimer) {
@@ -1697,16 +2348,9 @@ var LiveScanStore = class {
   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))) {
+    if (workerUrl.protocol === "file:" && !existsSync5(fileURLToPath3(workerUrl))) {
       return null;
     }
     return workerUrl;
@@ -1717,7 +2361,7 @@ var LiveScanStore = class {
   scanAgentInWorker(agent, previousSessions, changedIds, scanOptions, workerOptions = {}) {
     const workerUrl = this.getScanRefreshWorkerUrl();
     return new Promise((resolve4, reject) => {
-      const worker = new Worker(workerUrl, {
+      const worker = new Worker2(workerUrl, {
         workerData: {
           agentName: agent.name,
           previousSessions,
@@ -1728,11 +2372,13 @@ var LiveScanStore = class {
         }
       });
       worker.unref();
+      this.scanRefreshWorkers.add(worker);
       let settled = false;
-      const finish = (callback) => {
+      const finish = (callback, terminate = true) => {
         if (settled) return;
         settled = true;
-        void worker.terminate();
+        this.scanRefreshWorkers.delete(worker);
+        if (terminate) void worker.terminate();
         callback();
       };
       worker.on("message", (message) => {
@@ -1756,8 +2402,15 @@ var LiveScanStore = class {
         finish(() => reject(error));
       });
       worker.once("exit", (code) => {
-        if (!settled && code !== 0) {
-          finish(() => reject(new Error(`Scan refresh worker exited with code ${code}`)));
+        if (!settled) {
+          appLogger.warn("scan.refresh_worker.exit_before_done", {
+            agent: agent.name,
+            code
+          });
+          finish(
+            () => reject(new Error(`Scan refresh worker exited before completing (code ${code})`)),
+            false
+          );
         }
       });
     });
@@ -1783,75 +2436,6 @@ var LiveScanStore = class {
       };
     });
   }
-  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: {}
-      }
-    });
-    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;
-        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();
@@ -1873,7 +2457,10 @@ var LiveScanStore = class {
     this.byAgent = {};
     for (const agent of this.agents) {
       this.byAgent[agent.name] = sortSessions(result.byAgent[agent.name] ?? []);
-      this.refreshTimestamps.set(agent.name, result.cacheTimestamps?.[agent.name] ?? Date.now());
+      this.refreshes.setLastRefreshAt(
+        agent.name,
+        result.cacheTimestamps?.[agent.name] ?? Date.now()
+      );
     }
     this.rebuildSessions();
   }
@@ -1890,7 +2477,7 @@ var LiveScanStore = class {
     const startedAt = performance.now();
     const context = "scan.initial.background";
     try {
-      await this.enqueueSearchIndexJobs(context, this.buildFullSearchIndexJobs(context));
+      await this.searchIndexJobs.enqueue(context, this.buildFullSearchIndexJobs(context));
       appLogger.info(`${context}.complete`, {
         duration_ms: Math.round(performance.now() - startedAt),
         sessions: this.sessions.length
@@ -1903,52 +2490,41 @@ var LiveScanStore = class {
       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) {
-    appLogger.debug("scan.refresh.schedule", { agent: agentName, delay_ms: delayMs });
-    const existing = this.refreshTimers.get(agentName);
-    if (existing) {
-      clearTimeout(existing);
-    }
-    const timer = setTimeout(() => {
-      this.refreshTimers.delete(agentName);
-      void this.refreshAgent(agentName);
-    }, delayMs);
-    this.refreshTimers.set(agentName, timer);
+    this.refreshes.schedule(agentName, delayMs, () => this.refreshAgent(agentName));
   }
   async refreshAgent(agentName) {
-    if (this.refreshInFlight.has(agentName)) {
-      appLogger.debug("scan.refresh.pending", { agent: agentName });
-      this.pendingRefreshes.add(agentName);
-      return;
-    }
-    this.refreshInFlight.add(agentName);
-    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 {
-      this.refreshInFlight.delete(agentName);
-      this.finishAgentScan(agentName);
-      if (this.pendingRefreshes.delete(agentName)) {
-        this.scheduleRefresh(agentName, PENDING_REFRESH_DELAY_MS);
+    await this.refreshes.runRefresh(agentName, async () => {
+      this.beginAgentScan(agentName);
+      try {
+        return await this.runRefresh(agentName);
+      } catch (error) {
+        appLogger.error("scan.refresh.error", { agent: agentName, error });
+        console.error(`[${agentName}] Session refresh failed:`, error);
+        return "failed";
+      } finally {
+        this.finishAgentScan(agentName);
       }
-    }
+    });
   }
   async runRefresh(agentName) {
     const startedAt = performance.now();
-    const pendingPathCount = this.pendingRefreshPathCounts.get(agentName) ?? 0;
-    this.pendingRefreshPathCounts.delete(agentName);
+    const pendingPathCount = this.refreshes.takePendingPathCount(agentName);
     const agent = this.agents.find((item) => item.name === agentName);
     if (!agent) {
       appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
-      return;
+      return "skipped";
     }
     const previousSessions = this.byAgent[agentName] ?? [];
     const cached = loadCachedSessions(agentName);
     const refreshBaseline = cached?.sessions ?? previousSessions;
-    const cacheTimestamp = cached?.timestamp ?? this.refreshTimestamps.get(agentName) ?? 0;
+    const cacheTimestamp = cached?.timestamp ?? this.refreshes.lastRefreshAt(agentName);
     if (cached) {
       restoreAgentCacheMeta(agent, cached.meta);
     }
@@ -1971,24 +2547,29 @@ var LiveScanStore = class {
     availabilityDuration = performance.now() - availabilityStartedAt;
     if (!isAvailable) {
       nextSessions = [];
-      this.refreshTimestamps.set(agentName, Date.now());
+      this.refreshes.setLastRefreshAt(agentName, Date.now());
     } else if (!isInitialized) {
       this.setScanPhase("initializing");
       const scanStartedAt = performance.now();
-      const result = await this.scanAgentInWorker(agent, previousSessions, null, {});
+      const result = await this.scanAgentInWorker(
+        agent,
+        previousSessions,
+        null,
+        this.startupScanOptions
+      );
       nextSessions = result.sessions;
       agent.setSessionMetaMap?.(new Map(Object.entries(result.meta)));
       fullScanSessions = attachMissingProjectIdentities(nextSessions);
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
-      this.refreshTimestamps.set(agentName, Date.now());
+      this.refreshes.setLastRefreshAt(agentName, Date.now());
     } else if (cached && agent instanceof FileSystemSessionSource) {
       const scanStartedAt = performance.now();
       const result = await this.scanAgentInWorker(
         agent,
         cached.sessions,
         null,
-        {},
+        this.startupScanOptions,
         {
           sourceSync: true,
           meta: cached.meta
@@ -2005,7 +2586,7 @@ var LiveScanStore = class {
         preciseChangedIds
       );
       scanDuration = performance.now() - scanStartedAt;
-      this.refreshTimestamps.set(agentName, Date.now());
+      this.refreshes.setLastRefreshAt(agentName, Date.now());
       if (preciseChangedIds.length === 0) {
         appLogger.debug("scan.refresh.unchanged", {
           agent: agentName,
@@ -2018,13 +2599,13 @@ var LiveScanStore = class {
         agent.checkForChanges(cacheTimestamp, refreshBaseline)
       );
       checkDuration = performance.now() - checkStartedAt;
-      this.refreshTimestamps.set(agentName, checkResult.timestamp);
+      this.refreshes.setLastRefreshAt(agentName, checkResult.timestamp);
       if (!checkResult.hasChanges) {
         appLogger.debug("scan.refresh.unchanged", {
           agent: agentName,
           duration_ms: Math.round(performance.now() - startedAt)
         });
-        return;
+        return "unchanged";
       }
       preciseChangedIds = checkResult.changedIds ?? null;
       usedIncrementalScan = Array.isArray(checkResult.changedIds);
@@ -2049,7 +2630,7 @@ var LiveScanStore = class {
       fullScanSessions = attachMissingProjectIdentities(nextSessions);
       nextSessions = fullScanSessions;
       scanDuration = performance.now() - scanStartedAt;
-      this.refreshTimestamps.set(agentName, Date.now());
+      this.refreshes.setLastRefreshAt(agentName, Date.now());
     }
     nextSessions = attachMissingProjectIdentities(nextSessions);
     const filterStartedAt = performance.now();
@@ -2089,7 +2670,7 @@ var LiveScanStore = class {
     } : null;
     if (persistentJob) {
       persistentJobKind = persistentJob.kind;
-      const persist = this.enqueueSearchIndexJobs("scan.refresh", [persistentJob]);
+      const persist = this.searchIndexJobs.enqueue("scan.refresh", [persistentJob]);
       if (!isInitialized && persistentJob.kind === "full") {
         await persist;
       } else {
@@ -2110,9 +2691,11 @@ var LiveScanStore = class {
       event.totalSessions = this.sessions.length;
       this.emit(event);
     }
+    const totalDurationMs = performance.now() - startedAt;
+    this.refreshes.setLastRefreshDuration(agentName, totalDurationMs);
     appLogger.info("scan.refresh.done", {
       agent: agentName,
-      duration_ms: Math.round(performance.now() - startedAt),
+      duration_ms: Math.round(totalDurationMs),
       sessions: nextSessions.length,
       new_sessions: event?.newSessions ?? 0,
       updated_sessions: event?.updatedSessions ?? 0,
@@ -2128,6 +2711,7 @@ var LiveScanStore = class {
       persistent_index_worker_job: persistentJobKind,
       persistent_index_skipped: !persistentJob || void 0
     });
+    return "committed";
   }
 };
 
@@ -2137,8 +2721,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;
 
@@ -2188,6 +2772,18 @@ function parseSessionUri(uri) {
   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",
@@ -2201,6 +2797,16 @@ var main = defineCommand({
       description: "HTTP server port",
       default: String(DEFAULT_PORT)
     },
+    host: {
+      type: "string",
+      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",
@@ -2265,6 +2871,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();
     }
@@ -2278,7 +2892,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-T737I76S.js");
+      const { clearCache: clear } = await import("./dist-VD54GDPO.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");
@@ -2367,7 +2981,9 @@ var main = defineCommand({
         defaultSessionFrom: listDefaultFrom,
         defaultSessionTo: listDefaultTo,
         defaultSessionDays: listDefaultDays,
-        portFallbackAttempts: explicitPort ? 1 : DEFAULT_PORT_FALLBACK_ATTEMPTS
+        portFallbackAttempts: explicitPort ? 1 : DEFAULT_PORT_FALLBACK_ATTEMPTS,
+        hostname,
+        remoteAccess
       });
     } catch (error) {
       console.error(getServerStartupErrorMessage(error, port));
@@ -2394,14 +3010,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);
     }
   }