codesesh 1.0.4 → 1.0.6

package/dist/index.js

@@ -4,22 +4,25 @@ import {
   buildDashboard,
   getSessionActivityTime,
   summarizeProjects
-} from "./chunk-MBZ4VV4C.js";
+} from "./chunk-A3MT6L6Z.js";
 import {
   AGENT_UNAVAILABLE_DURING_SCAN_ERROR_CODE,
   AgentUnavailableDuringScanError
 } from "./chunk-RF3EEWPH.js";
+import {
+  terminateWorkerAfterLogDrain
+} from "./chunk-COZSWVCH.js";
 import "./chunk-QH2HOXJH.js";
 import {
   appLogger,
   logSearchIndexSync
-} from "./chunk-G4HRD3AR.js";
+} from "./chunk-4QFNZCBR.js";
 import {
   attachMissingProjectIdentities,
+  beginAgentRefresh,
   buildAgentCacheMeta,
   buildSessionPersistenceDiff,
   closeCacheStorage,
-  commitAgentRefreshCheck,
   computeSessionDiff,
   filterIndexedSessionReferences,
   getAgentFullSyncCursor,
@@ -32,6 +35,8 @@ import {
   markAgentFullSyncCompleted,
   markAgentFullSyncProgress,
   markAgentFullSyncStarted,
+  matchesSessionQueryScope,
+  materializeCachedSessionDetailResponse,
   materializeSessionDetailResponse,
   mergeSearchQueryOptions,
   readAgentCacheInitialization,
@@ -42,22 +47,24 @@ import {
   scanSessions,
   searchFileActivitySessions,
   searchSessions,
-  selectAgentRefresh,
   sessionMatchesSearchCost,
   sessionSignature,
   sortSessions
-} from "./chunk-BYB77UAJ.js";
+} from "./chunk-XQDYKKRC.js";
 import {
   PROJECT_IDENTITY_RESOLVER_REVISION,
+  createProjectScopeMatcher,
   createProjectScopeMatcherFromIdentity,
   matchesProjectScope,
   normalizeProjectDirectory
-} from "./chunk-3SXCTDD6.js";
+} from "./chunk-YZ6XCSVQ.js";
 import {
   createRegisteredAgents,
   getAgentInfoMap
-} from "./chunk-YCUN52HA.js";
+} from "./chunk-L3DDWTYV.js";
 import {
+  CODESESH_OPERATION_ID_HEADER,
+  CODESESH_REQUEST_ID_HEADER,
   addCalendarDays,
   assertIdentifiedSessionHead,
   assertSessionIdentity,
@@ -78,6 +85,7 @@ import {
   mergeSortedSessions,
   normalizeSessionReference,
   openDb,
+  parseCalendarDayBoundary,
   perf,
   publishPendingPricing,
   refreshPricingCache,
@@ -88,162 +96,49 @@ import {
   tableExists,
   toPublicReferencedSessionHead,
   toPublicSessionHead
-} from "./chunk-W4PZHL2C.js";
+} from "./chunk-4ND6AT6W.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
 
+// src/cli-exit.ts
+var LOG_CLOSE_TIMEOUT_MS = 2e3;
+var LOG_CLOSE_TIMEOUT_MESSAGE = "[codesesh] Timed out closing application log; forcing exit\n";
+async function closeLoggerBeforeTermination(closeLogger, exitCode) {
+  let watchdog;
+  const timedOut = new Promise((resolve4) => {
+    watchdog = setTimeout(() => resolve4(false), LOG_CLOSE_TIMEOUT_MS);
+  });
+  try {
+    const closed = await Promise.race([closeLogger().then(() => true), timedOut]);
+    if (closed) return;
+    try {
+      process.stderr.write(LOG_CLOSE_TIMEOUT_MESSAGE);
+    } finally {
+      process.exit(exitCode);
+    }
+  } finally {
+    if (watchdog) clearTimeout(watchdog);
+  }
+}
+
 // src/server.ts
 import { Hono as Hono2 } from "hono";
+import { matchedRoutes } from "hono/route";
 import { bodyLimit } from "hono/body-limit";
 import { compress } from "hono/compress";
 import { secureHeaders } from "hono/secure-headers";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { existsSync } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
 import { createServer as createHttpsServer } from "https";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 
 // src/api/routes.ts
 import { Hono } from "hono";
-
-// ../core/dist/runtime/search.mjs
-function executeSessionSearch(query, options, snapshot, context = {}) {
-  const merged = mergeSearchQueryOptions(query, options);
-  if (!needsIndexedSearch(merged.text, merged.options)) {
-    return searchRecentSessions(snapshot, merged.options, context);
-  }
-  return searchIndexedSessions(query, merged.text, merged.parsed, merged.options);
-}
-function needsIndexedSearch(textQuery, options) {
-  return Boolean(textQuery || options.file || options.fileKind || options.tools?.length);
-}
-function matchesRecentSearchFilters(session, options, projectScope, inclusiveCost) {
-  if (options.projectKind || options.projectKey) {
-    if (!options.projectKind || !options.projectKey || !matchesProjectIdentity(session.project_identity, {
-      kind: options.projectKind,
-      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 (!sessionMatchesSearchCost(session, options, inclusiveCost)) return false;
-  return true;
-}
-function matchesSessionSearchFilters(agentName, session, options, projectScope = null, inclusiveCost = session.stats.total_cost) {
-  if (options.agent && agentName !== options.agent) return false;
-  const activity = getSessionActivityTime(session);
-  if (options.from != null && activity < options.from) return false;
-  if (options.to != null && activity > options.to) return false;
-  return matchesRecentSearchFilters(session, options, projectScope, inclusiveCost);
-}
-function filterSessionSearchCandidates(candidates, options, context = {}) {
-  const projectScope = options.projectScope ?? null;
-  const sessionSnapshot = context.sessionSnapshot ?? candidates.map((candidate) => candidate.session);
-  const inclusiveCosts = buildInclusiveCostLookup(sessionSnapshot, options, context.sessionTree);
-  const headMatches = candidates.filter(
-    (candidate) => matchesSessionSearchFilters(
-      candidate.reference.agentName,
-      candidate.session,
-      options,
-      projectScope,
-      inclusiveCostFor(candidate.reference.agentName, candidate.session, inclusiveCosts)
-    )
-  );
-  if (!options.file && !options.fileKind && !options.tools?.length) return headMatches;
-  const indexedMatches = filterIndexedSessionReferences(
-    headMatches.map((candidate) => ({
-      agentName: candidate.reference.agentName,
-      sessionId: candidate.reference.sessionId
-    })),
-    {
-      file: options.file,
-      fileKind: options.fileKind,
-      tools: options.tools
-    }
-  );
-  return headMatches.filter(
-    (candidate) => indexedMatches.has(getSessionReferenceKey(candidate.reference))
-  );
-}
-function searchRecentSessions(snapshot, options, context) {
-  const limit = Math.max(0, Math.trunc(options.limit ?? 50));
-  if (limit === 0) return [];
-  const projectScope = options.projectScope ?? null;
-  const inclusiveCosts = buildInclusiveCostLookup(snapshot.sessions, options, context.sessionTree);
-  const sessions = options.agent ? snapshot.byAgent[options.agent] ?? [] : snapshot.sessions;
-  const results = [];
-  for (const session of sessions) {
-    const agentName = options.agent ?? session.reference.agentName;
-    if (!matchesSessionSearchFilters(
-      agentName,
-      session,
-      options,
-      projectScope,
-      inclusiveCostFor(agentName, session, inclusiveCosts)
-    )) {
-      continue;
-    }
-    results.push({
-      reference: session.reference,
-      session,
-      snippet: `Recent session \xB7 ${session.directory}`,
-      snippetHighlights: [],
-      matchType: "recent"
-    });
-    if (results.length >= limit) break;
-  }
-  return results;
-}
-function buildInclusiveCostLookup(sessions, options, sessionTree) {
-  if (options.costMin == null && options.costMax == null) return null;
-  return (sessionTree ?? buildSessionTree(sessions)).byRouteKey;
-}
-function inclusiveCostFor(agentName, session, lookup) {
-  return lookup?.get(getSessionReferenceKey({ agentName, sessionId: session.reference.sessionId }))?.inclusiveStats.cost ?? session.stats.total_cost;
-}
-function deriveFileQuery(query, parsed, options) {
-  return options.file ?? (!parsed.text ? parsed.filters.file : void 0) ?? (!parsed.hasQualifiers && query ? parsed.text || query : "");
-}
-function mergeSearchResultSources(results, limit) {
-  const seen = /* @__PURE__ */ new Set();
-  const merged = [];
-  for (const result of results) {
-    const key = getSessionReferenceKey(result.reference);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    merged.push(result);
-    if (merged.length >= limit) break;
-  }
-  return merged;
-}
-function canSkipSessionsSearch(fileQuery, textQuery) {
-  return Boolean(fileQuery && !textQuery);
-}
-function searchIndexedSessions(query, textQuery, parsed, options) {
-  const fileQuery = deriveFileQuery(query, parsed, options);
-  const fileResults = fileQuery ? searchFileActivitySessions(fileQuery, options) : [];
-  const sessionResults = canSkipSessionsSearch(fileQuery, textQuery) ? [] : searchSessions(query, options);
-  const textMatchReferences = textQuery && options.file ? new Set(sessionResults.map((result) => getSessionReferenceKey(result.reference))) : null;
-  const matchingFileResults = textMatchReferences ? fileResults.filter(
-    (result) => textMatchReferences.has(getSessionReferenceKey(result.reference))
-  ) : fileResults;
-  return mergeSearchResultSources([...matchingFileResults, ...sessionResults], options.limit ?? 50);
-}
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/project-identity-resolver.ts
 import { Worker } from "worker_threads";
@@ -524,59 +419,6 @@ function createProjectIdentityResolver() {
   );
 }
 
-// src/time-window-resolution.ts
-var ROLLING_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 * ROLLING_DAY_MS;
-  return Number.isFinite(rollingFrom) ? { from: rollingFrom, to, days } : { to };
-}
-function resolveDashboardWindow(request) {
-  const now = request.now ?? Date.now();
-  const to = request.window.to ?? now;
-  const hasQueryDays = Boolean(request.days?.trim());
-  const parsedDays = hasQueryDays ? parseDays(request.days) : void 0;
-  let days = parsedDays != null && parsedDays > 0 ? parsedDays : request.defaultDays;
-  if (request.window.hasExplicitFrom && request.window.from != null) {
-    days ??= countCalendarDays(request.window.from, to);
-    return { from: request.window.from, to, days };
-  }
-  if (parsedDays === 0 || !hasQueryDays && request.defaultDays === 0) {
-    return { to, days: 0 };
-  }
-  if (request.window.from != null) {
-    days ??= countCalendarDays(request.window.from, to);
-    return { from: request.window.from, to, days };
-  }
-  const resolvedDays = days != null && days > 0 ? days : DEFAULT_DASHBOARD_DAYS;
-  return {
-    from: addCalendarDays(startOfCalendarDay(to), -(resolvedDays - 1)),
-    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 parseDays(value) {
-  if (value == null) return void 0;
-  const days = Number.parseInt(value, 10);
-  return Number.isSafeInteger(days) && Number.isSafeInteger(days * ROLLING_DAY_MS) ? days : void 0;
-}
-
 // src/api/query-params.ts
 var SEARCH_LIMIT_POLICY = { defaultValue: 50, maxValue: 100 };
 var FILE_ACTIVITY_LIMIT_POLICY = { defaultValue: 50, maxValue: 200 };
@@ -687,16 +529,53 @@ function filterSessionsByActivityWindow(sessions, from, to) {
   return filterSessionTreeByActivityWindow(sessions, from, to);
 }
 
+// src/api/handler-support.ts
+var KNOWN_AGENT_NAMES = getAgentInfoMap({}).map((agent) => agent.name);
+var KNOWN_AGENT_NAME_SET = new Set(KNOWN_AGENT_NAMES);
+async function resolveProjectScope(cwd, sessions, resolver, signal) {
+  const normalizedCwd = normalizeProjectDirectory(cwd);
+  const matchingSession = sessions.find(
+    (session) => normalizeProjectDirectory(session.directory) === normalizedCwd && session.project_identity_resolver_revision === PROJECT_IDENTITY_RESOLVER_REVISION && Boolean(session.project_identity_input_signature)
+  );
+  if (matchingSession) {
+    return createProjectScopeMatcherFromIdentity(cwd, matchingSession.project_identity);
+  }
+  if (!resolver) throw new Error("Project identity resolver is unavailable");
+  const projection = await resolver.resolve(cwd, signal);
+  return createProjectScopeMatcherFromIdentity(cwd, projection.identity);
+}
+function projectScopeResolutionFailureResponse(c, endpoint, error) {
+  if (error instanceof ProjectIdentityRequestAbortedError) throw error;
+  appLogger.warn("api.project_scope.unavailable", {
+    endpoint,
+    error: error instanceof Error ? error.message : String(error)
+  });
+  if (error instanceof ProjectIdentityQueueFullError) {
+    return c.json({ error: "Project scope busy; retry later" }, 429);
+  }
+  return c.json({ error: "Project scope unavailable" }, 503);
+}
+function reportInvalidQueryParameter(endpoint, parameter, validationOutcome) {
+  appLogger.warn("api.query_parameter.invalid", {
+    endpoint,
+    parameter,
+    validation_outcome: validationOutcome
+  });
+}
+function parseDateWindowRequest(c, endpoint, defaults) {
+  const outcome = parseDateWindow(searchParams(c), defaults);
+  if (outcome.kind === "valid") return outcome;
+  reportInvalidQueryParameter(endpoint, outcome.parameter, "rejected");
+  return {
+    kind: "rejected",
+    response: c.json({ error: `${outcome.parameter} ${outcome.error}` }, 400)
+  };
+}
+
 // src/api/snapshot-pagination.ts
 import { createHash, randomUUID } from "crypto";
-var identityVersions = /* @__PURE__ */ new WeakMap();
-function identityVersion(identity) {
-  const existing = identityVersions.get(identity);
-  if (existing) return existing;
-  const version = randomUUID();
-  identityVersions.set(identity, version);
-  return version;
-}
+var SNAPSHOT_TTL_MS = 6e4;
+var SNAPSHOT_LIMIT = 32;
 function queryFingerprint(params) {
   const canonical = new URLSearchParams(params);
   canonical.delete("cursor");
@@ -713,7 +592,7 @@ function decodeCursor(cursor) {
     const value = JSON.parse(
       Buffer.from(cursor, "base64url").toString("utf8")
     );
-    if (value.version !== 1 || typeof value.snapshot !== "string" || typeof value.view !== "string" || typeof value.query !== "string" || !Number.isSafeInteger(value.offset) || value.offset <= 0) {
+    if (value.version !== 1 || typeof value.snapshot !== "string" || !Number.isSafeInteger(value.offset) || value.offset <= 0) {
       return null;
     }
     return value;
@@ -721,26 +600,47 @@ function decodeCursor(cursor) {
     return null;
   }
 }
-function paginateSnapshot(items, request) {
-  const snapshot = identityVersion(request.snapshotIdentity);
-  const view = identityVersion(request.viewIdentity);
-  const query = queryFingerprint(request.query);
-  let offset = 0;
-  if (request.cursor) {
-    const cursor = decodeCursor(request.cursor);
-    if (!cursor || cursor.query !== query) return { kind: "invalid_cursor" };
-    if (cursor.snapshot !== snapshot || cursor.view !== view) {
-      return { kind: "stale_snapshot" };
+function createSnapshotPaginator() {
+  const snapshotsBySource = /* @__PURE__ */ new WeakMap();
+  return function paginateSnapshot(source, request, load) {
+    const snapshots = snapshotsBySource.get(source) ?? /* @__PURE__ */ new Map();
+    const now = Date.now();
+    for (const [id, snapshot2] of snapshots) {
+      if (snapshot2.expiresAt <= now) snapshots.delete(id);
+    }
+    const query = queryFingerprint(request.query);
+    let snapshot;
+    let snapshotId;
+    let offset = 0;
+    if (request.cursor) {
+      const cursor = decodeCursor(request.cursor);
+      if (!cursor) return { kind: "invalid_cursor" };
+      const retained = snapshots.get(cursor.snapshot);
+      if (!retained) return { kind: "stale_snapshot" };
+      if (retained.query !== query || cursor.offset >= retained.items.length) {
+        return { kind: "invalid_cursor" };
+      }
+      snapshot = retained;
+      snapshotId = cursor.snapshot;
+      offset = cursor.offset;
+    } else {
+      const loaded = load();
+      snapshot = { ...loaded, items: [...loaded.items], query, expiresAt: now + SNAPSHOT_TTL_MS };
+      snapshotId = randomUUID();
     }
-    if (cursor.offset >= items.length) return { kind: "invalid_cursor" };
-    offset = cursor.offset;
-  }
-  const end = Math.min(offset + request.limit, items.length);
-  const nextCursor = end < items.length ? encodeCursor({ version: 1, snapshot, view, query, offset: end }) : void 0;
-  return {
-    kind: "page",
-    items: items.slice(offset, end),
-    ...nextCursor ? { nextCursor } : {}
+    const end = Math.min(offset + request.limit, snapshot.items.length);
+    const nextCursor = end < snapshot.items.length ? encodeCursor({ version: 1, snapshot: snapshotId, offset: end }) : void 0;
+    if (!request.cursor && nextCursor) {
+      if (snapshots.size >= SNAPSHOT_LIMIT) snapshots.delete(snapshots.keys().next().value);
+      snapshots.set(snapshotId, snapshot);
+      snapshotsBySource.set(source, snapshots);
+    }
+    return {
+      kind: "page",
+      items: snapshot.items.slice(offset, end),
+      view: snapshot.view,
+      ...nextCursor ? { nextCursor } : {}
+    };
   };
 }
 
@@ -778,26 +678,30 @@ function getSnapshotSessionTree(source, sessions) {
   const cache = getSnapshotAggregationCache(source, sessions);
   return cache.sessionTree ??= buildSessionTree(sessions);
 }
-function getDashboardCostFacts(source, sessions, from, to, cacheTo, analyticsRevision) {
-  const build = () => listDashboardCostFacts({ from, to });
+function getSnapshotCostFacts(source, sessions, from, to, cacheTo, analyticsRevision) {
+  const costFrom = from === 0 ? void 0 : from;
+  const build = () => listDashboardCostFacts({ from: costFrom, to });
   if (analyticsRevision === null) return build();
   return getSnapshotAggregation(
     source,
     sessions,
-    ["dashboard-cost-facts", from, cacheTo, analyticsRevision],
+    ["cost-facts", costFrom, cacheTo, analyticsRevision],
     build
   );
 }
 function getDashboardStorageAggregation(source, sessions, scope, from, to, cacheTo, analyticsRevision) {
   const build = () => ({
-    recentFileActivities: listFileActivity({
-      agent: scope.agent,
-      projectKind: scope.projectKind,
-      projectKey: scope.projectKey,
-      from,
-      to,
-      limit: 12
-    })
+    recentFileActivities: listFileActivity(
+      {
+        agent: scope.agent,
+        projectKind: scope.projectKind,
+        projectKey: scope.projectKey,
+        from,
+        to,
+        limit: 12
+      },
+      source.queryScope
+    )
   });
   const startedAt = performance.now();
   const log = (cache) => {
@@ -829,157 +733,318 @@ function getDashboardStorageAggregation(source, sessions, scope, from, to, cache
   );
 }
 
-// src/api/request-payloads.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
+// src/api/catalog-handlers.ts
+var paginateProjects = createSnapshotPaginator();
+function handleGetConfig(c, defaults) {
+  const payload = {
+    window: {
+      from: defaults.from,
+      to: defaults.to,
+      days: defaults.days
+    }
+  };
+  return c.json(payload);
 }
-function parseSessionReferencePayload(value) {
-  if (!isRecord(value) || typeof value.agentName !== "string" || typeof value.sessionId !== "string" || !value.agentName.trim() || !value.sessionId) {
-    return null;
-  }
-  return normalizeSessionReference({
-    agentName: value.agentName.trim().toLowerCase(),
-    sessionId: value.sessionId
-  });
+function handleGetScanStatus(c, scanSource) {
+  return c.json(scanSource.getScanStatus());
 }
-function parseBookmarkReference(value) {
-  if (!isRecord(value)) return null;
-  const reference = parseSessionReferencePayload(value.reference);
-  if (reference) return reference;
-  if (typeof value.agentKey !== "string" || typeof value.sessionId !== "string" || !value.agentKey.trim() || !value.sessionId) {
-    return null;
+function handleGetAgents(c, scanSource, defaults = {}) {
+  const scanResult = scanSource.getSnapshot();
+  const window = parseDateWindowRequest(c, "agents", defaults);
+  if (window.kind === "rejected") return window.response;
+  const { from, to } = window;
+  const agents = getSnapshotAggregation(
+    scanSource,
+    scanResult.sessions,
+    ["agents", from, to],
+    () => {
+      const counts = Object.fromEntries(
+        Object.entries(scanResult.byAgent).map(([agentName, sessions]) => [
+          agentName,
+          filterSessionsByActivityWindow(sessions, from, to).length
+        ])
+      );
+      return getAgentInfoMap(counts);
+    }
+  );
+  return c.json(agents);
+}
+function handleGetProjects(c, scanSource, defaults = {}) {
+  const scanResult = scanSource.getSnapshot();
+  const params = searchParams(c);
+  const limit = parseLimit(params.get("limit"), PROJECT_PAGE_LIMIT_POLICY);
+  if (limit.kind === "invalid") {
+    reportInvalidQueryParameter("projects", "limit", "rejected");
+    return c.json({ error: limit.error }, 400);
   }
-  return normalizeSessionReference({
-    agentName: value.agentKey.trim().toLowerCase(),
-    sessionId: value.sessionId
+  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 window = parseDateWindowRequest(c, "projects", defaults);
+  if (window.kind === "rejected") return window.response;
+  const { from, to } = window;
+  const loadSnapshot = () => {
+    const analyticsRevision = getAnalyticsRevision();
+    const catalog = getSnapshotAggregation(
+      scanSource,
+      scanResult.sessions,
+      ["projects", from, to, analyticsRevision],
+      () => {
+        const tree = getSnapshotSessionTree(scanSource, scanResult.sessions);
+        const costFacts = (from == null || from === 0) && to == null ? getSnapshotCostFacts(scanSource, scanResult.sessions, from, to, to, analyticsRevision) : listDashboardCostFacts({ from, to, includeModelCosts: false });
+        const projects2 = attachProjectMetricsFromTree(
+          listCachedProjectGroups(scanResult.sessions),
+          tree,
+          from,
+          to,
+          costFacts
+        ).filter(
+          (project) => project.sessionCount > 0 || project.messages > 0 || project.tokens > 0 || project.cost > 0
+        );
+        return { projects: projects2, summary: summarizeProjects(projects2) };
+      }
+    );
+    const projects = projectIdentity ? catalog.projects.filter(
+      (project) => project.identityKind === projectIdentity.kind && project.identityKey === projectIdentity.key
+    ) : catalog.projects;
+    return {
+      items: projects,
+      view: projectIdentity ? summarizeProjects(projects) : catalog.summary
+    };
+  };
+  const page = paginateProjects(
+    scanSource,
+    {
+      cursor: params.get("cursor") ?? void 0,
+      limit: limit.value,
+      query: params
+    },
+    loadSnapshot
+  );
+  if (page.kind === "invalid_cursor") {
+    reportInvalidQueryParameter("projects", "cursor", "rejected");
+    return c.json({ error: "cursor is invalid for this request" }, 400);
+  }
+  if (page.kind === "stale_snapshot") {
+    return c.json({ error: "project snapshot expired; restart pagination" }, 409);
+  }
+  return c.json({
+    projects: page.items,
+    summary: page.view,
+    ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
   });
 }
-function parseBookmarkImport(value) {
-  if (!isRecord(value)) return null;
-  const reference = parseBookmarkReference(value);
-  if (!reference) return null;
-  const timestamp = value.bookmarkedAt ?? value.bookmarked_at;
-  if (timestamp != null && (typeof timestamp !== "number" || !Number.isFinite(timestamp))) {
-    return null;
+
+// 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, "start");
+  const to = parseRequiredDate(request.to, "end");
+  if (from != null && to != null && from > to) {
+    throw new Error("Invalid time window: from must not be after 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 calendarFrom = addCalendarDays(startOfCalendarDay(to ?? now), -(days - 1));
+  return Number.isFinite(calendarFrom) ? { from: calendarFrom, to, days } : { to };
+}
+function resolveDashboardWindow(request) {
+  const now = request.now ?? Date.now();
+  const to = request.window.to ?? now;
+  const hasQueryDays = Boolean(request.days?.trim());
+  const parsedDays = hasQueryDays ? parseDays(request.days) : void 0;
+  if (request.window.hasExplicitFrom && request.window.from != null) {
+    return { from: request.window.from, to, days: countCalendarDays(request.window.from, to) };
+  }
+  const days = parsedDays ?? request.defaultDays;
+  if (days === 0) {
+    return { to, days: 0 };
+  }
+  if (days != null && days > 0) {
+    return {
+      from: addCalendarDays(startOfCalendarDay(to), -(days - 1)),
+      to,
+      days
+    };
+  }
+  if (request.window.from != null) {
+    return { from: request.window.from, to, days: countCalendarDays(request.window.from, to) };
   }
   return {
-    reference,
-    bookmarkedAt: typeof timestamp === "number" ? timestamp : Date.now()
+    from: addCalendarDays(startOfCalendarDay(to), -(DEFAULT_DASHBOARD_DAYS - 1)),
+    to,
+    days: DEFAULT_DASHBOARD_DAYS
   };
 }
-function sanitizeClientLogData(value) {
-  if (!isRecord(value)) return {};
-  return Object.fromEntries(
-    Object.entries(value).slice(0, 30).map(([key, item]) => {
-      if (typeof item === "string") return [key, item.slice(0, 300)];
-      if (typeof item === "number" || typeof item === "boolean" || item == null) {
-        return [key, item];
-      }
-      return [key, String(item).slice(0, 300)];
-    })
-  );
+function parseRequiredDate(value, boundary) {
+  if (!value) return void 0;
+  const calendarBoundary = parseCalendarDayBoundary(value, boundary);
+  if (calendarBoundary === null) throw new Error(`Invalid date: ${value}`);
+  if (calendarBoundary != null) return calendarBoundary;
+  const timestamp = new Date(value).getTime();
+  if (Number.isNaN(timestamp)) throw new Error(`Invalid date: ${value}`);
+  return timestamp;
+}
+function parseDays(value) {
+  if (value == null) return void 0;
+  const normalized = value.trim();
+  if (!/^-?\d+$/.test(normalized)) return void 0;
+  const days = Number(normalized);
+  return Number.isSafeInteger(days) && Number.isSafeInteger(days * DAY_MS) ? days : void 0;
 }
 
-// src/api/session-detail-stream.ts
-var SESSION_DETAIL_STREAM_BATCH_CHARS = 64 * 1024;
-function createSessionDetailJsonResponse(data, messages) {
-  const encoder = new TextEncoder();
-  const headerJson = JSON.stringify(data);
-  const headerPrefix = headerJson === "{}" ? '{"messages":[' : `${headerJson.slice(0, -1)},"messages":[`;
-  const iterator = messages[Symbol.iterator]();
-  let wroteHeader = false;
-  let wroteMessage = false;
-  return new Response(
-    new ReadableStream({
-      pull(controller) {
-        if (!wroteHeader) {
-          controller.enqueue(encoder.encode(headerPrefix));
-          wroteHeader = true;
-          return;
-        }
-        const batch = [];
-        let batchLength = 0;
-        let next;
-        try {
-          next = iterator.next();
-          while (!next.done) {
-            const prefix = wroteMessage ? "," : "";
-            batch.push(prefix, next.value);
-            batchLength += prefix.length + next.value.length;
-            wroteMessage = true;
-            if (batchLength >= SESSION_DETAIL_STREAM_BATCH_CHARS) break;
-            next = iterator.next();
-          }
-        } catch (error) {
-          try {
-            iterator.return?.();
-          } catch {
-          }
-          controller.error(error);
-          return;
-        }
-        if (next.done) {
-          batch.push("]}");
-          controller.enqueue(encoder.encode(batch.join("")));
-          controller.close();
-          return;
-        }
-        controller.enqueue(encoder.encode(batch.join("")));
-      },
-      cancel() {
-        iterator.return?.();
-      }
-    }),
-    { headers: { "Content-Type": "application/json; charset=UTF-8" } }
+// ../core/dist/runtime/search.mjs
+function executeSessionSearch(query, options, snapshot, context = {}) {
+  const merged = mergeSearchQueryOptions(query, options);
+  if (!needsIndexedSearch(merged.text, merged.options)) {
+    return searchRecentSessions(snapshot, merged.options, context);
+  }
+  return searchIndexedSessions(
+    query,
+    merged.text,
+    merged.parsed,
+    merged.options,
+    context.queryScope
   );
 }
-
-// src/api/search-result-merge.ts
-function withParentContext(results, getSessionTree, aliases) {
-  if (!results.some((result) => result.session.parent_reference)) return results;
-  const byRouteKey = getSessionTree().byRouteKey;
-  return results.map((result) => {
-    const parentReference = result.session.parent_reference;
-    if (!parentReference) return result;
-    const parent = byRouteKey.get(formatSessionReference(parentReference))?.session;
-    if (!parent) return result;
-    const reference = normalizeSessionReference(parentReference);
-    return { ...result, parent: { reference, title: aliases.get(reference) ?? parent.title } };
-  });
+function needsIndexedSearch(textQuery, options) {
+  return Boolean(textQuery || options.file || options.fileKind || options.tools?.length);
 }
-var ALIAS_SEARCH_RESULT_SHARE = 0.25;
-function searchResultKey(result) {
-  return `${result.reference.agentName}\0${result.reference.sessionId}`;
+function matchesRecentSearchFilters(session, options, projectScope, inclusiveCost) {
+  if (options.projectKind || options.projectKey) {
+    if (!options.projectKind || !options.projectKey || !matchesProjectIdentity(session.project_identity, {
+      kind: options.projectKind,
+      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 (!sessionMatchesSearchCost(session, options, inclusiveCost)) return false;
+  return true;
 }
-function uniqueSearchResults(results) {
-  const seen = /* @__PURE__ */ new Set();
-  return results.filter((result) => {
-    const key = searchResultKey(result);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
+function matchesSessionSearchFilters(agentName, session, options, projectScope = null, inclusiveCost = session.stats.total_cost) {
+  if (options.agent && agentName !== options.agent) return false;
+  const activity = getSessionActivityTime(session);
+  if (options.from != null && activity < options.from) return false;
+  if (options.to != null && activity > options.to) return false;
+  return matchesRecentSearchFilters(session, options, projectScope, inclusiveCost);
 }
-function mergeAliasSearchResults(rankedResults, aliasResults, limit) {
-  if (limit <= 0) return [];
-  const ranked = uniqueSearchResults(rankedResults);
-  const rankedKeys = new Set(ranked.map(searchResultKey));
-  const aliases = uniqueSearchResults(aliasResults).filter(
-    (result) => !rankedKeys.has(searchResultKey(result))
+function filterSessionSearchCandidates(candidates, options, context = {}) {
+  const projectScope = options.projectScope ?? null;
+  const sessionSnapshot = context.sessionSnapshot ?? candidates.map((candidate) => candidate.session);
+  const inclusiveCosts = buildInclusiveCostLookup(sessionSnapshot, options, context.sessionTree);
+  const headMatches = candidates.filter(
+    (candidate) => matchesSessionQueryScope(candidate.session, context.queryScope) && matchesSessionSearchFilters(
+      candidate.reference.agentName,
+      candidate.session,
+      options,
+      projectScope,
+      inclusiveCostFor(candidate.reference.agentName, candidate.session, inclusiveCosts)
+    )
   );
-  if (ranked.length === 0) return aliases.slice(0, limit);
-  if (aliases.length === 0) return ranked.slice(0, limit);
-  const aliasQuota = Math.min(
-    limit - 1,
-    Math.max(1, Math.floor(limit * ALIAS_SEARCH_RESULT_SHARE))
+  if (!options.file && !options.fileKind && !options.tools?.length) return headMatches;
+  const indexedMatches = filterIndexedSessionReferences(
+    headMatches.map((candidate) => ({
+      agentName: candidate.reference.agentName,
+      sessionId: candidate.reference.sessionId
+    })),
+    {
+      file: options.file,
+      fileKind: options.fileKind,
+      tools: options.tools
+    }
   );
-  const rankedQuota = limit - aliasQuota;
-  return [
-    ...ranked.slice(0, rankedQuota),
-    ...aliases.slice(0, aliasQuota),
-    ...ranked.slice(rankedQuota),
-    ...aliases.slice(aliasQuota)
-  ].slice(0, limit);
+  return headMatches.filter(
+    (candidate) => indexedMatches.has(getSessionReferenceKey(candidate.reference))
+  );
+}
+function searchRecentSessions(snapshot, options, context) {
+  const limit = Math.max(0, Math.trunc(options.limit ?? 50));
+  if (limit === 0) return [];
+  const projectScope = options.projectScope ?? null;
+  const inclusiveCosts = buildInclusiveCostLookup(snapshot.sessions, options, context.sessionTree);
+  const sessions = options.agent ? snapshot.byAgent[options.agent] ?? [] : snapshot.sessions;
+  const results = [];
+  for (const session of sessions) {
+    const agentName = options.agent ?? session.reference.agentName;
+    if (!matchesSessionQueryScope(session, context.queryScope) || !matchesSessionSearchFilters(
+      agentName,
+      session,
+      options,
+      projectScope,
+      inclusiveCostFor(agentName, session, inclusiveCosts)
+    )) {
+      continue;
+    }
+    results.push({
+      reference: session.reference,
+      session,
+      snippet: `Recent session \xB7 ${session.directory}`,
+      snippetHighlights: [],
+      matchType: "recent"
+    });
+    if (results.length >= limit) break;
+  }
+  return results;
+}
+function buildInclusiveCostLookup(sessions, options, sessionTree) {
+  if (options.costMin == null && options.costMax == null) return null;
+  return (sessionTree ?? buildSessionTree(sessions)).byRouteKey;
+}
+function inclusiveCostFor(agentName, session, lookup) {
+  return lookup?.get(getSessionReferenceKey({ agentName, sessionId: session.reference.sessionId }))?.inclusiveStats.cost ?? session.stats.total_cost;
+}
+function deriveFileQuery(query, parsed, options) {
+  return options.file ?? (!parsed.text ? parsed.filters.file : void 0) ?? (!parsed.hasQualifiers && query ? parsed.text || query : "");
+}
+function mergeSearchResultSources(results, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const result of results) {
+    const key = getSessionReferenceKey(result.reference);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(result);
+    if (merged.length >= limit) break;
+  }
+  return merged;
+}
+function canSkipSessionsSearch(fileQuery, textQuery) {
+  return Boolean(fileQuery && !textQuery);
+}
+function searchIndexedSessions(query, textQuery, parsed, options, queryScope) {
+  const fileQuery = deriveFileQuery(query, parsed, options);
+  const fileResults = fileQuery ? searchFileActivitySessions(fileQuery, options, queryScope) : [];
+  const sessionResults = canSkipSessionsSearch(fileQuery, textQuery) ? [] : searchSessions(query, options, queryScope);
+  const textMatchReferences = textQuery && options.file ? new Set(sessionResults.map((result) => getSessionReferenceKey(result.reference))) : null;
+  const matchingFileResults = textMatchReferences ? fileResults.filter(
+    (result) => textMatchReferences.has(getSessionReferenceKey(result.reference))
+  ) : fileResults;
+  return mergeSearchResultSources([...matchingFileResults, ...sessionResults], options.limit ?? 50);
 }
 
 // ../core/dist/runtime/state.mjs
@@ -1471,99 +1536,243 @@ function findAliasSearchResults(query, options, scanResult, aliases, context = {
   }
   return filterSessionSearchCandidates(results, search.options, {
     sessionSnapshot: scanResult.sessions,
-    sessionTree: context.sessionTree
+    sessionTree: context.sessionTree,
+    queryScope: context.queryScope
   }).sort((a, b) => getSessionActivityTime(b.session) - getSessionActivityTime(a.session));
 }
 
-// src/api/handlers.ts
-var KNOWN_AGENT_NAMES = getAgentInfoMap({}).map((agent) => agent.name);
-var KNOWN_AGENT_NAME_SET = new Set(KNOWN_AGENT_NAMES);
-async function resolveProjectScope(cwd, sessions, resolver, signal) {
-  const normalizedCwd = normalizeProjectDirectory(cwd);
-  const matchingSession = sessions.find(
-    (session) => normalizeProjectDirectory(session.directory) === normalizedCwd && session.project_identity_resolver_revision === PROJECT_IDENTITY_RESOLVER_REVISION && Boolean(session.project_identity_input_signature)
+// src/api/dashboard-handler.ts
+function handleGetDashboard(c, scanSource, defaults = {}) {
+  const scanResult = scanSource.getSnapshot();
+  const projectIdentity = parseProjectIdentityFilter(
+    c.req.query("projectKind"),
+    c.req.query("projectKey")
   );
-  if (matchingSession) {
-    return createProjectScopeMatcherFromIdentity(cwd, matchingSession.project_identity);
-  }
-  if (!resolver) throw new Error("Project identity resolver is unavailable");
-  const projection = await resolver.resolve(cwd, signal);
-  return createProjectScopeMatcherFromIdentity(cwd, projection.identity);
-}
-function reportProjectScopeResolutionFailure(endpoint, error) {
-  appLogger.warn("api.project_scope.unavailable", {
-    endpoint,
-    error: error instanceof Error ? error.message : String(error)
-  });
-}
-function projectScopeResolutionFailureResponse(c, endpoint, error) {
-  if (error instanceof ProjectIdentityRequestAbortedError) throw error;
-  reportProjectScopeResolutionFailure(endpoint, error);
-  if (error instanceof ProjectIdentityQueueFullError) {
-    return c.json({ error: "Project scope busy; retry later" }, 429);
+  if (projectIdentity === null) {
+    return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
   }
-  return c.json({ error: "Project scope unavailable" }, 503);
-}
-function reportInvalidQueryParameter(endpoint, parameter, validationOutcome) {
-  appLogger.warn("api.query_parameter.invalid", {
-    endpoint,
-    parameter,
-    validation_outcome: validationOutcome
+  const dateWindow = parseDateWindowRequest(c, "dashboard", defaults);
+  if (dateWindow.kind === "rejected") return dateWindow.response;
+  const { from, to, days } = resolveTimeWindow({
+    mode: "dashboard",
+    window: dateWindow,
+    days: c.req.query("days"),
+    defaultDays: defaults.days
   });
-}
-function parseDateWindowRequest(c, endpoint, defaults) {
-  const outcome = parseDateWindow(searchParams(c), defaults);
-  if (outcome.kind === "valid") return outcome;
-  reportInvalidQueryParameter(endpoint, outcome.parameter, "rejected");
-  return {
-    kind: "rejected",
-    response: c.json({ error: `${outcome.parameter} ${outcome.error}` }, 400)
+  const scope = {
+    agent: optionalQueryValue(c.req.query("agent"))?.toLowerCase(),
+    projectKind: projectIdentity?.kind,
+    projectKey: projectIdentity?.key
   };
+  const compare = from == null ? void 0 : { from: addCalendarDays(from, -days), to: from - 1 };
+  const fixedTo = dateWindow.to;
+  const cacheTo = fixedTo ?? startOfCalendarDay(to);
+  const analyticsRevision = getAnalyticsRevision();
+  const costFacts = getSnapshotCostFacts(
+    scanSource,
+    scanResult.sessions,
+    compare?.from ?? from,
+    from == null && fixedTo == null ? void 0 : to,
+    from == null && fixedTo == null ? void 0 : cacheTo,
+    analyticsRevision
+  );
+  const aggregate = getSnapshotAggregation(
+    scanSource,
+    scanResult.sessions,
+    [
+      "dashboard",
+      scope.agent,
+      scope.projectKind,
+      scope.projectKey,
+      from,
+      cacheTo,
+      compare?.from,
+      compare?.to,
+      analyticsRevision
+    ],
+    () => {
+      const agentInfo = getAgentInfoMap({});
+      const agentInfoMap = new Map(agentInfo.map((agent) => [agent.name, agent]));
+      return buildDashboard(scanResult.sessions, {
+        byAgentNames: Object.keys(scanResult.byAgent),
+        scope,
+        from,
+        to,
+        agentInfoMap,
+        compare,
+        costFacts
+      });
+    }
+  );
+  const storageAggregation = getDashboardStorageAggregation(
+    scanSource,
+    scanResult.sessions,
+    scope,
+    from,
+    to,
+    cacheTo,
+    analyticsRevision
+  );
+  const data = {
+    ...aggregate,
+    ...storageAggregation,
+    window: { from, to, days, compareFrom: compare?.from, compareTo: compare?.to }
+  };
+  const aliases = loadAliasView();
+  return c.json({
+    ...data,
+    recentSessions: data.recentSessions.map(
+      (item) => toPublicReferencedSessionHead({
+        ...item,
+        session: aliases.decorate(item.session, item.reference)
+      })
+    ),
+    recentFileActivities: data.recentFileActivities.map(
+      (activity) => toPublicReferencedSessionHead(decorateFileActivity(activity, aliases))
+    )
+  });
 }
-function getSessionHeadReference(session) {
-  return session.reference;
+
+// src/api/search-result-merge.ts
+function withParentContext(results, getSessionTree, aliases) {
+  if (!results.some((result) => result.session.parent_reference)) return results;
+  const byRouteKey = getSessionTree().byRouteKey;
+  return results.map((result) => {
+    const parentReference = result.session.parent_reference;
+    if (!parentReference) return result;
+    const parent = byRouteKey.get(formatSessionReference(parentReference))?.session;
+    if (!parent) return result;
+    const reference = normalizeSessionReference(parentReference);
+    return { ...result, parent: { reference, title: aliases.get(reference) ?? parent.title } };
+  });
 }
-function handleGetConfig(c, defaults) {
-  const payload = {
-    window: {
-      from: defaults.from,
-      to: defaults.to,
-      days: defaults.days
-    }
-  };
-  return c.json(payload);
+var ALIAS_SEARCH_RESULT_SHARE = 0.25;
+function searchResultKey(result) {
+  return `${result.reference.agentName}\0${result.reference.sessionId}`;
 }
-function handleGetScanStatus(c, scanSource) {
-  return c.json(scanSource.getScanStatus());
+function uniqueSearchResults(results) {
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((result) => {
+    const key = searchResultKey(result);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
-function handleGetAgents(c, scanSource, defaults = {}) {
+function mergeAliasSearchResults(rankedResults, aliasResults, limit) {
+  if (limit <= 0) return [];
+  const ranked = uniqueSearchResults(rankedResults);
+  const rankedKeys = new Set(ranked.map(searchResultKey));
+  const aliases = uniqueSearchResults(aliasResults).filter(
+    (result) => !rankedKeys.has(searchResultKey(result))
+  );
+  if (ranked.length === 0) return aliases.slice(0, limit);
+  if (aliases.length === 0) return ranked.slice(0, limit);
+  const aliasQuota = Math.min(
+    limit - 1,
+    Math.max(1, Math.floor(limit * ALIAS_SEARCH_RESULT_SHARE))
+  );
+  const rankedQuota = limit - aliasQuota;
+  return [
+    ...ranked.slice(0, rankedQuota),
+    ...aliases.slice(0, aliasQuota),
+    ...ranked.slice(rankedQuota),
+    ...aliases.slice(aliasQuota)
+  ].slice(0, limit);
+}
+
+// src/api/search-handlers.ts
+async function handleSearchSessions(c, scanSource, defaults = {}, resolver) {
+  const query = c.req.query("q")?.trim() ?? "";
   const scanResult = scanSource.getSnapshot();
-  const window = parseDateWindowRequest(c, "agents", defaults);
+  const sessionQuery = parseSessionQuery(searchParams(c), KNOWN_AGENT_NAMES, SEARCH_LIMIT_POLICY);
+  if (sessionQuery.limit.kind === "invalid") {
+    reportInvalidQueryParameter("search", "limit", "rejected");
+    return c.json({ error: sessionQuery.limit.error }, 400);
+  }
+  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 window = parseDateWindowRequest(c, "search", defaults);
   if (window.kind === "rejected") return window.response;
-  const { from, to } = window;
-  const agents = getSnapshotAggregation(
-    scanSource,
-    scanResult.sessions,
-    ["agents", from, to],
-    () => {
-      const counts = Object.fromEntries(
-        Object.entries(scanResult.byAgent).map(([agentName, sessions]) => [
-          agentName,
-          filterSessionsByActivityWindow(sessions, from, to).length
-        ])
+  if (sessionQuery.agent.kind === "unknown") {
+    reportInvalidQueryParameter("search", "agent", "empty_result");
+    return c.json({ results: [] });
+  }
+  const searchRequestOptions = parseSearchOptions(
+    c,
+    window,
+    {
+      agent: sessionQuery.agent.kind === "known" ? sessionQuery.agent.agentName : void 0,
+      limit: sessionQuery.limit.value
+    },
+    projectIdentity
+  );
+  const cwd = getSearchProjectDirectory(query, searchRequestOptions);
+  let projectScope;
+  if (cwd) {
+    try {
+      projectScope = await resolveProjectScope(
+        cwd,
+        scanResult.sessions,
+        resolver,
+        c.req.raw.signal
       );
-      return getAgentInfoMap(counts);
+    } catch (error) {
+      return projectScopeResolutionFailureResponse(c, "search", error);
     }
+  }
+  const { cwd: _cwd, ...searchOptions } = searchRequestOptions;
+  const resolvedSearchOptions = projectScope ? { ...searchOptions, projectScope } : searchOptions;
+  const aliases = loadAliasView();
+  let sessionTree;
+  const getSessionTree = () => sessionTree ??= getSnapshotSessionTree(scanSource, scanResult.sessions);
+  const effectiveSearchOptions = mergeSearchQueryOptions(query, resolvedSearchOptions).options;
+  const searchContext = {
+    queryScope: scanSource.queryScope,
+    ...effectiveSearchOptions.costMin != null || effectiveSearchOptions.costMax != null ? { sessionTree: getSessionTree() } : {}
+  };
+  const searchResults = executeSessionSearch(
+    query,
+    resolvedSearchOptions,
+    scanResult,
+    searchContext
   );
-  return c.json(agents);
+  const results = searchResults.map((result) => ({
+    ...result,
+    session: aliases.decorate(result.session, result.reference)
+  }));
+  const aliasResults = findAliasSearchResults(
+    query,
+    resolvedSearchOptions,
+    scanResult,
+    aliases,
+    searchContext
+  );
+  const mergedResults = mergeAliasSearchResults(
+    results,
+    aliasResults,
+    resolvedSearchOptions.limit ?? 50
+  );
+  return c.json({
+    results: withParentContext(mergedResults, getSessionTree, aliases).map(
+      toPublicReferencedSessionHead
+    )
+  });
 }
-function handleGetProjects(c, scanSource, defaults = {}) {
-  const scanResult = scanSource.getSnapshot();
-  const params = searchParams(c);
-  const limit = parseLimit(params.get("limit"), PROJECT_PAGE_LIMIT_POLICY);
-  if (limit.kind === "invalid") {
-    reportInvalidQueryParameter("projects", "limit", "rejected");
-    return c.json({ error: limit.error }, 400);
+async function handleGetFileActivity(c, scanSource, defaults = {}, resolver) {
+  const sessionQuery = parseSessionQuery(
+    searchParams(c),
+    KNOWN_AGENT_NAMES,
+    FILE_ACTIVITY_LIMIT_POLICY
+  );
+  if (sessionQuery.limit.kind === "invalid") {
+    reportInvalidQueryParameter("file-activity", "limit", "rejected");
+    return c.json({ error: sessionQuery.limit.error }, 400);
   }
   const projectIdentity = parseProjectIdentityFilter(
     c.req.query("projectKind"),
@@ -1572,51 +1781,185 @@ function handleGetProjects(c, scanSource, defaults = {}) {
   if (projectIdentity === null) {
     return c.json({ error: "projectKind and projectKey must form a valid project identity" }, 400);
   }
-  const window = parseDateWindowRequest(c, "projects", defaults);
+  const window = parseDateWindowRequest(c, "file-activity", defaults);
   if (window.kind === "rejected") return window.response;
-  const { from, to } = window;
-  const analyticsRevision = getAnalyticsRevision();
-  const catalog = getSnapshotAggregation(
-    scanSource,
-    scanResult.sessions,
-    ["projects", from, to, analyticsRevision],
-    () => {
-      const tree = getSnapshotSessionTree(scanSource, scanResult.sessions);
-      const costFacts = listDashboardCostFacts({ from, to, includeModelCosts: false });
-      const projects2 = attachProjectMetricsFromTree(
-        listCachedProjectGroups(scanResult.sessions),
-        tree,
-        from,
-        to,
-        costFacts
-      ).filter(
-        (project) => project.sessionCount > 0 || project.messages > 0 || project.tokens > 0 || project.cost > 0
-      );
-      return { projects: projects2, summary: summarizeProjects(projects2) };
+  if (sessionQuery.agent.kind === "unknown") {
+    reportInvalidQueryParameter("file-activity", "agent", "empty_result");
+    return c.json({ activity: [] });
+  }
+  const cwd = optionalQueryValue(c.req.query("cwd"));
+  let projectScope;
+  if (cwd) {
+    try {
+      projectScope = await resolveProjectScope(cwd, [], resolver, c.req.raw.signal);
+    } catch (error) {
+      return projectScopeResolutionFailureResponse(c, "file-activity", error);
+    }
+  }
+  const aliases = loadAliasView();
+  return c.json({
+    activity: listFileActivity(
+      {
+        agent: sessionQuery.agent.kind === "known" ? sessionQuery.agent.agentName : void 0,
+        sessionId: optionalQueryValue(c.req.query("sessionId")),
+        projectKind: projectIdentity?.kind,
+        projectKey: projectIdentity?.key,
+        project: optionalQueryValue(c.req.query("project")),
+        projectScope,
+        path: optionalQueryValue(c.req.query("path")),
+        kind: parseFileActivityKind(optionalQueryValue(c.req.query("kind"))),
+        from: window.from,
+        to: window.to,
+        limit: sessionQuery.limit.value
+      },
+      scanSource.queryScope
+    ).map((activity) => toPublicReferencedSessionHead(decorateFileActivity(activity, aliases)))
+  });
+}
+
+// src/session-detail-loader.ts
+import { Worker as Worker2 } from "worker_threads";
+var SessionDetailBusyError = class extends Error {
+  constructor() {
+    super("Session detail workers are busy");
+  }
+};
+var MAX_DETAIL_WORKERS = 2;
+var DETAIL_TIMEOUT_MS = 6e4;
+var ThreadSessionDetailLoader = class {
+  constructor(workerUrl = new URL("./session-detail-worker.js", import.meta.url)) {
+    this.workerUrl = workerUrl;
+  }
+  workerUrl;
+  workers = /* @__PURE__ */ new Set();
+  shutdownController = new AbortController();
+  load = async (snapshot, reference, options = {}, signal) => {
+    const requestSignal = signal ? AbortSignal.any([signal, this.shutdownController.signal]) : this.shutdownController.signal;
+    requestSignal.throwIfAborted();
+    const cached = materializeCachedSessionDetailResponse(snapshot, reference, options);
+    if (cached) return cached;
+    if (this.workers.size >= MAX_DETAIL_WORKERS) throw new SessionDetailBusyError();
+    const agent = snapshot.agents.find((item) => item.name === reference.agentName);
+    const head = snapshot.byAgent[reference.agentName]?.find(
+      (item) => item.reference.sessionId === reference.sessionId
+    );
+    const meta = agent?.getSessionCacheMeta(reference.sessionId);
+    const request = {
+      reference,
+      head,
+      meta: meta ? { [reference.sessionId]: meta } : {},
+      messageCursor: options.messageCursor,
+      pricingGenerationId: getPricingGeneration().id,
+      logContext: appLogger.captureContext()
+    };
+    appLogger.info("session_detail.worker.started", {
+      agent: reference.agentName,
+      session_id: reference.sessionId
+    });
+    const worker = new Worker2(this.workerUrl, { workerData: request });
+    const exited = new Promise(
+      (resolve4) => worker.once("exit", () => {
+        this.workers.delete(worker);
+        resolve4();
+      })
+    );
+    let timeout;
+    let abort = () => {
+    };
+    try {
+      return await new Promise((resolve4, reject) => {
+        abort = () => reject(requestSignal.reason);
+        requestSignal.addEventListener("abort", abort, { once: true });
+        this.workers.add(worker);
+        timeout = setTimeout(
+          () => reject(new Error("Session detail loading timed out")),
+          DETAIL_TIMEOUT_MS
+        );
+        timeout.unref();
+        worker.on("message", (message) => {
+          if (appLogger.consumeWorkerMessage(message)) return;
+          if (message.type === "result") resolve4(message.result);
+          else if (message.type === "error") reject(new Error(message.error));
+        });
+        worker.once("error", reject);
+        worker.once(
+          "exit",
+          (code) => reject(new Error(`Session detail worker exited without a result (${code})`))
+        );
+      });
+    } finally {
+      clearTimeout(timeout);
+      requestSignal.removeEventListener("abort", abort);
+      await terminateWorkerAfterLogDrain(worker);
+      await exited;
     }
+  };
+  async shutdown() {
+    this.shutdownController.abort();
+    await Promise.allSettled(
+      [...this.workers].map((worker) => terminateWorkerAfterLogDrain(worker))
+    );
+  }
+};
+
+// src/api/session-detail-stream.ts
+var SESSION_DETAIL_STREAM_BATCH_CHARS = 64 * 1024;
+function createSessionDetailJsonResponse(data, messages) {
+  const encoder = new TextEncoder();
+  const headerJson = JSON.stringify(data);
+  const headerPrefix = headerJson === "{}" ? '{"messages":[' : `${headerJson.slice(0, -1)},"messages":[`;
+  const iterator = messages[Symbol.iterator]();
+  let wroteHeader = false;
+  let wroteMessage = false;
+  return new Response(
+    new ReadableStream({
+      pull(controller) {
+        if (!wroteHeader) {
+          controller.enqueue(encoder.encode(headerPrefix));
+          wroteHeader = true;
+          return;
+        }
+        const batch = [];
+        let batchLength = 0;
+        let next;
+        try {
+          next = iterator.next();
+          while (!next.done) {
+            const prefix = wroteMessage ? "," : "";
+            batch.push(prefix, next.value);
+            batchLength += prefix.length + next.value.length;
+            wroteMessage = true;
+            if (batchLength >= SESSION_DETAIL_STREAM_BATCH_CHARS) break;
+            next = iterator.next();
+          }
+        } catch (error) {
+          try {
+            iterator.return?.();
+          } catch {
+          }
+          controller.error(error);
+          return;
+        }
+        if (next.done) {
+          batch.push("]}");
+          controller.enqueue(encoder.encode(batch.join("")));
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(batch.join("")));
+      },
+      cancel() {
+        iterator.return?.();
+      }
+    }),
+    { headers: { "Content-Type": "application/json; charset=UTF-8" } }
   );
-  const projects = projectIdentity ? catalog.projects.filter(
-    (project) => project.identityKind === projectIdentity.kind && project.identityKey === projectIdentity.key
-  ) : catalog.projects;
-  const page = paginateSnapshot(projects, {
-    cursor: params.get("cursor") ?? void 0,
-    limit: limit.value,
-    query: params,
-    snapshotIdentity: scanResult.sessions,
-    viewIdentity: catalog.projects
-  });
-  if (page.kind === "invalid_cursor") {
-    reportInvalidQueryParameter("projects", "cursor", "rejected");
-    return c.json({ error: "cursor is invalid for this request" }, 400);
-  }
-  if (page.kind === "stale_snapshot") {
-    return c.json({ error: "project snapshot changed; restart pagination" }, 409);
-  }
-  return c.json({
-    projects: page.items,
-    summary: projectIdentity ? summarizeProjects(projects) : catalog.summary,
-    ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
-  });
+}
+
+// src/api/session-handlers.ts
+var paginateSessions = createSnapshotPaginator();
+function getSessionHeadReference(session) {
+  return session.reference;
 }
 async function handleGetSessions(c, scanSource, defaults = {}, resolver) {
   const scanResult = scanSource.getSnapshot();
@@ -1656,213 +1999,92 @@ async function handleGetSessions(c, scanSource, defaults = {}, resolver) {
   if (sessionQuery.agent.kind === "unknown") {
     reportInvalidQueryParameter("sessions", "agent", "empty_result");
   }
-  const agentFilter = sessionQuery.agent.kind === "known" ? sessionQuery.agent.agentName : sessionQuery.agent.kind;
-  let sessions = getSnapshotAggregation(
-    scanSource,
-    scanResult.sessions,
-    [
-      "sessions",
-      agentFilter,
-      projectIdentity?.kind,
-      projectIdentity?.key,
-      projectScope?.identity.kind,
-      projectScope?.identity.key,
-      projectScope?.path,
-      tag,
-      from,
-      to
-    ],
-    () => {
-      let filtered = sessionQuery.agent.kind === "all" ? scanResult.sessions : sessionQuery.agent.kind === "known" ? scanResult.byAgent[sessionQuery.agent.agentName] ?? [] : [];
-      if (projectIdentity) {
-        filtered = filtered.filter(
-          (session) => matchesProjectIdentity(session.project_identity, projectIdentity)
-        );
-      } else if (projectScope) {
-        filtered = filtered.filter((session) => matchesProjectScope(session, projectScope));
+  const loadSnapshot = () => {
+    const agentFilter = sessionQuery.agent.kind === "known" ? sessionQuery.agent.agentName : sessionQuery.agent.kind;
+    let sessions2 = getSnapshotAggregation(
+      scanSource,
+      scanResult.sessions,
+      [
+        "sessions",
+        agentFilter,
+        projectIdentity?.kind,
+        projectIdentity?.key,
+        projectScope?.identity.kind,
+        projectScope?.identity.key,
+        projectScope?.path,
+        tag,
+        from,
+        to
+      ],
+      () => {
+        let filtered = sessionQuery.agent.kind === "all" ? scanResult.sessions : sessionQuery.agent.kind === "known" ? scanResult.byAgent[sessionQuery.agent.agentName] ?? [] : [];
+        if (projectIdentity) {
+          filtered = filtered.filter(
+            (session) => matchesProjectIdentity(session.project_identity, projectIdentity)
+          );
+        } else if (projectScope) {
+          filtered = filtered.filter(
+            (session) => matchesProjectScope(session, projectScope)
+          );
+        }
+        filtered = filterSessionsByActivityWindow(filtered, from, to);
+        return tag ? filtered.filter((session) => session.smart_tags?.includes(tag)) : filtered;
       }
-      filtered = filterSessionsByActivityWindow(filtered, from, to);
-      return tag ? filtered.filter((session) => session.smart_tags?.includes(tag)) : filtered;
+    );
+    const aliases2 = loadAliasView();
+    if (q) {
+      sessions2 = sessions2.filter((session) => {
+        const alias = aliases2.get(getSessionHeadReference(session));
+        return session.title.toLowerCase().includes(q) || alias?.toLowerCase().includes(q);
+      });
     }
-  );
-  const aliases = loadAliasView();
-  if (q) {
-    sessions = sessions.filter((session) => {
-      const alias = aliases.get(getSessionHeadReference(session));
-      return session.title.toLowerCase().includes(q) || alias?.toLowerCase().includes(q);
-    });
-  }
+    return { items: sessions2, view: aliases2 };
+  };
   if (paginationRequested) {
-    const page = paginateSnapshot(sessions, {
-      cursor: params.get("cursor") ?? void 0,
-      limit: sessionQuery.limit.value,
-      query: params,
-      snapshotIdentity: scanResult.sessions,
-      viewIdentity: aliases
-    });
+    const page = paginateSessions(
+      scanSource,
+      {
+        cursor: params.get("cursor") ?? void 0,
+        limit: sessionQuery.limit.value,
+        query: params
+      },
+      loadSnapshot
+    );
     if (page.kind === "invalid_cursor") {
       reportInvalidQueryParameter("sessions", "cursor", "rejected");
       return c.json({ error: "cursor is invalid for this request" }, 400);
     }
     if (page.kind === "stale_snapshot") {
-      return c.json({ error: "session snapshot changed; restart pagination" }, 409);
+      return c.json({ error: "session snapshot expired; restart pagination" }, 409);
     }
     return c.json({
       sessions: page.items.map(
-        (session) => toPublicSessionHead(aliases.decorate(session, getSessionHeadReference(session)))
+        (session) => toPublicSessionHead(page.view.decorate(session, getSessionHeadReference(session)))
       ),
       ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
     });
   }
+  const { items: sessions, view: aliases } = loadSnapshot();
   return c.json({
     sessions: sessions.map(
       (session) => toPublicSessionHead(aliases.decorate(session, getSessionHeadReference(session)))
     )
   });
 }
-async function handleSearchSessions(c, scanSource, defaults = {}, resolver) {
-  const query = c.req.query("q")?.trim() ?? "";
-  const scanResult = scanSource.getSnapshot();
-  const sessionQuery = parseSessionQuery(searchParams(c), KNOWN_AGENT_NAMES, SEARCH_LIMIT_POLICY);
-  if (sessionQuery.limit.kind === "invalid") {
-    reportInvalidQueryParameter("search", "limit", "rejected");
-    return c.json({ error: sessionQuery.limit.error }, 400);
-  }
-  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 window = parseDateWindowRequest(c, "search", defaults);
-  if (window.kind === "rejected") return window.response;
-  if (sessionQuery.agent.kind === "unknown") {
-    reportInvalidQueryParameter("search", "agent", "empty_result");
-    return c.json({ results: [] });
-  }
-  const searchRequestOptions = parseSearchOptions(
-    c,
-    window,
-    {
-      agent: sessionQuery.agent.kind === "known" ? sessionQuery.agent.agentName : void 0,
-      limit: sessionQuery.limit.value
-    },
-    projectIdentity
-  );
-  const cwd = getSearchProjectDirectory(query, searchRequestOptions);
-  let projectScope;
-  if (cwd) {
-    try {
-      projectScope = await resolveProjectScope(
-        cwd,
-        scanResult.sessions,
-        resolver,
-        c.req.raw.signal
-      );
-    } catch (error) {
-      return projectScopeResolutionFailureResponse(c, "search", error);
-    }
-  }
-  const { cwd: _cwd, ...searchOptions } = searchRequestOptions;
-  const resolvedSearchOptions = projectScope ? { ...searchOptions, projectScope } : searchOptions;
-  const aliases = loadAliasView();
-  let sessionTree;
-  const getSessionTree = () => sessionTree ??= getSnapshotSessionTree(scanSource, scanResult.sessions);
-  const effectiveSearchOptions = mergeSearchQueryOptions(query, resolvedSearchOptions).options;
-  const searchContext = effectiveSearchOptions.costMin != null || effectiveSearchOptions.costMax != null ? { sessionTree: getSessionTree() } : void 0;
-  const searchResults = searchContext ? executeSessionSearch(query, resolvedSearchOptions, scanResult, searchContext) : executeSessionSearch(query, resolvedSearchOptions, scanResult);
-  const results = searchResults.map((result) => ({
-    ...result,
-    session: aliases.decorate(result.session, result.reference)
-  }));
-  const aliasResults = findAliasSearchResults(
-    query,
-    resolvedSearchOptions,
-    scanResult,
-    aliases,
-    searchContext
-  );
-  const mergedResults = mergeAliasSearchResults(
-    results,
-    aliasResults,
-    resolvedSearchOptions.limit ?? 50
-  );
-  return c.json({
-    results: withParentContext(mergedResults, getSessionTree, aliases).map(
-      toPublicReferencedSessionHead
-    )
-  });
-}
-async function handleGetFileActivity(c, defaults = {}, resolver) {
-  const sessionQuery = parseSessionQuery(
-    searchParams(c),
-    KNOWN_AGENT_NAMES,
-    FILE_ACTIVITY_LIMIT_POLICY
-  );
-  if (sessionQuery.limit.kind === "invalid") {
-    reportInvalidQueryParameter("file-activity", "limit", "rejected");
-    return c.json({ error: sessionQuery.limit.error }, 400);
-  }
-  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 window = parseDateWindowRequest(c, "file-activity", defaults);
-  if (window.kind === "rejected") return window.response;
-  if (sessionQuery.agent.kind === "unknown") {
-    reportInvalidQueryParameter("file-activity", "agent", "empty_result");
-    return c.json({ activity: [] });
-  }
-  const cwd = optionalQueryValue(c.req.query("cwd"));
-  let projectScope;
-  if (cwd) {
-    try {
-      projectScope = await resolveProjectScope(cwd, [], resolver, c.req.raw.signal);
-    } catch (error) {
-      return projectScopeResolutionFailureResponse(c, "file-activity", error);
-    }
-  }
-  const aliases = loadAliasView();
-  return c.json({
-    activity: listFileActivity({
-      agent: sessionQuery.agent.kind === "known" ? sessionQuery.agent.agentName : void 0,
-      sessionId: optionalQueryValue(c.req.query("sessionId")),
-      projectKind: projectIdentity?.kind,
-      projectKey: projectIdentity?.key,
-      project: optionalQueryValue(c.req.query("project")),
-      projectScope,
-      path: optionalQueryValue(c.req.query("path")),
-      kind: parseFileActivityKind(optionalQueryValue(c.req.query("kind"))),
-      from: window.from,
-      to: window.to,
-      limit: sessionQuery.limit.value
-    }).map((activity) => toPublicReferencedSessionHead(decorateFileActivity(activity, aliases)))
-  });
-}
-async function handleGetSessionData(c, scanSource) {
+async function handleGetSessionData(c, scanSource, loadDetail = materializeSessionDetailResponse) {
   const startedAt = performance.now();
   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);
-  }
+  if (!agentName) return c.json({ error: "Missing agent name" }, 400);
+  if (!sessionId) return c.json({ error: "Missing session ID" }, 400);
   try {
-    const reference = {
-      agentName,
-      sessionId
-    };
+    const reference = { agentName, sessionId };
     const messageCursor = optionalQueryValue(c.req.query("messageCursor"));
-    const result = materializeSessionDetailResponse(
+    const result = await loadDetail(
       scanSource.getSnapshot(),
       reference,
-      messageCursor ? { messageCursor } : {}
+      messageCursor ? { messageCursor } : {},
+      c.req.raw.signal
     );
     if (result.status === "unknown-agent") {
       return c.json({ error: `Unknown agent: ${agentName}` }, 404);
@@ -1891,117 +2113,136 @@ async function handleGetSessionData(c, scanSource) {
       );
     }
     return c.json(aliases.decorate(result.data, result.data.reference));
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Failed to load session";
+  } catch (error) {
+    if (error instanceof SessionDetailBusyError) {
+      c.header("Retry-After", "1");
+      return c.json({ error: "Session details busy; retry later" }, 503);
+    }
+    const message = error instanceof Error ? error.message : "Failed to load session";
     appLogger.error("api.session_data.error", {
       agent: agentName,
       session_id: sessionId,
-      duration_ms: Math.round(performance.now() - startedAt),
-      error: message
-    });
-    return c.json({ error: "Failed to load session" }, 500);
-  }
-}
-async function handlePostClientLog(c) {
-  const payload = await c.req.json().catch(() => null);
-  const rawEvent = payload?.event;
-  if (typeof rawEvent !== "string" || !rawEvent.trim()) {
-    return c.json({ ok: false }, 400);
-  }
-  const event = rawEvent.trim().replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 120);
-  appLogger.info(`client.${event}`, sanitizeClientLogData(payload?.data));
-  return c.json({ ok: true });
-}
-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 dateWindow = parseDateWindowRequest(c, "dashboard", defaults);
-  if (dateWindow.kind === "rejected") return dateWindow.response;
-  const { from, to, days } = resolveTimeWindow({
-    mode: "dashboard",
-    window: dateWindow,
-    days: c.req.query("days"),
-    defaultDays: defaults.days
-  });
-  const scope = {
-    agent: optionalQueryValue(c.req.query("agent"))?.toLowerCase(),
-    projectKind: projectIdentity?.kind,
-    projectKey: projectIdentity?.key
-  };
-  const compare = from == null ? void 0 : { from: addCalendarDays(from, -(days ?? countCalendarDays(from, to))), to: from - 1 };
-  const fixedTo = dateWindow.to;
-  const cacheTo = fixedTo ?? startOfCalendarDay(to);
-  const analyticsRevision = getAnalyticsRevision();
-  const costFacts = getDashboardCostFacts(
-    scanSource,
-    scanResult.sessions,
-    compare?.from ?? from,
-    to,
-    cacheTo,
-    analyticsRevision
-  );
-  const aggregate = getSnapshotAggregation(
-    scanSource,
-    scanResult.sessions,
-    [
-      "dashboard",
-      scope.agent,
-      scope.projectKind,
-      scope.projectKey,
-      from,
-      cacheTo,
-      compare?.from,
-      compare?.to,
-      analyticsRevision
-    ],
-    () => {
-      const agentInfo = getAgentInfoMap({});
-      const agentInfoMap = new Map(agentInfo.map((agent) => [agent.name, agent]));
-      return buildDashboard(scanResult.sessions, {
-        byAgentNames: Object.keys(scanResult.byAgent),
-        scope,
-        from,
-        to,
-        agentInfoMap,
-        compare,
-        costFacts
-      });
-    }
-  );
-  const storageAggregation = getDashboardStorageAggregation(
-    scanSource,
-    scanResult.sessions,
-    scope,
-    from,
-    to,
-    cacheTo,
-    analyticsRevision
-  );
-  const data = {
-    ...aggregate,
-    ...storageAggregation,
-    window: { from, to, days, compareFrom: compare?.from, compareTo: compare?.to }
-  };
-  const aliases = loadAliasView();
-  return c.json({
-    ...data,
-    recentSessions: data.recentSessions.map(
-      (item) => toPublicReferencedSessionHead({
-        ...item,
-        session: aliases.decorate(item.session, item.reference)
-      })
-    ),
-    recentFileActivities: data.recentFileActivities.map(
-      (activity) => toPublicReferencedSessionHead(decorateFileActivity(activity, aliases))
-    )
+      duration_ms: Math.round(performance.now() - startedAt),
+      error: message
+    });
+    return c.json({ error: "Failed to load session" }, 500);
+  }
+}
+
+// src/api/request-payloads.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseSessionReferencePayload(value) {
+  if (!isRecord(value) || typeof value.agentName !== "string" || typeof value.sessionId !== "string" || !value.agentName.trim() || !value.sessionId) {
+    return null;
+  }
+  return normalizeSessionReference({
+    agentName: value.agentName.trim().toLowerCase(),
+    sessionId: value.sessionId
+  });
+}
+function parseBookmarkReference(value) {
+  if (!isRecord(value)) return null;
+  const reference = parseSessionReferencePayload(value.reference);
+  if (reference) return reference;
+  if (typeof value.agentKey !== "string" || typeof value.sessionId !== "string" || !value.agentKey.trim() || !value.sessionId) {
+    return null;
+  }
+  return normalizeSessionReference({
+    agentName: value.agentKey.trim().toLowerCase(),
+    sessionId: value.sessionId
   });
 }
+function parseBookmarkImport(value) {
+  if (!isRecord(value)) return null;
+  const reference = parseBookmarkReference(value);
+  if (!reference) return null;
+  const timestamp = value.bookmarkedAt ?? value.bookmarked_at;
+  if (timestamp != null && (typeof timestamp !== "number" || !Number.isFinite(timestamp))) {
+    return null;
+  }
+  return {
+    reference,
+    bookmarkedAt: typeof timestamp === "number" ? timestamp : Date.now()
+  };
+}
+function sanitizeClientLogData(value) {
+  if (!isRecord(value)) return {};
+  const sanitized = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (CLIENT_LOG_STRING_FIELDS.has(key) && typeof item === "string") {
+      if (key === "operation_id" && !UUID_PATTERN.test(item)) continue;
+      sanitized[key] = item.slice(0, 300);
+      continue;
+    }
+    if (CLIENT_LOG_NUMBER_FIELDS.has(key) && typeof item === "number" && Number.isFinite(item) && item >= 0) {
+      sanitized[key] = item;
+      continue;
+    }
+    if (CLIENT_LOG_NULLABLE_FIELDS.has(key) && item === null) sanitized[key] = null;
+  }
+  return sanitized;
+}
+var CLIENT_LOG_STRING_FIELDS = /* @__PURE__ */ new Set([
+  "agent",
+  "error_name",
+  "mode",
+  "operation_id",
+  "phase",
+  "profiler_id",
+  "reason",
+  "request_key",
+  "session",
+  "source",
+  "trigger"
+]);
+var CLIENT_LOG_NUMBER_FIELDS = /* @__PURE__ */ new Set([
+  "actual_duration_ms",
+  "agents",
+  "base_duration_ms",
+  "commit_time_ms",
+  "duration_ms",
+  "error_status",
+  "messages",
+  "query_length",
+  "results",
+  "sessions",
+  "start_time_ms"
+]);
+var CLIENT_LOG_NULLABLE_FIELDS = /* @__PURE__ */ new Set(["agent", "session"]);
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+// src/api/client-log-handler.ts
+var CLIENT_LOG_EVENTS = /* @__PURE__ */ new Set([
+  "app.load.done",
+  "app.load.error",
+  "app.load.start",
+  "bookmark.add",
+  "bookmark.delete",
+  "react.profiler.commit",
+  "route.change",
+  "search.done",
+  "search.error",
+  "search.start",
+  "session.markdown_copy.done",
+  "session.markdown_copy.error",
+  "session.open.cancel",
+  "session.open.done",
+  "session.open.error",
+  "session.open.start"
+]);
+async function handlePostClientLog(c) {
+  const payload = await c.req.json().catch(() => null);
+  const rawEvent = payload?.event;
+  if (typeof rawEvent !== "string") {
+    return c.json({ ok: false }, 400);
+  }
+  const event = rawEvent.trim();
+  if (!CLIENT_LOG_EVENTS.has(event)) return c.json({ ok: false }, 400);
+  appLogger.info(`client.${event}`, sanitizeClientLogData(payload?.data));
+  return c.json({ ok: true });
+}
 
 // src/api/bookmark-handlers.ts
 function withStorageErrors(handler, onUnavailable) {
@@ -2041,7 +2282,7 @@ function handleGetBookmarks(c, scanSource) {
         storageAvailable: true
       });
     },
-    () => c.json({ bookmarks: [], storageAvailable: false })
+    () => c.json({ error: "Bookmark storage is unavailable" }, 503)
   );
 }
 function isKnownAgentKey(agentKey) {
@@ -2296,7 +2537,7 @@ function createSseConnectionBudget(maxConnections) {
     }
   };
 }
-function createSseResponse(eventSource, signal, releaseConnection) {
+function createSseResponse(eventSource, requestSignal, shutdownSignal, closeConnection) {
   let cancelStream = () => {
   };
   let drainStream = () => {
@@ -2309,26 +2550,32 @@ function createSseResponse(eventSource, signal, releaseConnection) {
         };
         let unsubscribeScanStatus = () => {
         };
-        let abortStream = () => {
+        let disconnectStream = () => {
+        };
+        let shutdownStream = () => {
         };
         let heartbeat;
         let buffer;
-        const cleanup = () => {
+        const cleanup = (reason) => {
           if (isClosed) return false;
           isClosed = true;
           buffer?.close();
           if (heartbeat) clearInterval(heartbeat);
           unsubscribeSessions();
           unsubscribeScanStatus();
-          signal.removeEventListener("abort", abortStream);
-          releaseConnection();
+          requestSignal.removeEventListener("abort", disconnectStream);
+          shutdownSignal?.removeEventListener("abort", shutdownStream);
+          closeConnection(reason);
           return true;
         };
-        abortStream = () => {
-          if (cleanup()) controller.close();
+        disconnectStream = () => {
+          if (cleanup("client_disconnected")) controller.close();
+        };
+        shutdownStream = () => {
+          if (cleanup("server_shutdown")) controller.close();
         };
         buffer = new SseEventBuffer(controller, () => {
-          if (cleanup()) controller.error(new Error("SSE client fell behind"));
+          if (cleanup("client_too_slow")) controller.error(new Error("SSE client fell behind"));
         });
         drainStream = () => buffer.drain();
         try {
@@ -2342,12 +2589,16 @@ function createSseResponse(eventSource, signal, releaseConnection) {
           });
           heartbeat = setInterval(() => buffer?.enqueueHeartbeat(), 15e3);
           cancelStream = () => {
-            cleanup();
+            cleanup("client_cancelled");
           };
-          if (signal.aborted) abortStream();
-          else signal.addEventListener("abort", abortStream, { once: true });
+          if (shutdownSignal?.aborted) shutdownStream();
+          else if (requestSignal.aborted) disconnectStream();
+          else {
+            requestSignal.addEventListener("abort", disconnectStream, { once: true });
+            shutdownSignal?.addEventListener("abort", shutdownStream, { once: true });
+          }
         } catch (error) {
-          cleanup();
+          cleanup("setup_failed");
           throw error;
         }
       },
@@ -2391,9 +2642,12 @@ function createApiRoutes(scanSource, eventSource, options = {}) {
   );
   api.get(
     "/file-activity",
-    (c) => handleGetFileActivity(c, listDefaults, options.projectIdentityResolver)
+    (c) => handleGetFileActivity(c, scanSource, listDefaults, options.projectIdentityResolver)
+  );
+  api.get(
+    "/sessions/:agent/:id",
+    (c) => handleGetSessionData(c, scanSource, options.loadSessionDetail)
   );
-  api.get("/sessions/:agent/:id", (c) => handleGetSessionData(c, scanSource));
   api.get("/dashboard", (c) => handleGetDashboard(c, scanSource, listDefaults));
   api.get("/bookmarks", (c) => handleGetBookmarks(c, scanSource));
   api.put("/bookmarks", (c) => handlePutBookmark(c));
@@ -2413,11 +2667,34 @@ function createApiRoutes(scanSource, eventSource, options = {}) {
         c.header("Retry-After", "1");
         return c.json({ error: "Too many active event streams" }, 429);
       }
-      const signal = options.shutdownSignal ? AbortSignal.any([c.req.raw.signal, options.shutdownSignal]) : c.req.raw.signal;
+      const connectionId = randomUUID2();
+      const connectedAt = performance.now();
+      let isClosed = false;
+      appLogger.info("api.sse.connection.opened", {
+        connection_id: connectionId,
+        active_connections: sseConnections.activeCount(),
+        connection_limit: MAX_ACTIVE_SSE_CONNECTIONS
+      });
+      const closeConnection = (reason) => {
+        if (isClosed) return;
+        isClosed = true;
+        releaseConnection();
+        appLogger.info("api.sse.connection.closed", {
+          connection_id: connectionId,
+          close_reason: reason,
+          duration_ms: Math.max(0, Math.round(performance.now() - connectedAt)),
+          active_connections: sseConnections.activeCount()
+        });
+      };
       try {
-        return createSseResponse(eventSource, signal, releaseConnection);
+        return createSseResponse(
+          eventSource,
+          c.req.raw.signal,
+          options.shutdownSignal,
+          closeConnection
+        );
       } catch (error) {
-        releaseConnection();
+        closeConnection("setup_failed");
         throw error;
       }
     });
@@ -2527,7 +2804,6 @@ function loopbackWriteGuard() {
     if (!decision.allowed) {
       appLogger.warn("http.loopback_request.rejected", {
         method: c.req.method,
-        path: url.pathname,
         reason: decision.reason
       });
       const error = decision.reason === "content-type" ? "Write requests require application/json" : "Cross-origin API request rejected";
@@ -2661,6 +2937,29 @@ function accessTokenAuth(expectedToken) {
 // src/server.ts
 var MAX_API_REQUEST_BYTES = 1024 * 1024;
 var SERVER_CLOSE_GRACE_MS = 1e3;
+var OPERATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var OBSERVABLE_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "agent",
+  "costMax",
+  "costMin",
+  "cursor",
+  "cwd",
+  "days",
+  "fileActivity",
+  "from",
+  "kind",
+  "limit",
+  "messageCursor",
+  "path",
+  "project",
+  "projectKey",
+  "projectKind",
+  "q",
+  "sessionId",
+  "tag",
+  "to",
+  "tool"
+]);
 function findWebDistPath() {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
   const packagedPath = resolve(__dirname2, "web");
@@ -2700,6 +2999,32 @@ function getListeningPort(server, fallback) {
   const address = server.address();
   return typeof address === "object" && address !== null ? address.port : fallback;
 }
+function optionalOperationId(value) {
+  return value && OPERATION_ID_PATTERN.test(value) ? value : void 0;
+}
+function errorStatus(error) {
+  try {
+    if (typeof error !== "object" || error === null) return 500;
+    const status = Reflect.get(error, "status");
+    if (typeof status === "number" && status >= 400 && status <= 599) return status;
+  } catch {
+  }
+  return 500;
+}
+function matchedRoute(context) {
+  try {
+    return matchedRoutes(context).map((route) => route.path).filter((path) => !path.includes("*")).at(-1) ?? "<unmatched>";
+  } catch {
+    return "<unmatched>";
+  }
+}
+function queryKeys(url) {
+  try {
+    return [...new Set(new URL(url).searchParams.keys())].filter((key) => OBSERVABLE_QUERY_KEYS.has(key)).toSorted();
+  } catch {
+    return [];
+  }
+}
 async function closeHttpServer(server, port) {
   if (!server) return;
   let forceCloseTimer;
@@ -2731,6 +3056,7 @@ async function createServer(port, store, options = {}) {
   const loopbackAuthorityEnabled = !accessPolicy.remoteAccessRequired;
   const shutdownController = new AbortController();
   const projectIdentityResolver = options.projectIdentityResolver ?? createProjectIdentityResolver();
+  const sessionDetailLoader = new ThreadSessionDetailLoader();
   let actualPort = null;
   appLogger.info("server.access_policy", {
     bind_category: accessPolicy.bindCategory,
@@ -2772,41 +3098,48 @@ async function createServer(port, store, options = {}) {
       xXssProtection: false
     })
   );
+  app.use("*", async (c, next) => {
+    const startedAt = performance.now();
+    const requestId = randomUUID3();
+    const actualPath = c.req.path;
+    const operationId = optionalOperationId(c.req.header(CODESESH_OPERATION_ID_HEADER));
+    const context = actualPath === "/api/events" ? {} : { request_id: requestId, ...operationId ? { operation_id: operationId } : {} };
+    c.header(CODESESH_REQUEST_ID_HEADER, requestId);
+    return appLogger.restoreContext(context, async () => {
+      let thrown;
+      try {
+        await next();
+      } catch (error) {
+        thrown = error;
+        throw error;
+      } finally {
+        const requestError = thrown ?? c.error;
+        appLogger.info("http.request", {
+          method: c.req.method,
+          route: matchedRoute(c),
+          query_keys: queryKeys(c.req.url),
+          status: requestError == null ? c.res.status : errorStatus(requestError),
+          duration_ms: Math.round(performance.now() - startedAt),
+          ...requestError == null ? {} : { error: requestError }
+        });
+      }
+    });
+  });
   if (loopbackAuthorityEnabled) {
     app.use("*", async (c, next) => {
       const decision = validateLoopbackAuthority(c.env.incoming.rawHeaders, hostname, actualPort);
       if (!decision.allowed) {
         appLogger.warn("http.loopback_authority.rejected", {
           method: c.req.method,
-          path: new URL(c.req.url).pathname,
+          route: "<rejected>",
           reason: decision.reason,
-          authority: decision.authority
+          authority_present: Boolean(decision.authority)
         });
         return c.json({ error: "Loopback request authority rejected" }, 403);
       }
       await next();
     });
   }
-  app.use("*", async (c, next) => {
-    const startedAt = performance.now();
-    let thrown;
-    try {
-      await next();
-    } catch (error) {
-      thrown = error;
-      throw error;
-    } finally {
-      const url2 = new URL(c.req.url);
-      appLogger.info("http.request", {
-        method: c.req.method,
-        path: url2.pathname,
-        query_keys: [...url2.searchParams.keys()].toSorted(),
-        status: c.res.status,
-        duration_ms: Math.round(performance.now() - startedAt),
-        error: thrown instanceof Error ? thrown.message : void 0
-      });
-    }
-  });
   if (transport.kind === "trusted-proxy") {
     app.use("/api/*", requireProxyTls());
   }
@@ -2825,7 +3158,8 @@ async function createServer(port, store, options = {}) {
     defaultSessionTo: options.defaultSessionTo,
     defaultSessionDays: options.defaultSessionDays,
     shutdownSignal: shutdownController.signal,
-    projectIdentityResolver
+    projectIdentityResolver,
+    loadSessionDetail: sessionDetailLoader.load
   };
   app.route("/api", createApiRoutes(store, store, routeOptions));
   const webDistPath = options.webDistPath ?? findWebDistPath();
@@ -2909,6 +3243,7 @@ async function createServer(port, store, options = {}) {
       appLogger.info("server.shutdown", { port: actualPort });
       shutdownController.abort();
       try {
+        await sessionDetailLoader.shutdown();
         appLogger.info("server.shutdown.phase", { phase: "http-closing", port: actualPort });
         await closeHttpServer(server, actualPort);
       } finally {
@@ -3074,14 +3409,17 @@ var AgentOperationScheduler = class {
     const run = previous.then(async () => {
       if (this.isStopped) 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;
-      }
+      return appLogger.runWithContext({ operation_id: lifecycle.operationId }, async () => {
+        this.logOperationStarted(lifecycle);
+        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,
@@ -3139,13 +3477,21 @@ var AgentOperationScheduler = class {
     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,
+    return {
+      agentName,
+      kind,
       generation,
-      started_at: startedAt
+      operationId: `${agentName}:${generation}`,
+      startedAt
+    };
+  }
+  logOperationStarted(lifecycle) {
+    appLogger.info("scan.agent_operation.started", {
+      agent: lifecycle.agentName,
+      operation: lifecycle.kind,
+      generation: lifecycle.generation,
+      started_at: lifecycle.startedAt
     });
-    return { agentName, kind, generation, startedAt };
   }
   completeOperation(lifecycle, result) {
     const completedAt = Date.now();
@@ -3256,23 +3602,27 @@ var BackfillLifecycle = class {
 var LiveSessionIndex = class {
   agents = [];
   agentsByName = /* @__PURE__ */ new Map();
+  queryScope;
+  allByAgent = {};
   byAgent = {};
   sessions = [];
   cacheFailures = {};
   scanFailures = {};
   signatureCaches = /* @__PURE__ */ new Map();
   initialize(snapshot, options = {}) {
+    this.queryScope = options.queryScope;
     const agentMap = /* @__PURE__ */ new Map();
     for (const agent of snapshot.agents) agentMap.set(agent.name, agent);
     for (const agent of options.registeredAgents ?? []) {
       if (!agentMap.has(agent.name)) agentMap.set(agent.name, agent);
     }
     this.agents = [...agentMap.values()].filter(
-      (agent) => !options.allowedAgents || options.allowedAgents.has(agent.name.toLowerCase())
+      (agent) => !this.queryScope?.agents?.length || this.queryScope.agents.includes(agent.name.toLowerCase())
     );
     this.agentsByName = new Map(this.agents.map((agent) => [agent.name, agent]));
     this.cacheFailures = { ...snapshot.cacheFailures };
     this.scanFailures = { ...snapshot.scanFailures };
+    this.allByAgent = {};
     this.byAgent = Object.fromEntries(
       this.agents.flatMap((agent) => {
         if (this.scanFailures[agent.name] && !(agent.name in snapshot.byAgent)) return [];
@@ -3281,7 +3631,8 @@ var LiveSessionIndex = class {
           assertSessionIdentity(session, agent.name);
           assertIdentifiedSessionHead(session);
         }
-        return [[agent.name, sortSessions(sessions)]];
+        this.allByAgent[agent.name] = sortSessions(sessions);
+        return [[agent.name, this.visibleSessions(this.allByAgent[agent.name])]];
       })
     );
     this.sessions = mergeSortedSessions(Object.values(this.byAgent));
@@ -3299,11 +3650,15 @@ var LiveSessionIndex = class {
   findAgent(agentName) {
     return this.agentsByName.get(agentName);
   }
+  agentSessions(agentName) {
+    return this.allByAgent[agentName] ?? [];
+  }
   commitAgentSessions(agentName, nextSessions, candidateChangedIds = []) {
     for (const session of nextSessions) {
       assertSessionIdentity(session, agentName);
       assertIdentifiedSessionHead(session);
     }
+    const visibleSessions = this.visibleSessions(nextSessions);
     delete this.cacheFailures[agentName];
     delete this.scanFailures[agentName];
     const previousSessions = this.byAgent[agentName] ?? [];
@@ -3311,15 +3666,18 @@ var LiveSessionIndex = class {
     const signatureCache = this.signatureCache(agentName);
     const { changes, removedSessionIds, counts } = computeSessionDiff(
       previousSessions,
-      nextSessions,
+      visibleSessions,
       candidateChangedIds,
       sessionSignature,
       signatureCache
     );
     for (const removedId of removedSessionIds) signatureCache.delete(removedId);
-    this.byAgent[agentName] = sortSessions(nextSessions);
+    this.allByAgent[agentName] = sortSessions(nextSessions);
+    const hasChanges = counts.new > 0 || counts.updated > 0 || counts.removed > 0;
+    if (!hasChanges && agentName in this.byAgent) return null;
+    this.byAgent[agentName] = this.visibleSessions(this.allByAgent[agentName]);
     this.sessions = mergeSortedSessions(Object.values(this.byAgent));
-    if (counts.new === 0 && counts.updated === 0 && counts.removed === 0) return null;
+    if (!hasChanges) return null;
     const changedSessionHeads = changes.map(({ session }) => ({
       reference: session.reference,
       session
@@ -3358,12 +3716,16 @@ var LiveSessionIndex = class {
     this.signatureCaches.set(agentName, cache);
     return cache;
   }
+  visibleSessions(sessions) {
+    if (!this.queryScope?.projectScope) return sessions;
+    return sessions.filter((session) => matchesSessionQueryScope(session, this.queryScope));
+  }
 };
 
 // src/search-index-job-runner.ts
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { Worker as Worker2 } from "worker_threads";
+import { Worker as Worker3 } from "worker_threads";
 
 // src/errors.ts
 function toError2(value) {
@@ -3371,14 +3733,24 @@ function toError2(value) {
 }
 
 // src/pending-search-index-jobs.ts
+var LOG_CONTEXT_KEYS = ["request_id", "operation_id", "publication_id"];
+function commonLogContext(left, right) {
+  const common = {};
+  for (const key of LOG_CONTEXT_KEYS) {
+    if (left[key] !== void 0 && left[key] === right[key]) common[key] = left[key];
+  }
+  return common;
+}
 var PendingSearchIndexJobBatch = class {
-  constructor(id, context, jobs, waiter) {
+  constructor(id, context, jobs, waiter, logContext) {
     this.id = id;
     this.context = context;
-    this.merge(context, jobs, waiter);
+    this.logContext = logContext;
+    this.merge(context, jobs, waiter, logContext);
   }
   id;
   context;
+  logContext;
   jobsByAgent = /* @__PURE__ */ new Map();
   waiters = [];
   settled = false;
@@ -3420,8 +3792,9 @@ var PendingSearchIndexJobBatch = class {
       }
     }
   }
-  merge(context, jobs, waiter) {
+  merge(context, jobs, waiter, logContext) {
     this.context = context;
+    this.logContext = commonLogContext(this.logContext, logContext);
     this.waiters.push(waiter);
     for (const job of jobs) this.mergeJob(job);
   }
@@ -3459,7 +3832,7 @@ var PendingSearchIndexJobs = class {
   get changeCount() {
     return this.pendingBatch?.changeCount ?? 0;
   }
-  enqueue(id, context, jobs, onStarted, onProgress) {
+  enqueue(id, context, jobs, onStarted, onProgress, logContext = {}) {
     if (jobs.length === 0) return Promise.resolve();
     return new Promise((resolve4, reject) => {
       const waiter = {
@@ -3470,9 +3843,9 @@ var PendingSearchIndexJobs = class {
         agentNames: new Set(jobs.map((job) => job.agentName))
       };
       if (this.pendingBatch) {
-        this.pendingBatch.merge(context, jobs, waiter);
+        this.pendingBatch.merge(context, jobs, waiter, logContext);
       } else {
-        this.pendingBatch = new PendingSearchIndexJobBatch(id, context, jobs, waiter);
+        this.pendingBatch = new PendingSearchIndexJobBatch(id, context, jobs, waiter, logContext);
         this.batches.add(this.pendingBatch);
       }
     });
@@ -3560,6 +3933,7 @@ var SearchIndexJobRunner = class {
   pendingJobs = new PendingSearchIndexJobs();
   pendingMaintenanceJobs = new PendingSearchIndexJobs();
   isShuttingDown = false;
+  retirements = /* @__PURE__ */ new Set();
   enqueue(context, jobs, onStarted, onProgress) {
     return this.enqueueIn(this.pendingJobs, context, jobs, onStarted, onProgress);
   }
@@ -3570,7 +3944,14 @@ var SearchIndexJobRunner = class {
     if (jobs.length === 0) return Promise.resolve();
     if (this.isShuttingDown) return Promise.reject(new Error(SHUTDOWN_ERROR_MESSAGE2));
     const batchId = this.nextBatchId++;
-    const completion = queue.enqueue(batchId, context, jobs, onStarted, onProgress);
+    const completion = queue.enqueue(
+      batchId,
+      context,
+      jobs,
+      onStarted,
+      onProgress,
+      appLogger.captureContext()
+    );
     if (this.activeBatch) {
       const snapshot = this.snapshot();
       appLogger.debug("search_index.worker_queued", {
@@ -3606,25 +3987,33 @@ var SearchIndexJobRunner = class {
     if (activeBatch) this.settle(activeBatch, shutdownError);
     this.pendingJobs.rejectAll(shutdownError);
     this.pendingMaintenanceJobs.rejectAll(shutdownError);
-    if (worker) await worker.terminate();
+    const activeRetirement = worker ? this.retireWorker(worker) : null;
+    const retirements = [...this.retirements];
+    try {
+      if (activeRetirement) await activeRetirement;
+    } finally {
+      await Promise.allSettled(retirements);
+    }
   }
   startNextBatch() {
     if (this.isShuttingDown || this.activeBatch) return;
     const batch = this.pendingJobs.take() ?? this.pendingMaintenanceJobs.take();
     if (!batch) return;
-    appLogger.info("search_index.worker_dequeued", {
-      batch_id: batch.id,
-      context: batch.context,
-      pending_batches: this.pendingJobs.batchCount
-    });
-    batch.start((error) => {
-      appLogger.error("search_index.worker_start_listener_failed", {
+    appLogger.restoreContext(batch.logContext, () => {
+      appLogger.info("search_index.worker_dequeued", {
         batch_id: batch.id,
         context: batch.context,
-        error: toError2(error)
+        pending_batches: this.pendingJobs.batchCount
+      });
+      batch.start((error) => {
+        appLogger.error("search_index.worker_start_listener_failed", {
+          batch_id: batch.id,
+          context: batch.context,
+          error: toError2(error)
+        });
       });
+      this.startBatch(batch);
     });
-    this.startBatch(batch);
   }
   startBatch(batch) {
     if (this.isShuttingDown) {
@@ -3635,6 +4024,7 @@ var SearchIndexJobRunner = class {
       type: "run",
       pricingGenerationId: getPricingGeneration().id,
       context: batch.context,
+      logContext: batch.logContext,
       jobs: batch.jobs
     };
     const existingWorker = this.worker;
@@ -3661,7 +4051,7 @@ var SearchIndexJobRunner = class {
     });
     let worker;
     try {
-      worker = new Worker2(workerUrl, { workerData: request });
+      worker = new Worker3(workerUrl, { workerData: request });
     } catch (error) {
       this.settle(batch, toError2(error));
       this.startNextBatch();
@@ -3674,62 +4064,76 @@ var SearchIndexJobRunner = class {
       if (this.worker !== worker) return;
       const activeBatch = this.activeBatch;
       if (!activeBatch) return;
-      if (message.type === "publication-progress") {
-        const { agentName, stage } = message;
-        activeBatch.progress({ agentName, stage }, (error) => {
-          appLogger.error("search_index.worker_progress_listener_failed", {
-            batch_id: activeBatch.id,
-            context: activeBatch.context,
-            error: toError2(error)
-          });
-        });
-        return;
-      }
-      if (message.type === "sync-result") {
-        logSearchIndexSync(message.context, message.result);
-        return;
-      }
-      if (message.type === "persist-failed") {
-        appLogger.error("search_index.persist_failed", {
-          batch_id: activeBatch.id,
-          context: message.context,
-          stage: message.stage,
-          publication_id: message.publicationId,
-          agent: message.agentName,
-          sessions: message.sessions
+      appLogger.restoreContext(activeBatch.logContext, () => {
+        this.handleWorkerMessage(activeBatch, message);
+      });
+    });
+    worker.on("error", (error) => {
+      const activeBatch = this.worker === worker ? this.activeBatch : null;
+      appLogger.restoreContext(activeBatch?.logContext ?? {}, () => {
+        appLogger.error("search_index.worker_error", {
+          context: activeBatch?.context,
+          error
         });
-        if (message.fatal) {
-          this.finishBatch(
-            activeBatch,
-            new Error(
-              `Search index worker failed to persist ${message.stage} for ${message.agentName}`
-            )
-          );
-        }
-        return;
-      }
-      if (message.type !== "done") return;
-      if (message.failedAgents.length > 0) {
-        appLogger.warn("search_index.batch_partial", {
+        this.invalidateWorker(worker, toError2(error));
+      });
+    });
+    worker.on("exit", (code) => {
+      const activeBatch = this.worker === worker ? this.activeBatch : null;
+      appLogger.restoreContext(
+        activeBatch?.logContext ?? {},
+        () => this.finishWorker(worker, code)
+      );
+    });
+  }
+  handleWorkerMessage(activeBatch, message) {
+    if (message.type === "publication-progress") {
+      const { agentName, stage } = message;
+      activeBatch.progress({ agentName, stage }, (error) => {
+        appLogger.error("search_index.worker_progress_listener_failed", {
           batch_id: activeBatch.id,
-          context: message.context,
-          failed_agents: message.failedAgents
+          context: activeBatch.context,
+          error: toError2(error)
         });
-      }
-      appLogger.info(`${message.context}.done`, {
-        duration_ms: Math.round(message.durationMs),
+      });
+      return;
+    }
+    if (message.type === "sync-result") {
+      logSearchIndexSync(message.context, message.result);
+      return;
+    }
+    if (message.type === "persist-failed") {
+      appLogger.error("search_index.persist_failed", {
+        batch_id: activeBatch.id,
+        context: message.context,
+        stage: message.stage,
+        publication_id: message.publicationId,
+        agent: message.agentName,
         sessions: message.sessions
       });
-      this.finishBatch(activeBatch);
-    });
-    worker.on("error", (error) => {
-      appLogger.error("search_index.worker_error", {
-        context: this.activeBatch?.context ?? batch.context,
-        error
+      if (message.fatal) {
+        this.finishBatch(
+          activeBatch,
+          new Error(
+            `Search index worker failed to persist ${message.stage} for ${message.agentName}`
+          )
+        );
+      }
+      return;
+    }
+    if (message.type !== "done") return;
+    if (message.failedAgents.length > 0) {
+      appLogger.warn("search_index.batch_partial", {
+        batch_id: activeBatch.id,
+        context: message.context,
+        failed_agents: message.failedAgents
       });
-      this.invalidateWorker(worker, toError2(error));
+    }
+    appLogger.info(`${message.context}.done`, {
+      duration_ms: Math.round(message.durationMs),
+      sessions: message.sessions
     });
-    worker.on("exit", (code) => this.finishWorker(worker, code));
+    this.finishBatch(activeBatch);
   }
   finishBatch(batch, error) {
     if (this.activeBatch !== batch) return;
@@ -3743,7 +4147,7 @@ var SearchIndexJobRunner = class {
     const batch = this.activeBatch;
     this.activeBatch = null;
     if (batch) this.settle(batch, error);
-    void worker.terminate();
+    void this.retireWorker(worker);
     this.startNextBatch();
   }
   finishWorker(worker, code) {
@@ -3767,15 +4171,23 @@ var SearchIndexJobRunner = class {
     this.startNextBatch();
   }
   settle(batch, error) {
-    if (!this.pendingJobs.settle(batch, error) && !this.pendingMaintenanceJobs.settle(batch, error)) {
-      return;
-    }
-    appLogger.info("search_index.worker_settled", {
-      batch_id: batch.id,
-      context: batch.context,
-      result: error ? "rejected" : "resolved"
+    appLogger.restoreContext(batch.logContext, () => {
+      if (!this.pendingJobs.settle(batch, error) && !this.pendingMaintenanceJobs.settle(batch, error)) {
+        return;
+      }
+      appLogger.info("search_index.worker_settled", {
+        batch_id: batch.id,
+        context: batch.context,
+        result: error ? "rejected" : "resolved"
+      });
     });
   }
+  retireWorker(worker) {
+    const retirement = terminateWorkerAfterLogDrain(worker);
+    this.retirements.add(retirement);
+    void retirement.finally(() => this.retirements.delete(retirement)).catch(() => void 0);
+    return retirement;
+  }
   workerUrl() {
     const workerUrl = new URL("./search-index-worker.js", import.meta.url);
     if (workerUrl.protocol === "file:" && !existsSync2(fileURLToPath2(workerUrl))) return null;
@@ -3862,19 +4274,21 @@ var SearchIndexMaintenanceScheduler = class {
       if (outcome.status === "failed") {
         throw new Error(`Session cache read failed for ${agentName}`);
       }
-      cached = outcome.value ?? void 0;
-    }
-    if (!cached) throw new Error(`Session cache is unavailable for ${agentName}`);
-    this.cachedSessionsByAgent.set(agentName, cached);
-    const sessionsById = new Map(
-      cached.sessions.map((session, sortIndex) => [
-        session.reference.sessionId,
-        { session, sortIndex }
-      ])
-    );
+      if (!outcome.value) throw new Error(`Session cache is unavailable for ${agentName}`);
+      cached = {
+        sessionsById: new Map(
+          outcome.value.sessions.map((session, sortIndex) => [
+            session.reference.sessionId,
+            { session, sortIndex }
+          ])
+        ),
+        meta: outcome.value.meta
+      };
+      this.cachedSessionsByAgent.set(agentName, cached);
+    }
     const changes = pending.sessionIds.flatMap(
       (sessionId) => {
-        const change = sessionsById.get(sessionId);
+        const change = cached.sessionsById.get(sessionId);
         return change ? [change] : [];
       }
     );
@@ -4486,7 +4900,7 @@ var SearchIndexPublisher = class {
           kind: "full",
           context,
           agentName: agent.name,
-          sessions: snapshot.byAgent[agent.name] ?? [],
+          sessions: this.options.agentSessions(agent.name),
           meta: buildAgentCacheMeta(agent),
           completeness: "partial",
           removedSessionIds: [],
@@ -4566,7 +4980,7 @@ var SessionPublicationCoordinator = class {
       publication.candidateChangedIds
     );
     const diffDuration = performance.now() - diffStartedAt;
-    const result = { durableCommitted: true, event, diffDuration };
+    const result = { event, diffDuration };
     this.runPostCommit(publication, "worker_commit", () => publication.stagedRun?.commit());
     this.runPostCommit(publication, "callback", () => publication.onCommitted?.(result));
     this.runPostCommit(
@@ -4632,7 +5046,6 @@ function countSessionUpdates(event) {
 }
 var REFRESH_DEBOUNCE_MS = 200;
 var EMPTY_AGENT_REFRESH_DEBOUNCE_MS = 3e4;
-var SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD = 100;
 var SOURCE_FAILURE_SUMMARY_MAX_LENGTH = 160;
 function buildScanCompletion(completeness, sourceFailures) {
   if (sourceFailures.length === 0) return { completeness };
@@ -4644,6 +5057,15 @@ function buildScanCompletion(completeness, sourceFailures) {
     sourceFailureSummary: summary.length > SOURCE_FAILURE_SUMMARY_MAX_LENGTH ? `${summary.slice(0, SOURCE_FAILURE_SUMMARY_MAX_LENGTH - 1)}\u2026` : summary
   };
 }
+function selectCacheMeta(meta, sessionIds) {
+  if (!sessionIds) return { ...meta };
+  const selected = {};
+  for (const sessionId of sessionIds) {
+    const entry = meta[sessionId];
+    if (entry) selected[sessionId] = entry;
+  }
+  return selected;
+}
 var AgentSyncEngine = class {
   constructor(options) {
     this.options = options;
@@ -4656,6 +5078,7 @@ var AgentSyncEngine = class {
     this.indexPublisher = new SearchIndexPublisher({
       jobs: this.searchIndexJobs,
       snapshot: () => this.sessionIndex.snapshot(),
+      agentSessions: (agentName) => this.sessionIndex.agentSessions(agentName),
       readCachedSessions: (agentName) => this.readCachedSessionsOrWarn("search.index", agentName)
     });
     this.sessionPublication = new SessionPublicationCoordinator(
@@ -4781,11 +5204,21 @@ var AgentSyncEngine = class {
   reportPostCommitError(operation, agentName, error) {
     appLogger.error(`${operation}.post_commit_error`, { agent: agentName, error });
   }
-  commitRefreshChangeCheck(agentName, commit) {
+  commitAgentState(operation, agent, state) {
+    if (!state) return;
     try {
-      commit?.();
+      agent.restoreSessionCacheMeta(state.meta);
+      if (state.refreshedAt != null) {
+        this.lastRefreshAtByAgent.set(agent.name, state.refreshedAt);
+      }
     } catch (error) {
-      this.reportPostCommitError("scan.refresh", agentName, error);
+      this.reportPostCommitError(operation, agent.name, error);
+      return;
+    }
+    try {
+      state.refreshTransaction?.commit();
+    } catch (error) {
+      this.reportPostCommitError(operation, agent.name, error);
     }
   }
   finishCommittedAgentScan(agentName, completion) {
@@ -4853,12 +5286,11 @@ var AgentSyncEngine = class {
       appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
       return { result: "skipped", completion: { completeness: "complete" } };
     }
-    const previousSessions = this.sessionIndex.snapshot().byAgent[agentName] ?? [];
+    const previousSessions = this.sessionIndex.agentSessions(agentName);
     const refreshBaseline = cached?.sessions ?? previousSessions;
     const cacheTimestamp = cached?.timestamp ?? this.lastRefreshAtByAgent.get(agentName) ?? 0;
     if (cached) agent.restoreSessionCacheMeta(cached.meta);
     const durableMeta = agent.snapshotSessionCacheMeta();
-    const durableLastRefreshAt = this.lastRefreshAtByAgent.get(agentName);
     const initialization = readAgentCacheInitialization(agentName);
     if (initialization.status === "failed") {
       appLogger.warn("scan.refresh.cache_state_unavailable", {
@@ -4868,40 +5300,50 @@ var AgentSyncEngine = class {
       return { result: "unchanged", completion: { completeness: "complete" } };
     }
     const isInitialized = initialization.value;
-    const refresh = await selectAgentRefresh(agent, {
+    const refreshTransaction = await beginAgentRefresh(agent, {
       initialized: isInitialized,
       sinceTimestamp: cacheTimestamp,
       cachedSessions: refreshBaseline
     });
+    const refresh = refreshTransaction.selection;
     const availabilityDuration = refresh.availabilityDurationMs;
     let strategyResult;
-    if (refresh.kind === "unavailable") {
-      strategyResult = this.refreshUnavailableAgent(agentName);
-    } else if (refresh.kind === "initialize") {
-      strategyResult = await this.initializeAgent(agent, previousSessions);
-    } else if (refresh.kind === "synchronize") {
-      strategyResult = await this.syncAgentSources(
-        agent,
-        cached ?? {
-          sessions: refreshBaseline,
-          meta: durableMeta
-        },
-        startedAt
-      );
-    } else {
-      strategyResult = await this.refreshChangedAgent(agent, refresh, refreshBaseline, startedAt);
+    try {
+      if (refresh.kind === "unavailable") {
+        strategyResult = this.refreshUnavailableAgent(agentName);
+      } else if (refresh.kind === "initialize") {
+        strategyResult = await this.initializeAgent(agent, previousSessions);
+      } else if (refresh.kind === "synchronize") {
+        strategyResult = await this.syncAgentSources(
+          agent,
+          cached ?? {
+            sessions: refreshBaseline,
+            meta: durableMeta
+          },
+          startedAt
+        );
+      } else {
+        strategyResult = await this.refreshChangedAgent(
+          agent,
+          refresh,
+          refreshTransaction,
+          refreshBaseline,
+          startedAt
+        );
+      }
+    } finally {
+      agent.restoreSessionCacheMeta(durableMeta);
     }
     const stagedRun = strategyResult.workerRun;
     if (strategyResult.status === "unchanged") {
       stagedRun?.commit();
-      this.commitRefreshChangeCheck(agentName, strategyResult.commitChangeCheck);
+      this.commitAgentState("scan.refresh", agent, strategyResult.pendingAgentState);
       return {
         result: "unchanged",
         completion: buildScanCompletion(strategyResult.completeness, strategyResult.sourceFailures)
       };
     }
     const nextSessions = attachMissingProjectIdentities(strategyResult.nextSessions);
-    const searchIndexOptions = pendingPathCount >= SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD ? { isBulk: true } : void 0;
     const persistenceDiff = strategyResult.publication.kind === "changes" ? strategyResult.publication.diff : null;
     const publicationSessions = strategyResult.publication.kind === "full" ? strategyResult.publication.sessions : nextSessions;
     const explicitRemovedSessionIds = strategyResult.publication.kind === "full" ? strategyResult.publication.explicitRemovedSessionIds : [];
@@ -4923,6 +5365,7 @@ var AgentSyncEngine = class {
       delete_candidates: replacementDeleteCandidates
     });
     const changedSessionIds = persistenceDiff ? new Set(persistenceDiff.changedSessions.map(({ session }) => session.reference.sessionId)) : void 0;
+    const pendingMeta = strategyResult.pendingAgentState?.meta ?? durableMeta;
     const persistStartedAt = performance.now();
     const persistentJob = persistenceDiff ? {
       kind: "changes",
@@ -4930,18 +5373,16 @@ var AgentSyncEngine = class {
       agentName,
       changes: persistenceDiff.changedSessions,
       removedSessionIds: persistenceDiff.removedSessionIds,
-      meta: buildAgentCacheMeta(agent, changedSessionIds),
-      ...searchIndexOptions ? { searchIndexOptions } : {}
+      meta: selectCacheMeta(pendingMeta, changedSessionIds)
     } : {
       kind: "full",
       context: "scan.refresh",
       agentName,
       sessions: publicationSessions,
-      meta: buildAgentCacheMeta(agent),
+      meta: selectCacheMeta(pendingMeta),
       completeness: strategyResult.completeness,
       removedSessionIds: explicitRemovedSessionIds,
-      saveCache: true,
-      ...searchIndexOptions ? { searchIndexOptions } : {}
+      saveCache: true
     };
     const completion = buildScanCompletion(
       strategyResult.completeness,
@@ -4961,12 +5402,9 @@ var AgentSyncEngine = class {
       });
     } catch (error) {
       stagedRun?.discard();
-      agent.restoreSessionCacheMeta(durableMeta);
-      if (durableLastRefreshAt == null) this.lastRefreshAtByAgent.delete(agentName);
-      else this.lastRefreshAtByAgent.set(agentName, durableLastRefreshAt);
       throw error;
     }
-    this.commitRefreshChangeCheck(agentName, strategyResult.commitChangeCheck);
+    this.commitAgentState("scan.refresh", agent, strategyResult.pendingAgentState);
     const persistDuration = performance.now() - persistStartedAt;
     const totalDurationMs = performance.now() - startedAt;
     try {
@@ -5011,7 +5449,7 @@ var AgentSyncEngine = class {
    * empty database.
    */
   refreshUnavailableAgent(agentName) {
-    const previousSessions = this.sessionIndex.snapshot().byAgent[agentName] ?? [];
+    const previousSessions = this.sessionIndex.agentSessions(agentName);
     if (previousSessions.length > 0) {
       appLogger.warn("scan.refresh.agent_unavailable", {
         agent: agentName,
@@ -5035,14 +5473,13 @@ var AgentSyncEngine = class {
     const workerRun = await this.runWorker(agent, previousSessions, { kind: "full-scan" }, scope);
     try {
       const { result } = workerRun;
-      agent.restoreSessionCacheMeta(result.meta);
       const sessions = attachMissingProjectIdentities(result.sessions);
-      this.lastRefreshAtByAgent.set(agent.name, Date.now());
       return {
         ...this.refreshStrategyBase(sessions, result.completeness, scope, {
           scanDuration: performance.now() - scanStartedAt,
           sourceFailures: result.sourceFailures ?? [],
-          workerRun
+          workerRun,
+          pendingAgentState: { meta: result.meta, refreshedAt: Date.now() }
         }),
         status: "continue",
         publication: {
@@ -5070,19 +5507,19 @@ var AgentSyncEngine = class {
     );
     try {
       const { result } = workerRun;
-      agent.restoreSessionCacheMeta(result.meta);
       const sessions = attachMissingProjectIdentities(result.sessions);
       const preciseChangedIds = result.changedIds ?? [];
       const persistenceDiff = buildSessionPersistenceDiff(baseline.sessions, sessions, {
         candidateChangedIds: preciseChangedIds
       });
-      this.lastRefreshAtByAgent.set(agent.name, Date.now());
+      const pendingAgentState = { meta: result.meta, refreshedAt: Date.now() };
       if (persistenceDiff.changedSessions.length === 0 && persistenceDiff.removedSessionIds.length === 0 && (result.sourceFailures?.length ?? 0) === 0) {
         this.logUnchangedRefresh(agent.name, refreshStartedAt);
         return {
           ...this.refreshStrategyBase(sessions, result.completeness, scope, {
             scanDuration: performance.now() - scanStartedAt,
-            workerRun
+            workerRun,
+            pendingAgentState
           }),
           status: "unchanged"
         };
@@ -5091,7 +5528,8 @@ var AgentSyncEngine = class {
         ...this.refreshStrategyBase(sessions, result.completeness, scope, {
           scanDuration: performance.now() - scanStartedAt,
           sourceFailures: result.sourceFailures ?? [],
-          workerRun
+          workerRun,
+          pendingAgentState
         }),
         status: "continue",
         publication: {
@@ -5105,7 +5543,7 @@ var AgentSyncEngine = class {
       throw error;
     }
   }
-  async refreshChangedAgent(agent, refresh, baseline, refreshStartedAt) {
+  async refreshChangedAgent(agent, refresh, refreshTransaction, baseline, refreshStartedAt) {
     const scope = this.startupScanOptions();
     if (refresh.kind === "failed") {
       appLogger.warn("scan.refresh.change_check_failed", {
@@ -5133,9 +5571,12 @@ var AgentSyncEngine = class {
       const workerRun = await this.runWorker(agent, baseline, { kind: "recompute-derived" }, {});
       try {
         const { result } = workerRun;
-        agent.restoreSessionCacheMeta(result.meta);
         const sessions2 = attachMissingProjectIdentities(result.sessions);
-        this.lastRefreshAtByAgent.set(agent.name, checkResult.timestamp);
+        const pendingAgentState = {
+          meta: result.meta,
+          refreshedAt: checkResult.timestamp,
+          refreshTransaction
+        };
         const persistenceDiff = buildSessionPersistenceDiff(baseline, sessions2);
         if (persistenceDiff.changedSessions.length === 0 && persistenceDiff.removedSessionIds.length === 0) {
           this.logUnchangedRefresh(agent.name, refreshStartedAt);
@@ -5148,7 +5589,7 @@ var AgentSyncEngine = class {
                 checkDuration,
                 scanDuration: performance.now() - scanStartedAt2,
                 workerRun,
-                commitChangeCheck: () => commitAgentRefreshCheck(refresh)
+                pendingAgentState
               }
             ),
             status: "unchanged"
@@ -5164,7 +5605,7 @@ var AgentSyncEngine = class {
               scanDuration: performance.now() - scanStartedAt2,
               sourceFailures: result.sourceFailures ?? [],
               workerRun,
-              commitChangeCheck: () => commitAgentRefreshCheck(refresh)
+              pendingAgentState
             }
           ),
           status: "continue",
@@ -5180,30 +5621,32 @@ var AgentSyncEngine = class {
       const workerRun = await this.runWorker(agent, baseline, { kind: "full-scan" }, scope);
       try {
         const { result } = workerRun;
-        agent.restoreSessionCacheMeta(result.meta);
         const sessions2 = attachMissingProjectIdentities(result.sessions);
-        this.lastRefreshAtByAgent.set(agent.name, checkResult.timestamp);
+        const persistenceDiff = buildSessionPersistenceDiff(baseline, sessions2, {
+          // Worker-reported IDs also preserve metadata-only pricing repairs.
+          candidateChangedIds: result.changedIds ?? [],
+          completeness: result.completeness,
+          explicitRemovedSessionIds: result.explicitRemovedSessionIds
+        });
+        const strategy = this.refreshStrategyBase(sessions2, result.completeness, scope, {
+          checkDuration,
+          scanDuration: performance.now() - scanStartedAt,
+          sourceFailures: result.sourceFailures ?? [],
+          workerRun,
+          pendingAgentState: {
+            meta: result.meta,
+            refreshedAt: checkResult.timestamp,
+            refreshTransaction
+          }
+        });
+        if (persistenceDiff.changedSessions.length === 0 && persistenceDiff.removedSessionIds.length === 0 && (result.sourceFailures?.length ?? 0) === 0) {
+          this.logUnchangedRefresh(agent.name, refreshStartedAt);
+          return { ...strategy, status: "unchanged" };
+        }
         return {
-          ...this.refreshStrategyBase(sessions2, result.completeness, scope, {
-            checkDuration,
-            scanDuration: performance.now() - scanStartedAt,
-            sourceFailures: result.sourceFailures ?? [],
-            workerRun,
-            commitChangeCheck: () => commitAgentRefreshCheck(refresh)
-          }),
+          ...strategy,
           status: "continue",
-          publication: {
-            kind: "changes",
-            // Meta-only changes (e.g. a pricing capture epoch bump) leave the head
-            // signature intact; without the worker-reported ids they would never
-            // persist and checkForChanges would rescan on every startup.
-            diff: buildSessionPersistenceDiff(baseline, sessions2, {
-              candidateChangedIds: result.changedIds ?? [],
-              completeness: result.completeness,
-              explicitRemovedSessionIds: result.explicitRemovedSessionIds
-            }),
-            candidateChangedIds: []
-          }
+          publication: { kind: "changes", diff: persistenceDiff, candidateChangedIds: [] }
         };
       } catch (error) {
         workerRun.discard();
@@ -5217,7 +5660,6 @@ var AgentSyncEngine = class {
         source.incrementalScan(baseline, preciseChangedIds, checkResult.refs, scope)
       )
     );
-    this.lastRefreshAtByAgent.set(agent.name, checkResult.timestamp);
     const sourceFailures = checkResult.sourceFailures ?? [];
     const completeness = resolveSessionSnapshotCompleteness(scope, sourceFailures);
     return {
@@ -5225,7 +5667,11 @@ var AgentSyncEngine = class {
         checkDuration,
         scanDuration: performance.now() - scanStartedAt,
         sourceFailures,
-        commitChangeCheck: () => commitAgentRefreshCheck(refresh)
+        pendingAgentState: {
+          meta: agent.snapshotSessionCacheMeta(),
+          refreshedAt: checkResult.timestamp,
+          refreshTransaction
+        }
       }),
       status: "continue",
       publication: {
@@ -5301,9 +5747,8 @@ var AgentSyncEngine = class {
     const startedAt = performance.now();
     const agent = this.findAgent(agentName);
     if (!agent || !agent.isAvailable()) return "skipped";
-    const snapshot = this.sessionIndex.snapshot();
     const cached = this.readCachedSessionsOrWarn("scan.backfill", agentName);
-    const baseline = cached?.sessions ?? snapshot.byAgent[agentName] ?? [];
+    const baseline = cached?.sessions ?? this.sessionIndex.agentSessions(agentName);
     const meta = cached?.meta ?? buildAgentCacheMeta(agent);
     const backfillCursor = getAgentFullSyncCursor(agentName);
     if (cached) agent.restoreSessionCacheMeta(cached.meta);
@@ -5337,7 +5782,6 @@ var AgentSyncEngine = class {
         }
       );
       const { result } = workerRun;
-      agent.restoreSessionCacheMeta(result.meta);
       const fullSessions = attachMissingProjectIdentities(result.sessions);
       const completion = buildScanCompletion(result.completeness, result.sourceFailures ?? []);
       this.statusReporter.flushProgressStatus(`backfill:${agentName}`);
@@ -5360,7 +5804,7 @@ var AgentSyncEngine = class {
           context: "scan.backfill",
           agentName,
           sessions: fullSessions,
-          meta: buildAgentCacheMeta(agent),
+          meta: result.meta,
           completeness: result.completeness,
           removedSessionIds: result.explicitRemovedSessionIds,
           saveCache: true
@@ -5377,6 +5821,7 @@ var AgentSyncEngine = class {
           }
         }
       });
+      this.commitAgentState("scan.backfill", agent, { meta: result.meta });
       try {
         if (completion.completeness === "complete" && !markAgentFullSyncCompleted(agentName)) {
           appLogger.warn("scan.backfill.completion_not_durable", { agent: agentName });
@@ -5402,7 +5847,6 @@ var AgentSyncEngine = class {
       }
       return "committed";
     } catch (error) {
-      agent.restoreSessionCacheMeta(meta);
       workerRun?.discard();
       appLogger.error("scan.backfill.error", { agent: agentName, error });
       console.error(`[${agentName}] Backfill failed:`, error);
@@ -5425,7 +5869,7 @@ var AgentSyncEngine = class {
 
 // src/session-watcher.ts
 import { existsSync as existsSync3, readdirSync, statSync, watch } from "fs";
-import { dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve2 } from "path";
+import { basename, 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) {
@@ -5531,7 +5975,11 @@ var SessionWatcher = class {
         const targetPath = toAbsolutePath(target.path);
         const scopes = scopesByRoot.get(rootPath) ?? [];
         if (!scopes.some((scope) => scope.agentName === agent.name && scope.targetPath === targetPath)) {
-          scopes.push({ agentName: agent.name, targetPath });
+          scopes.push({
+            agentName: agent.name,
+            targetPath,
+            ignoredFileNames: target.ignoredFileNames
+          });
         }
         scopesByRoot.set(rootPath, scopes);
       }
@@ -5650,7 +6098,9 @@ var SessionWatcher = class {
   handleWatchEvent(watchPath, scopes, eventType, filename) {
     const changedPath = resolveWatchEventPath(watchPath, filename);
     const agentNames = new Set(
-      scopes.filter((scope) => isRelatedPath(changedPath, scope.targetPath)).map((scope) => scope.agentName)
+      scopes.filter(
+        (scope) => isRelatedPath(changedPath, scope.targetPath) && !(scope.ignoredFileNames?.includes(basename(changedPath)) && changedPath !== scope.targetPath && isSameOrChildPath(scope.targetPath, changedPath))
+      ).map((scope) => scope.agentName)
     );
     if (agentNames.size === 0) {
       return;
@@ -5728,9 +6178,9 @@ var SessionWatcher = class {
 };
 
 // src/worker-runner.ts
-import { Worker as Worker3 } from "worker_threads";
+import { Worker as Worker4 } from "worker_threads";
 var SHUTDOWN_ERROR_MESSAGE3 = "Scan refresh worker shut down";
-function applySessionChanges2(previousSessions, changes, removedSessionIds) {
+function applySessionChanges(previousSessions, changes, removedSessionIds) {
   if (changes.length === 0 && removedSessionIds.length === 0) return previousSessions;
   const replacedIds = new Set(removedSessionIds);
   for (const { session } of changes) replacedIds.add(session.reference.sessionId);
@@ -5768,6 +6218,7 @@ var ThreadWorkerRunner = class {
   }
   workerUrl;
   workers = /* @__PURE__ */ new Map();
+  retirements = /* @__PURE__ */ new Set();
   nextRequestId = 1;
   isShuttingDown = false;
   get activeCount() {
@@ -5792,6 +6243,7 @@ var ThreadWorkerRunner = class {
       pricingGenerationId: getPricingGeneration().id,
       operation: payload.operation,
       scanOptions: payload.scanOptions,
+      logContext: appLogger.captureContext(),
       ...existingSlot ? {} : { previousSessions: payload.previousSessions, meta: payload.meta }
     };
     return new Promise((resolve4, reject) => {
@@ -5810,6 +6262,7 @@ var ThreadWorkerRunner = class {
         reject,
         payload,
         generation,
+        logContext: request.logContext ?? {},
         onProgress: payload.onProgress,
         onCheckpoint: payload.onCheckpoint
       });
@@ -5838,10 +6291,11 @@ var ThreadWorkerRunner = class {
       for (const pending of slot.pending.values()) pending.reject(shutdownError);
       slot.pending.clear();
     }
-    await Promise.allSettled(slots.map((slot) => slot.worker.terminate()));
+    for (const slot of slots) this.retireWorker(slot.worker);
+    await Promise.allSettled(this.retirements);
   }
   createWorker(agentName, request) {
-    const worker = new Worker3(this.workerUrl, { workerData: request });
+    const worker = new Worker4(this.workerUrl, { workerData: request });
     const slot = {
       agentName,
       worker,
@@ -5856,21 +6310,31 @@ var ThreadWorkerRunner = class {
       this.handleMessage(slot, message);
     });
     worker.on("error", (error) => {
-      this.closeWorker(agentName, slot, toError2(error));
+      appLogger.restoreContext(this.slotLogContext(slot), () => {
+        this.closeWorker(agentName, slot, toError2(error));
+        void this.retireWorker(worker);
+      });
     });
     worker.on("exit", (code) => {
-      if (slot.closed) return;
-      const error = new Error(`Scan refresh worker exited before completing (code ${code})`);
-      if (slot.pending.size > 0) {
-        appLogger.warn("scan.refresh_worker.exit_before_done", { agent: agentName, code });
-      }
-      this.closeWorker(agentName, slot, error);
+      appLogger.restoreContext(this.slotLogContext(slot), () => {
+        if (slot.closed) return;
+        const error = new Error(`Scan refresh worker exited before completing (code ${code})`);
+        if (slot.pending.size > 0) {
+          appLogger.warn("scan.refresh_worker.exit_before_done", { agent: agentName, code });
+        }
+        this.closeWorker(agentName, slot, error);
+      });
     });
     return slot;
   }
   handleMessage(slot, message) {
     const pending = slot.pending.get(message.requestId);
     if (!pending) return;
+    appLogger.restoreContext(pending.logContext, () => {
+      this.handlePendingMessage(slot, message, pending);
+    });
+  }
+  handlePendingMessage(slot, message, pending) {
     if (message.generation !== pending.generation) {
       const error = new Error(
         `Scan refresh generation mismatch: expected ${pending.generation}, received ${message.generation}`
@@ -5907,7 +6371,7 @@ var ThreadWorkerRunner = class {
     const removedMetaIds = [...message.removedSessionIds, ...message.removedMetaIds];
     try {
       const result = {
-        sessions: applySessionChanges2(
+        sessions: applySessionChanges(
           pending.payload.previousSessions,
           message.changes,
           message.removedSessionIds
@@ -5920,7 +6384,8 @@ var ThreadWorkerRunner = class {
       };
       slot.awaitingCommit = {
         requestId: message.requestId,
-        generation: message.generation
+        generation: message.generation,
+        logContext: pending.logContext
       };
       pending.resolve(this.createStagedRun(slot, message.requestId, message.generation, result));
     } catch (error) {
@@ -5952,7 +6417,8 @@ var ThreadWorkerRunner = class {
     const request = {
       type: "commit",
       requestId,
-      generation
+      generation,
+      logContext: awaiting.logContext
     };
     try {
       slot.worker.postMessage(request);
@@ -5976,19 +6442,30 @@ var ThreadWorkerRunner = class {
     slot.pending.clear();
     slot.awaitingCommit = null;
   }
+  slotLogContext(slot) {
+    for (const pending of slot.pending.values()) return pending.logContext;
+    return slot.awaitingCommit?.logContext ?? {};
+  }
   invalidateWorker(agentName, slot) {
     this.closeWorker(
       agentName,
       slot,
       new Error(`Scan refresh worker state discarded for ${agentName}`)
     );
-    void slot.worker.terminate().catch(() => void 0);
+    void this.retireWorker(slot.worker);
+  }
+  retireWorker(worker) {
+    const retirement = terminateWorkerAfterLogDrain(worker);
+    this.retirements.add(retirement);
+    void retirement.finally(() => this.retirements.delete(retirement)).catch(() => void 0);
+    return retirement;
   }
 };
 
 // src/live-scan.ts
 var NEW_SESSION_EVENT_WINDOW_MS = 250;
 var LiveScanStore = class {
+  queryScope;
   watchEnabled;
   scanOptions;
   startupScanOptions;
@@ -6003,6 +6480,10 @@ var LiveScanStore = class {
   constructor(options = {}) {
     this.watchEnabled = options.watchEnabled ?? true;
     this.scanOptions = options.scanOptions ?? {};
+    this.queryScope = {
+      ...this.scanOptions.agents?.length ? { agents: this.scanOptions.agents.map((agent) => agent.toLowerCase()) } : {},
+      ...this.scanOptions.cwd ? { projectScope: createProjectScopeMatcher(this.scanOptions.cwd) } : {}
+    };
     this.startupScanOptions = options.startupScanOptions ?? {};
     this.deferInitialRefresh = options.deferInitialRefresh === true;
     const workerRunner = options.workerRunner ?? new ThreadWorkerRunner(new URL("./scan-refresh-worker.js", import.meta.url));
@@ -6024,8 +6505,9 @@ var LiveScanStore = class {
       startup_to: this.startupScanOptions.to,
       deferred: this.deferInitialRefresh || void 0
     });
+    const { cwd: _cwd, ...scanOptions } = this.scanOptions;
     const initialResult = await scanSessions({
-      ...this.scanOptions,
+      ...scanOptions,
       useCache: this.scanOptions.useCache ?? true,
       cacheOnly: this.deferInitialRefresh,
       writeCache: this.deferInitialRefresh ? false : this.scanOptions.writeCache,
@@ -6035,7 +6517,7 @@ var LiveScanStore = class {
     this.syncEngine.initialize(initialResult, {
       cacheTimestamps: initialResult.cacheTimestamps,
       registeredAgents: createRegisteredAgents(),
-      allowedAgents: this.getAllowedAgents()
+      queryScope: this.queryScope
     });
     const snapshot = this.getSnapshot();
     const indexStartedAt = performance.now();
@@ -6144,10 +6626,6 @@ var LiveScanStore = class {
     if (workerUrl.protocol === "file:" && !existsSync4(fileURLToPath3(workerUrl))) return null;
     return workerUrl;
   }
-  getAllowedAgents() {
-    if (!this.scanOptions.agents?.length) return null;
-    return new Set(this.scanOptions.agents.map((agent) => agent.toLowerCase()));
-  }
 };
 
 // src/output.ts
@@ -6274,7 +6752,8 @@ function startPricingRefresh(timeoutMs = REFRESH_TIMEOUT_MS) {
     }
   );
   return {
-    publish() {
+    async ready() {
+      await completion;
       if (publishPendingPricing()) appLogger.info("pricing.refresh.published", {});
     },
     async cancel() {
@@ -6287,8 +6766,23 @@ function startPricingRefresh(timeoutMs = REFRESH_TIMEOUT_MS) {
 // src/index.ts
 process.on("unhandledRejection", (reason) => {
   appLogger.error("process.unhandled_rejection", { error: reason });
+  appLogger.flushSync();
   throw reason;
 });
+process.on("uncaughtExceptionMonitor", (error, origin) => {
+  appLogger.error("process.uncaught_exception", { error, exception_origin: origin });
+  appLogger.flushSync();
+});
+var closeApplicationLog = (exitCode) => closeLoggerBeforeTermination(() => appLogger.close(), exitCode);
+var shutdownOnSignal = (signal) => {
+  appLogger.info("cli.shutdown", { signal, phase: "startup" });
+  appLogger.flushSync();
+  process.exit(0);
+};
+var dispatchSignal = (signal) => shutdownOnSignal(signal);
+process.once("SIGINT", dispatchSignal);
+process.once("SIGTERM", dispatchSignal);
+process.once("SIGHUP", dispatchSignal);
 var main = defineCommand({
   meta: {
     name: "codesesh",
@@ -6337,7 +6831,7 @@ var main = defineCommand({
     days: {
       type: "string",
       alias: "d",
-      description: "Only include sessions active in the last N days (0 = all time)",
+      description: "Only include sessions active in the last N local calendar days (0 = all time)",
       default: "7"
     },
     cwd: {
@@ -6346,11 +6840,11 @@ var main = defineCommand({
     },
     from: {
       type: "string",
-      description: "Sessions active after this date, YYYY-MM-DD (overrides --days)"
+      description: "Sessions active on or after this date, YYYY-MM-DD (overrides --days)"
     },
     to: {
       type: "string",
-      description: "Sessions active before this date (YYYY-MM-DD)"
+      description: "Sessions active on or before this date (YYYY-MM-DD)"
     },
     session: {
       type: "string",
@@ -6433,7 +6927,7 @@ var main = defineCommand({
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./discovery-K3GLISI6.js");
+      const { clearCache: clear } = await import("./discovery-ADSQARBV.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");
@@ -6444,6 +6938,7 @@ var main = defineCommand({
       targetSession = parseSessionUri(args.session);
       if (!targetSession) {
         console.error(`Invalid session format: ${args.session}. Expected: agent://session-id`);
+        await closeApplicationLog(1);
         process.exit(1);
       }
     }
@@ -6461,6 +6956,7 @@ var main = defineCommand({
       { currentWorkingDirectory: process.cwd() }
     );
     const { from: listDefaultFrom, to: listDefaultTo, days: listDefaultDays } = listWindow;
+    await pricingRefresh.ready();
     const store = new LiveScanStore({
       watchEnabled: !jsonOnly,
       scanOptions,
@@ -6500,6 +6996,7 @@ var main = defineCommand({
         console.log(JSON.stringify(output, null, 2));
       }
       await store.shutdown();
+      await closeApplicationLog(process.exitCode ?? 0);
       return;
     }
     const agents = createRegisteredAgents();
@@ -6518,11 +7015,11 @@ var main = defineCommand({
       });
     } catch (error) {
       console.error(getServerStartupErrorMessage(error, port));
+      await closeApplicationLog(1);
       process.exit(1);
     }
     const { url } = app;
     if (!jsonOnly) {
-      pricingRefresh.publish();
       store.startBackgroundRefresh();
     }
     let shuttingDown = false;
@@ -6532,16 +7029,16 @@ var main = defineCommand({
       appLogger.info("cli.shutdown", { signal });
       await pricingRefresh.cancel();
       await app.shutdown();
+      await closeApplicationLog(0);
       process.exit(0);
     };
-    const shutdownOnSignal = (signal) => {
-      shutdown(signal).catch((error) => {
+    shutdownOnSignal = (signal) => {
+      shutdown(signal).catch(async (error) => {
         appLogger.error("cli.shutdown_failed", { signal, error });
+        await closeApplicationLog(1);
         process.exit(1);
       });
     };
-    process.once("SIGINT", shutdownOnSignal);
-    process.once("SIGTERM", shutdownOnSignal);
     console.log(`  ${url}`);
     console.log("");
     appLogger.info("cli.ready", {
@@ -6557,6 +7054,17 @@ var main = defineCommand({
     }
   }
 });
+var runCliCommand = main.run;
+if (!runCliCommand) throw new Error("CLI command is missing its runner");
+main.run = async (context) => {
+  try {
+    return await runCliCommand(context);
+  } catch (error) {
+    appLogger.error("cli.fatal", { error });
+    await closeApplicationLog(1);
+    throw error;
+  }
+};
 if (process.argv.slice(2).includes("-v")) {
   console.log(VERSION);
   process.exit(0);