codesesh 1.0.2 → 1.0.3

package/dist/index.js

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
+import {
+  AGENT_UNAVAILABLE_DURING_SCAN_ERROR_CODE,
+  AgentUnavailableDuringScanError
+} from "./chunk-RF3EEWPH.js";
 import {
   appLogger,
   logSearchIndexSync
-} from "./chunk-PROMURPM.js";
+} from "./chunk-WAKW5OPS.js";
 import {
   FileSystemSessionSource,
+  PROJECT_IDENTITY_RESOLVER_REVISION,
   SessionAliasValidationError,
   StateStorageUnavailableError,
   addCalendarDays,
@@ -16,7 +21,7 @@ import {
   closeCacheStorage,
   computeSessionDiff,
   countCalendarDays,
-  createProjectScopeMatcher,
+  createProjectScopeMatcherFromIdentity,
   createRegisteredAgents,
   createSessionIndex,
   createSessionProjectionContext,
@@ -28,16 +33,17 @@ import {
   formatSessionReference,
   getAgentFullSyncCursor,
   getAgentInfoMap,
+  getAnalyticsRevision,
   getPricingGeneration,
+  getSearchProjectDirectory,
   getSessionActivityTime,
   getSessionAgentKey,
-  getSessionRouteKey,
   importBookmarks,
   isProjectIdentityKind,
   listBookmarks,
   listCachedProjectGroups,
+  listDashboardCostFacts,
   listFileActivity,
-  listModelCostDistribution,
   listSessionAliases,
   loadCachedSessionHeads,
   loadCachedSessions,
@@ -51,11 +57,13 @@ import {
   mergeSearchQueryOptions,
   mergeSessionsUpdatedEvents,
   mergeSortedSessions,
+  normalizeProjectDirectory,
   normalizeSessionReference,
   perf,
   publishPendingPricing,
   readAgentCacheInitialization,
   readAgentLastFullSyncAt,
+  readCachedSessions,
   readPendingSearchIndexMaintenance,
   refreshPricingCache,
   scanSessions,
@@ -65,7 +73,7 @@ import {
   startOfCalendarDay,
   upsertBookmark,
   upsertSessionAlias
-} from "./chunk-VAUC2W7I.js";
+} from "./chunk-PSHZZITB.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -317,136 +325,92 @@ function paginateSessionSnapshot(items, request) {
   };
 }
 
-// src/api/session-aliases-view.ts
-function aliasKey(reference) {
-  return `${reference.agentName.toLowerCase()}\0${reference.sessionId}`;
-}
-function loadAliasMap() {
-  try {
-    return new Map(listSessionAliases().map((alias) => [aliasKey(alias.reference), alias]));
-  } catch (error) {
-    if (!(error instanceof StateStorageUnavailableError)) {
-      appLogger.warn("api.session_aliases.load_failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-    return /* @__PURE__ */ new Map();
-  }
-}
-function buildAliasView() {
-  const aliases = loadAliasMap();
-  return {
-    size: aliases.size,
-    get: (reference) => aliases.get(aliasKey(reference))?.alias,
-    decorate(record, reference) {
-      const alias = aliases.get(aliasKey(reference))?.alias;
-      return alias ? { ...record, display_title: alias } : record;
-    },
-    entries: () => aliases.values()
-  };
-}
-var cachedView = null;
-function loadAliasView() {
-  return cachedView ??= buildAliasView();
-}
-function invalidateAliasView() {
-  cachedView = null;
-}
-function decorateBookmark(bookmark, aliases) {
-  if (bookmark.availability === "available") {
-    return {
-      ...bookmark,
-      session: aliases.decorate(bookmark.session, bookmark.reference)
-    };
-  }
-  const displayTitle = aliases.get(bookmark.reference);
-  return displayTitle ? { ...bookmark, display_title: displayTitle } : bookmark;
-}
-function decorateFileActivity(activity, aliases) {
-  return {
-    ...activity,
-    session: aliases.decorate(activity.session, activity.reference)
-  };
-}
-function findAliasSearchResults(query, options, scanResult, aliases) {
-  const search = mergeSearchQueryOptions(query, options);
-  const needle = search.text.trim().toLowerCase();
-  if (!needle || aliases.size === 0) return [];
-  const sessionsByAgent = /* @__PURE__ */ new Map();
-  const lookupSession = (agentName, sessionId) => {
-    let byId = sessionsByAgent.get(agentName);
-    if (!byId) {
-      byId = new Map((scanResult.byAgent[agentName] ?? []).map((item) => [item.id, item]));
-      sessionsByAgent.set(agentName, byId);
-    }
-    return byId.get(sessionId);
-  };
-  const results = [];
-  for (const alias of aliases.entries()) {
-    if (!alias.alias.toLowerCase().includes(needle)) continue;
-    const { agentName, sessionId } = alias.reference;
-    const session = lookupSession(agentName, sessionId);
-    if (!session) continue;
-    results.push({
-      reference: alias.reference,
-      session: aliases.decorate(session, alias.reference),
-      snippet: `Alias \xB7 ${session.directory}`,
-      snippetHighlights: [],
-      matchType: "title"
-    });
-  }
-  return filterSessionSearchCandidates(results, search.options, scanResult.sessions).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);
-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-aggregation.ts
 var SNAPSHOT_AGGREGATION_CACHE_LIMIT = 64;
 var snapshotAggregationCaches = /* @__PURE__ */ new WeakMap();
-function getSnapshotAggregation(source, sessions, key, build) {
+function getSnapshotAggregationCache(source, sessions) {
   let cache = snapshotAggregationCaches.get(source);
   if (!cache || cache.sessions !== sessions) {
     cache = { sessions, values: /* @__PURE__ */ new Map() };
     snapshotAggregationCaches.set(source, cache);
   }
+  return cache;
+}
+function getSnapshotAggregation(source, sessions, key, build, onCacheState) {
+  const cache = getSnapshotAggregationCache(source, sessions);
   const cacheKey = JSON.stringify(key);
-  if (cache.values.has(cacheKey)) return cache.values.get(cacheKey);
+  if (cache.values.has(cacheKey)) {
+    const cached = cache.values.get(cacheKey);
+    cache.values.delete(cacheKey);
+    cache.values.set(cacheKey, cached);
+    onCacheState?.("hit");
+    return cached;
+  }
   const value = build();
   if (cache.values.size >= SNAPSHOT_AGGREGATION_CACHE_LIMIT) {
     const oldestKey = cache.values.keys().next().value;
     if (oldestKey != null) cache.values.delete(oldestKey);
   }
   cache.values.set(cacheKey, value);
+  onCacheState?.("miss");
   return value;
 }
-function withStorageErrors(handler, onUnavailable) {
-  try {
-    return handler();
-  } catch (error) {
-    if (error instanceof StateStorageUnavailableError) {
-      return onUnavailable();
-    }
-    throw error;
+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 });
+  if (analyticsRevision === null) return build();
+  return getSnapshotAggregation(
+    source,
+    sessions,
+    ["dashboard-cost-facts", from, 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
+    })
+  });
+  const startedAt = performance.now();
+  const log = (cache) => {
+    appLogger.info("api.dashboard.storage_aggregation", {
+      cache,
+      ...analyticsRevision === null ? {} : { analytics_revision: analyticsRevision },
+      duration_ms: Math.round(performance.now() - startedAt)
+    });
+  };
+  if (analyticsRevision === null) {
+    const value = build();
+    log("unavailable");
+    return value;
   }
+  return getSnapshotAggregation(
+    source,
+    sessions,
+    [
+      "dashboard-storage",
+      scope.agent,
+      scope.projectKind,
+      scope.projectKey,
+      from,
+      cacheTo,
+      analyticsRevision
+    ],
+    build,
+    log
+  );
 }
+
+// src/api/request-payloads.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -496,23 +460,8 @@ function sanitizeClientLogData(value) {
     })
   );
 }
-function toSessionListItem(session) {
-  const {
-    model_usage: _modelUsage,
-    project_identity_resolver_revision: _resolverRevision,
-    project_identity_input_signature: _identityInputSignature,
-    smart_tags_source_updated_at: _smartTagsSourceUpdatedAt,
-    smart_tags_classifier_revision: _smartTagsClassifierRevision,
-    ...item
-  } = session;
-  return item;
-}
-function getSessionHeadReference(session) {
-  return {
-    agentName: getSessionAgentKey(session),
-    sessionId: session.id
-  };
-}
+
+// src/api/session-detail-stream.ts
 var SESSION_DETAIL_STREAM_BATCH_CHARS = 64 * 1024;
 function createSessionDetailJsonResponse(data, messages) {
   const encoder = new TextEncoder();
@@ -565,6 +514,193 @@ function createSessionDetailJsonResponse(data, messages) {
     { headers: { "Content-Type": "application/json; charset=UTF-8" } }
   );
 }
+
+// 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 } };
+  });
+}
+var ALIAS_SEARCH_RESULT_SHARE = 0.25;
+function searchResultKey(result) {
+  return `${result.reference.agentName}\0${result.reference.sessionId}`;
+}
+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 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/session-aliases-view.ts
+function aliasKey(reference) {
+  return `${reference.agentName.toLowerCase()}\0${reference.sessionId}`;
+}
+function loadAliasMap() {
+  try {
+    return new Map(listSessionAliases().map((alias) => [aliasKey(alias.reference), alias]));
+  } catch (error) {
+    if (!(error instanceof StateStorageUnavailableError)) {
+      appLogger.warn("api.session_aliases.load_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return /* @__PURE__ */ new Map();
+  }
+}
+function buildAliasView() {
+  const aliases = loadAliasMap();
+  return {
+    size: aliases.size,
+    get: (reference) => aliases.get(aliasKey(reference))?.alias,
+    decorate(record, reference) {
+      const alias = aliases.get(aliasKey(reference))?.alias;
+      return alias ? { ...record, display_title: alias } : record;
+    },
+    entries: () => aliases.values()
+  };
+}
+var cachedView = null;
+function loadAliasView() {
+  return cachedView ??= buildAliasView();
+}
+function invalidateAliasView() {
+  cachedView = null;
+}
+function decorateBookmark(bookmark, aliases) {
+  if (bookmark.availability === "available") {
+    return {
+      ...bookmark,
+      session: aliases.decorate(bookmark.session, bookmark.reference)
+    };
+  }
+  const displayTitle = aliases.get(bookmark.reference);
+  return displayTitle ? { ...bookmark, display_title: displayTitle } : bookmark;
+}
+function decorateFileActivity(activity, aliases) {
+  return {
+    ...activity,
+    session: aliases.decorate(activity.session, activity.reference)
+  };
+}
+function findAliasSearchResults(query, options, scanResult, aliases, context = {}) {
+  const search = mergeSearchQueryOptions(query, options);
+  const needle = search.text.trim().toLowerCase();
+  if (!needle || aliases.size === 0) return [];
+  const sessionsByAgent = /* @__PURE__ */ new Map();
+  const lookupSession = (agentName, sessionId) => {
+    let byId = sessionsByAgent.get(agentName);
+    if (!byId) {
+      byId = new Map((scanResult.byAgent[agentName] ?? []).map((item) => [item.id, item]));
+      sessionsByAgent.set(agentName, byId);
+    }
+    return byId.get(sessionId);
+  };
+  const results = [];
+  for (const alias of aliases.entries()) {
+    if (!alias.alias.toLowerCase().includes(needle)) continue;
+    const { agentName, sessionId } = alias.reference;
+    const session = lookupSession(agentName, sessionId);
+    if (!session) continue;
+    results.push({
+      reference: alias.reference,
+      session: aliases.decorate(session, alias.reference),
+      snippet: `Alias \xB7 ${session.directory}`,
+      snippetHighlights: [],
+      matchType: "title"
+    });
+  }
+  return filterSessionSearchCandidates(results, search.options, {
+    sessionSnapshot: scanResult.sessions,
+    sessionTree: context.sessionTree
+  }).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) {
+  const normalizedCwd = normalizeProjectDirectory(cwd);
+  const matchingSession = sessions.find(
+    (session) => normalizeProjectDirectory(session.directory) === normalizedCwd && session.project_identity != null && session.project_identity_resolver_revision === PROJECT_IDENTITY_RESOLVER_REVISION && Boolean(session.project_identity_input_signature)
+  );
+  if (matchingSession?.project_identity) {
+    return createProjectScopeMatcherFromIdentity(cwd, matchingSession.project_identity);
+  }
+  if (!resolver) throw new Error("Project identity resolver is unavailable");
+  const projection = await resolver.resolve(cwd);
+  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 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)
+  };
+}
+function toSessionListItem(session) {
+  const {
+    model_usage: _modelUsage,
+    project_identity_resolver_revision: _resolverRevision,
+    project_identity_input_signature: _identityInputSignature,
+    smart_tags_source_updated_at: _smartTagsSourceUpdatedAt,
+    smart_tags_classifier_revision: _smartTagsClassifierRevision,
+    ...item
+  } = session;
+  return item;
+}
+function getSessionHeadReference(session) {
+  return {
+    agentName: getSessionAgentKey(session),
+    sessionId: session.id
+  };
+}
 function handleGetConfig(c, defaults) {
   const payload = {
     window: {
@@ -604,21 +740,30 @@ function handleGetProjects(c, scanSource, defaults = {}) {
   const window = parseDateWindowRequest(c, "projects", defaults);
   if (window.kind === "rejected") return window.response;
   const { from, to } = window;
+  const analyticsRevision = getAnalyticsRevision();
   const projects = getSnapshotAggregation(
     scanSource,
     scanResult.sessions,
-    ["projects", from, to],
+    ["projects", from, to, analyticsRevision],
     () => {
-      const tree = buildSessionTree(scanResult.sessions);
-      const sessions = filterSessionTreeByActivityWindow(scanResult.sessions, from, to, tree);
+      const tree = getSnapshotSessionTree(scanSource, scanResult.sessions);
+      const costFacts = listDashboardCostFacts({ from, to, includeModelCosts: false });
       return {
-        projects: attachProjectMetricsFromTree(listCachedProjectGroups(sessions), tree, from, to)
+        projects: attachProjectMetricsFromTree(
+          listCachedProjectGroups(scanResult.sessions),
+          tree,
+          from,
+          to,
+          costFacts
+        ).filter(
+          (project) => project.sessionCount > 0 || project.messages > 0 || project.tokens > 0 || project.cost > 0
+        )
       };
     }
   );
   return c.json(projects);
 }
-function handleGetSessions(c, scanSource, defaults = {}) {
+async function handleGetSessions(c, scanSource, defaults = {}, resolver) {
   const scanResult = scanSource.getSnapshot();
   const params = searchParams(c);
   const paginationRequested = params.has("limit") || params.has("cursor");
@@ -628,7 +773,7 @@ function handleGetSessions(c, scanSource, defaults = {}) {
     return c.json({ error: sessionQuery.limit.error }, 400);
   }
   const q = c.req.query("q")?.toLowerCase();
-  const cwd = c.req.query("cwd");
+  const cwd = optionalQueryValue(c.req.query("cwd"));
   const projectIdentity = parseProjectIdentityFilter(
     c.req.query("projectKind"),
     c.req.query("projectKey")
@@ -640,6 +785,15 @@ function handleGetSessions(c, scanSource, defaults = {}) {
   const window = parseDateWindowRequest(c, "sessions", defaults);
   if (window.kind === "rejected") return window.response;
   const { from, to } = window;
+  let projectScope;
+  if (cwd && !projectIdentity) {
+    try {
+      projectScope = await resolveProjectScope(cwd, scanResult.sessions, resolver);
+    } catch (error) {
+      reportProjectScopeResolutionFailure("sessions", error);
+      return c.json({ error: "Project scope unavailable" }, 503);
+    }
+  }
   if (sessionQuery.agent.kind === "unknown") {
     reportInvalidQueryParameter("sessions", "agent", "empty_result");
   }
@@ -647,15 +801,25 @@ function handleGetSessions(c, scanSource, defaults = {}) {
   let sessions = getSnapshotAggregation(
     scanSource,
     scanResult.sessions,
-    ["sessions", agentFilter, projectIdentity?.kind, projectIdentity?.key, cwd, tag, from, to],
+    [
+      "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 (cwd) {
-        const projectScope = createProjectScopeMatcher(cwd);
+      } else if (projectScope) {
         filtered = filtered.filter((session) => matchesProjectScope(session, projectScope));
       }
       filtered = filterSessionsByActivityWindow(filtered, from, to);
@@ -697,58 +861,7 @@ function handleGetSessions(c, scanSource, defaults = {}) {
     )
   });
 }
-function withParentContext(results, sessions, aliases) {
-  if (!results.some((result) => result.session.parent_reference)) return results;
-  const byRouteKey = new Map(
-    sessions.map((session) => [
-      getSessionRouteKey(getSessionAgentKey(session), session.id),
-      session
-    ])
-  );
-  return results.map((result) => {
-    const parentReference = result.session.parent_reference;
-    if (!parentReference) return result;
-    const parent = byRouteKey.get(formatSessionReference(parentReference));
-    if (!parent) return result;
-    const reference = normalizeSessionReference(parentReference);
-    return { ...result, parent: { reference, title: aliases.get(reference) ?? parent.title } };
-  });
-}
-var ALIAS_SEARCH_RESULT_SHARE = 0.25;
-function searchResultKey(result) {
-  return `${result.reference.agentName}\0${result.reference.sessionId}`;
-}
-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 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);
-}
-function handleSearchSessions(c, scanSource, defaults = {}) {
+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);
@@ -769,7 +882,7 @@ function handleSearchSessions(c, scanSource, defaults = {}) {
     reportInvalidQueryParameter("search", "agent", "empty_result");
     return c.json({ results: [] });
   }
-  const searchOptions = parseSearchOptions(
+  const searchRequestOptions = parseSearchOptions(
     c,
     window,
     {
@@ -778,18 +891,45 @@ function handleSearchSessions(c, scanSource, defaults = {}) {
     },
     projectIdentity
   );
+  const cwd = getSearchProjectDirectory(query, searchRequestOptions);
+  let projectScope;
+  if (cwd) {
+    try {
+      projectScope = await resolveProjectScope(cwd, scanResult.sessions, resolver);
+    } catch (error) {
+      reportProjectScopeResolutionFailure("search", error);
+      return c.json({ error: "Project scope unavailable" }, 503);
+    }
+  }
+  const { cwd: _cwd, ...searchOptions } = searchRequestOptions;
+  const resolvedSearchOptions = projectScope ? { ...searchOptions, projectScope } : searchOptions;
   const aliases = loadAliasView();
-  const results = executeSessionSearch(query, searchOptions, scanResult).map((result) => ({
+  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, searchOptions, scanResult, aliases);
-  const mergedResults = mergeAliasSearchResults(results, aliasResults, searchOptions.limit ?? 50);
+  const aliasResults = findAliasSearchResults(
+    query,
+    resolvedSearchOptions,
+    scanResult,
+    aliases,
+    searchContext
+  );
+  const mergedResults = mergeAliasSearchResults(
+    results,
+    aliasResults,
+    resolvedSearchOptions.limit ?? 50
+  );
   return c.json({
-    results: withParentContext(mergedResults, scanResult.sessions, aliases)
+    results: withParentContext(mergedResults, getSessionTree, aliases)
   });
 }
-function handleGetFileActivity(c, defaults = {}) {
+async function handleGetFileActivity(c, defaults = {}, resolver) {
   const sessionQuery = parseSessionQuery(
     searchParams(c),
     KNOWN_AGENT_NAMES,
@@ -812,6 +952,16 @@ function handleGetFileActivity(c, defaults = {}) {
     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);
+    } catch (error) {
+      reportProjectScopeResolutionFailure("file-activity", error);
+      return c.json({ error: "Project scope unavailable" }, 503);
+    }
+  }
   const aliases = loadAliasView();
   return c.json({
     activity: listFileActivity({
@@ -820,7 +970,7 @@ function handleGetFileActivity(c, defaults = {}) {
       projectKind: projectIdentity?.kind,
       projectKey: projectIdentity?.key,
       project: optionalQueryValue(c.req.query("project")),
-      cwd: optionalQueryValue(c.req.query("cwd")),
+      projectScope,
       path: optionalQueryValue(c.req.query("path")),
       kind: parseFileActivityKind(optionalQueryValue(c.req.query("kind"))),
       from: window.from,
@@ -829,7 +979,7 @@ function handleGetFileActivity(c, defaults = {}) {
     }).map((activity) => decorateFileActivity(activity, aliases))
   });
 }
-async function handleGetSessionData(c, scanSource) {
+async function handleGetSessionData(c, scanSource, resolver) {
   const startedAt = performance.now();
   const agentName = c.req.param("agent");
   const sessionId = c.req.param("id");
@@ -845,7 +995,18 @@ async function handleGetSessionData(c, scanSource) {
       sessionId
     };
     const messageCursor = optionalQueryValue(c.req.query("messageCursor"));
-    const result = messageCursor ? materializeSessionDetailResponse(scanSource.getSnapshot(), reference, { messageCursor }) : materializeSessionDetailResponse(scanSource.getSnapshot(), reference);
+    const materialize = (fallback) => materializeSessionDetailResponse(scanSource.getSnapshot(), reference, {
+      ...messageCursor ? { messageCursor } : {},
+      ...fallback ? { projectIdentityFallback: fallback } : {}
+    });
+    let result = materialize();
+    if (result.status === "needs-identity") {
+      if (!resolver) throw new Error("Project identity resolver is unavailable");
+      result = materialize((await resolver.resolve(result.directory)).identity);
+    }
+    if (result.status === "needs-identity") {
+      throw new Error("Project identity fallback was not applied");
+    }
     if (result.status === "unknown-agent") {
       return c.json({ error: `Unknown agent: ${agentName}` }, 404);
     }
@@ -884,15 +1045,118 @@ async function handleGetSessionData(c, scanSource) {
     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);
+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",
+    query: {
+      days: c.req.query("days"),
+      from: c.req.query("from"),
+      to: c.req.query("to")
+    },
+    defaults
+  });
+  const scope = {
+    agent: optionalQueryValue(c.req.query("agent"))?.toLowerCase(),
+    projectKind: projectIdentity?.kind,
+    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) => ({
+      ...item,
+      session: aliases.decorate(item.session, item.reference)
+    })),
+    recentFileActivities: data.recentFileActivities.map(
+      (activity) => decorateFileActivity(activity, aliases)
+    )
+  });
+}
+
+// src/api/bookmark-handlers.ts
+function withStorageErrors(handler, onUnavailable) {
+  try {
+    return handler();
+  } catch (error) {
+    if (error instanceof StateStorageUnavailableError) {
+      return onUnavailable();
+    }
+    throw error;
   }
-  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 materializeStoredBookmarks(scanSource, bookmarks, aliases) {
   const snapshot = scanSource.getSnapshot();
@@ -921,11 +1185,17 @@ function handleGetBookmarks(c, scanSource) {
     () => c.json({ bookmarks: [], storageAvailable: false })
   );
 }
+function isKnownAgentKey(agentKey) {
+  return KNOWN_AGENT_NAME_SET.has(agentKey.trim().toLowerCase());
+}
 async function handlePutBookmark(c) {
   const payload = parseBookmarkReference(await c.req.json().catch(() => null));
   if (!payload) {
     return c.json({ error: "Invalid bookmark payload" }, 400);
   }
+  if (!isKnownAgentKey(payload.agentName)) {
+    return c.json({ error: `Unknown agent: ${payload.agentName}` }, 400);
+  }
   return withStorageErrors(
     () => c.json({ bookmark: upsertBookmark(payload), storageAvailable: true }),
     () => c.json({ error: "Bookmark storage is unavailable" }, 503)
@@ -936,15 +1206,21 @@ async function handleImportBookmarks(c, scanSource) {
   if (!Array.isArray(payload)) {
     return c.json({ error: "Invalid bookmark payload" }, 400);
   }
-  const bookmarks = payload.map((entry) => parseBookmarkImport(entry)).filter((entry) => entry !== null);
-  if (bookmarks.length !== payload.length) {
+  const parsed = payload.map((entry) => parseBookmarkImport(entry)).filter((entry) => entry !== null);
+  if (parsed.length !== payload.length) {
     return c.json({ error: "Invalid bookmark payload" }, 400);
   }
+  const bookmarks = parsed.filter((entry) => isKnownAgentKey(entry.reference.agentName));
+  const skippedUnknownAgents = parsed.length - bookmarks.length;
   return withStorageErrors(
     () => {
       const imported = importBookmarks(bookmarks);
       const views = materializeStoredBookmarks(scanSource, imported, loadAliasView());
-      return c.json({ bookmarks: views, storageAvailable: true });
+      return c.json({
+        bookmarks: views,
+        storageAvailable: true,
+        ...skippedUnknownAgents > 0 ? { skippedUnknownAgents } : {}
+      });
     },
     () => c.json({ error: "Bookmark storage is unavailable" }, 503)
   );
@@ -955,6 +1231,9 @@ function handleDeleteBookmark(c) {
   if (!agentKey || !sessionId) {
     return c.json({ error: "Missing bookmark identifier" }, 400);
   }
+  if (!isKnownAgentKey(agentKey)) {
+    return c.json({ error: `Unknown agent: ${agentKey}` }, 400);
+  }
   return withStorageErrors(
     () => {
       deleteBookmark({ agentName: agentKey, sessionId });
@@ -971,6 +1250,9 @@ async function handlePutSessionAlias(c) {
   if (!agentKey || !sessionId || typeof aliasValue !== "string") {
     return c.json({ error: "Invalid session alias payload" }, 400);
   }
+  if (!isKnownAgentKey(agentKey)) {
+    return c.json({ error: `Unknown agent: ${agentKey}` }, 400);
+  }
   try {
     return withStorageErrors(
       () => {
@@ -993,6 +1275,9 @@ function handleDeleteSessionAlias(c) {
   if (!agentKey || !sessionId) {
     return c.json({ error: "Missing session alias identifier" }, 400);
   }
+  if (!isKnownAgentKey(agentKey)) {
+    return c.json({ error: `Unknown agent: ${agentKey}` }, 400);
+  }
   return withStorageErrors(
     () => {
       deleteSessionAlias({ agentName: agentKey, sessionId });
@@ -1002,95 +1287,24 @@ function handleDeleteSessionAlias(c) {
     () => c.json({ error: "Session alias storage is unavailable" }, 503)
   );
 }
-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",
-    query: {
-      days: c.req.query("days"),
-      from: c.req.query("from"),
-      to: c.req.query("to")
-    },
-    defaults
-  });
-  const scope = {
-    agent: optionalQueryValue(c.req.query("agent"))?.toLowerCase(),
-    projectKind: projectIdentity?.kind,
-    projectKey: projectIdentity?.key
-  };
-  const compare = from == null ? void 0 : { from: addCalendarDays(from, -(days ?? countCalendarDays(from, to))), to: from - 1 };
-  const fixedTo = dateWindow.to;
-  const aggregate = getSnapshotAggregation(
-    scanSource,
-    scanResult.sessions,
-    [
-      "dashboard",
-      scope.agent,
-      scope.projectKind,
-      scope.projectKey,
-      from,
-      fixedTo ?? startOfCalendarDay(to),
-      compare?.from,
-      compare?.to
-    ],
-    () => {
-      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
-      });
-    }
-  );
-  const data = {
-    ...aggregate,
-    recentFileActivities: listFileActivity({
-      agent: scope.agent,
-      projectKind: scope.projectKind,
-      projectKey: scope.projectKey,
-      from,
-      to,
-      limit: 12
-    }),
-    modelCost: listModelCostDistribution({
-      agent: scope.agent,
-      projectKind: scope.projectKind,
-      projectKey: scope.projectKey,
-      from,
-      to
-    }),
-    window: { from, to, days, compareFrom: compare?.from, compareTo: compare?.to }
-  };
-  const aliases = loadAliasView();
-  return c.json({
-    ...data,
-    recentSessions: data.recentSessions.map((item) => ({
-      ...item,
-      session: aliases.decorate(item.session, item.reference)
-    })),
-    recentFileActivities: data.recentFileActivities.map(
-      (activity) => decorateFileActivity(activity, aliases)
-    )
-  });
-}
 
 // src/api/sse-event-buffer.ts
 var MAX_PENDING_CRITICAL_SSE_FRAMES = 64;
 function scanStatusMilestone(status) {
-  const agentStates = Object.entries(status.agentStatuses).sort(([left], [right]) => left.localeCompare(right)).map(([agentName, agentStatus]) => [agentName, agentStatus.status, agentStatus.error ?? null]);
+  const agentStates = Object.entries(status.agentStatuses).sort(([left], [right]) => left.localeCompare(right)).map(([agentName, agentStatus]) => [
+    agentName,
+    agentStatus.status,
+    agentStatus.error ?? null,
+    agentStatus.completeness ?? null,
+    agentStatus.sourceFailureCount ?? null,
+    agentStatus.sourceFailureSummary ?? null
+  ]);
+  const partialBackfills = Object.entries(status.backfill.partialAgents ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([agentName, completion]) => [
+    agentName,
+    completion.completeness,
+    completion.sourceFailureCount ?? null,
+    completion.sourceFailureSummary ?? null
+  ]);
   return JSON.stringify([
     status.active,
     status.phase,
@@ -1105,6 +1319,7 @@ function scanStatusMilestone(status) {
     status.backfill.completedAgents,
     status.backfill.failedAgents,
     status.backfill.progress?.phase ?? null,
+    partialBackfills,
     status.searchIndexMaintenance?.active ?? false,
     status.searchIndexMaintenance?.currentAgent ?? null,
     status.searchIndexMaintenance?.pendingAgents ?? [],
@@ -1281,10 +1496,22 @@ function createApiRoutes(scanSource, eventSource, options = {}) {
   }
   api.get("/agents", (c) => handleGetAgents(c, scanSource, listDefaults));
   api.get("/projects", (c) => handleGetProjects(c, scanSource, listDefaults));
-  api.get("/sessions", (c) => handleGetSessions(c, scanSource, listDefaults));
-  api.get("/search", (c) => handleSearchSessions(c, scanSource, listDefaults));
-  api.get("/file-activity", (c) => handleGetFileActivity(c, listDefaults));
-  api.get("/sessions/:agent/:id", (c) => handleGetSessionData(c, scanSource));
+  api.get(
+    "/sessions",
+    (c) => handleGetSessions(c, scanSource, listDefaults, options.projectIdentityResolver)
+  );
+  api.get(
+    "/search",
+    (c) => handleSearchSessions(c, scanSource, listDefaults, options.projectIdentityResolver)
+  );
+  api.get(
+    "/file-activity",
+    (c) => handleGetFileActivity(c, listDefaults, options.projectIdentityResolver)
+  );
+  api.get(
+    "/sessions/:agent/:id",
+    (c) => handleGetSessionData(c, scanSource, options.projectIdentityResolver)
+  );
   api.get("/dashboard", (c) => handleGetDashboard(c, scanSource, listDefaults));
   api.get("/bookmarks", (c) => handleGetBookmarks(c, scanSource));
   api.put("/bookmarks", (c) => handlePutBookmark(c));
@@ -1302,6 +1529,124 @@ function createApiRoutes(scanSource, eventSource, options = {}) {
   return api;
 }
 
+// src/project-identity-resolver.ts
+import { Worker } from "worker_threads";
+var PROJECT_IDENTITY_RESOLVER_MAX_WORKERS = 2;
+var SHUTDOWN_ERROR_MESSAGE = "Project identity resolver shut down";
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function isWorkerMessage(message) {
+  return typeof message === "object" && message !== null && "type" in message && (message.type === "resolved" && "requestId" in message && "projection" in message || message.type === "failed" && "requestId" in message && "error" in message);
+}
+var ThreadProjectIdentityResolver = class {
+  constructor(workerUrl, maxWorkers = PROJECT_IDENTITY_RESOLVER_MAX_WORKERS) {
+    this.workerUrl = workerUrl;
+    this.maxWorkers = maxWorkers;
+  }
+  workerUrl;
+  maxWorkers;
+  workers = /* @__PURE__ */ new Set();
+  queue = [];
+  nextRequestId = 1;
+  isShuttingDown = false;
+  resolve(cwd) {
+    if (this.isShuttingDown) return Promise.reject(new Error(SHUTDOWN_ERROR_MESSAGE));
+    return new Promise((resolve4, reject) => {
+      this.queue.push({ requestId: this.nextRequestId++, cwd, resolve: resolve4, reject });
+      this.pump();
+    });
+  }
+  async shutdown() {
+    if (this.isShuttingDown) return;
+    this.isShuttingDown = true;
+    const error = new Error(SHUTDOWN_ERROR_MESSAGE);
+    for (const request of this.queue.splice(0)) request.reject(error);
+    const workers = [...this.workers];
+    this.workers.clear();
+    for (const slot of workers) {
+      slot.closed = true;
+      slot.pending?.reject(error);
+      slot.pending = null;
+    }
+    await Promise.allSettled(workers.map(({ worker }) => worker.terminate()));
+  }
+  pump() {
+    while (!this.isShuttingDown && this.queue.length > 0) {
+      const slot = this.idleWorker() ?? this.createWorker();
+      if (!slot) return;
+      const request = this.queue.shift();
+      if (!request) return;
+      slot.pending = request;
+      try {
+        slot.worker.postMessage({
+          type: "resolve",
+          requestId: request.requestId,
+          cwd: request.cwd
+        });
+      } catch (error) {
+        this.closeWorker(slot, toError(error));
+      }
+    }
+  }
+  idleWorker() {
+    for (const slot of this.workers) {
+      if (!slot.closed && slot.pending == null) return slot;
+    }
+    return null;
+  }
+  createWorker() {
+    if (this.workers.size >= this.maxWorkers) return null;
+    let worker;
+    try {
+      worker = new Worker(this.workerUrl);
+    } catch (error) {
+      this.rejectQueued(toError(error));
+      return null;
+    }
+    const slot = { worker, pending: null, closed: false };
+    this.workers.add(slot);
+    worker.unref();
+    worker.on("message", (message) => {
+      if (appLogger.consumeWorkerMessage(message)) return;
+      this.handleWorkerMessage(slot, message);
+    });
+    worker.on("error", (error) => this.closeWorker(slot, toError(error)));
+    worker.on("exit", (code) => {
+      if (!slot.closed) {
+        this.closeWorker(slot, new Error(`Project identity worker exited with code ${code}`));
+      }
+    });
+    return slot;
+  }
+  handleWorkerMessage(slot, message) {
+    if (!isWorkerMessage(message) || slot.closed) return;
+    const request = slot.pending;
+    if (!request || message.requestId !== request.requestId) return;
+    slot.pending = null;
+    if (message.type === "resolved") request.resolve(message.projection);
+    else request.reject(new Error(message.error));
+    this.pump();
+  }
+  closeWorker(slot, error) {
+    if (slot.closed) return;
+    slot.closed = true;
+    this.workers.delete(slot);
+    const request = slot.pending;
+    slot.pending = null;
+    request?.reject(error);
+    if (!this.isShuttingDown) this.pump();
+  }
+  rejectQueued(error) {
+    for (const request of this.queue.splice(0)) request.reject(error);
+  }
+};
+function createProjectIdentityResolver() {
+  return new ThreadProjectIdentityResolver(
+    new URL("./project-identity-worker.js", import.meta.url)
+  );
+}
+
 // src/loopback-authority.ts
 import { isIP } from "net";
 var LOOPBACK_AUTHORITY_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
@@ -1366,7 +1711,6 @@ function validateLoopbackAuthority(rawHeaders, listenerHostname, listenerPort) {
 }
 
 // src/loopback-write-guard.ts
-var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
 var JSON_BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
 var ALLOWED_FETCH_SITES = /* @__PURE__ */ new Set(["same-origin", "none"]);
 function mediaType(contentType) {
@@ -1381,7 +1725,6 @@ function isSameOrigin(origin, requestOrigin) {
 }
 function evaluateLoopbackWriteRequest(request) {
   const method = request.method.toUpperCase();
-  if (SAFE_METHODS.has(method)) return { allowed: true };
   if (JSON_BODY_METHODS.has(method) && mediaType(request.contentType) !== "application/json") {
     return { allowed: false, reason: "content-type", status: 415 };
   }
@@ -1404,12 +1747,12 @@ function loopbackWriteGuard() {
       requestOrigin: url.origin
     });
     if (!decision.allowed) {
-      appLogger.warn("http.loopback_write.rejected", {
+      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 write request rejected";
+      const error = decision.reason === "content-type" ? "Write requests require application/json" : "Cross-origin API request rejected";
       return c.json({ error }, decision.status);
     }
     await next();
@@ -1572,6 +1915,7 @@ async function createServer(port, store, options = {}) {
   const remoteAccessToken = accessPolicy.authenticationRequired ? options.remoteAccessToken ?? (options.remoteAccess ? createRemoteAccessToken() : null) : null;
   const loopbackAuthorityEnabled = !accessPolicy.authenticationRequired;
   const shutdownController = new AbortController();
+  const projectIdentityResolver = options.projectIdentityResolver ?? createProjectIdentityResolver();
   let actualPort = null;
   appLogger.info("server.access_policy", {
     bind_category: accessPolicy.bindCategory,
@@ -1667,7 +2011,8 @@ async function createServer(port, store, options = {}) {
     defaultSessionFrom: options.defaultSessionFrom,
     defaultSessionTo: options.defaultSessionTo,
     defaultSessionDays: options.defaultSessionDays,
-    shutdownSignal: shutdownController.signal
+    shutdownSignal: shutdownController.signal,
+    projectIdentityResolver
   };
   app.route("/api", createApiRoutes(store, store, routeOptions));
   const webDistPath = options.webDistPath ?? findWebDistPath();
@@ -1752,8 +2097,12 @@ async function createServer(port, store, options = {}) {
         appLogger.info("server.shutdown.phase", { phase: "http-closing", port: actualPort });
         await closeHttpServer(server, actualPort);
       } finally {
-        appLogger.info("server.shutdown.phase", { phase: "store-closing", port: actualPort });
-        await store.shutdown();
+        try {
+          await projectIdentityResolver.shutdown();
+        } finally {
+          appLogger.info("server.shutdown.phase", { phase: "store-closing", port: actualPort });
+          await store.shutdown();
+        }
       }
       appLogger.info("server.shutdown.phase", { phase: "complete", port: actualPort });
     }
@@ -1800,7 +2149,9 @@ var AgentOperationScheduler = class {
     state.timer = setTimeout(() => {
       state.timer = null;
       state.timerDeadline = 0;
-      void this.refresh(agentName);
+      this.refresh(agentName).catch((error) => {
+        appLogger.error("scan.refresh.uncaught", { agent: agentName, error });
+      });
     }, effectiveDelayMs);
   }
   async refresh(agentName) {
@@ -1946,9 +2297,16 @@ var BackfillLifecycle = class {
     });
     return true;
   }
+  recordCompletion(attempt, completion) {
+    const current = this.matchingRunningAttempt(attempt);
+    if (!current) return false;
+    this.attempts.set(attempt.agentName, { ...current, completion: { ...completion } });
+    return true;
+  }
   complete(attempt, status) {
-    if (!this.matchingRunningAttempt(attempt)) return false;
-    this.attempts.set(attempt.agentName, { ...attempt, status });
+    const current = this.matchingRunningAttempt(attempt);
+    if (!current) return false;
+    this.attempts.set(attempt.agentName, { ...current, status });
     return true;
   }
   cancelAll() {
@@ -1965,17 +2323,25 @@ var BackfillLifecycle = class {
   stateFor(agentName) {
     const state = this.attempts.get(agentName);
     if (!state) return void 0;
-    return state.status === "running" && state.progress ? { ...state, progress: { ...state.progress } } : { ...state };
+    const completion = state.completion ? { completion: { ...state.completion } } : {};
+    return state.status === "running" && state.progress ? { ...state, progress: { ...state.progress }, ...completion } : { ...state, ...completion };
   }
   status() {
     const states = [...this.attempts.values()];
     const queued = states.filter((attempt) => attempt.status === "queued").sort((left, right) => left.attemptId - right.attemptId);
     const running = states.find((attempt) => attempt.status === "running");
+    const partialAgents = {};
+    for (const attempt of states) {
+      if (attempt.status === "committed" && attempt.completion?.completeness === "partial") {
+        partialAgents[attempt.agentName] = { ...attempt.completion };
+      }
+    }
     const status = {
       active: running != null || queued.length > 0,
       pendingAgents: queued.map((attempt) => attempt.agentName),
       completedAgents: states.filter((attempt) => attempt.status === "committed").map((attempt) => attempt.agentName),
-      failedAgents: states.filter((attempt) => attempt.status === "failed").map((attempt) => attempt.agentName)
+      failedAgents: states.filter((attempt) => attempt.status === "failed").map((attempt) => attempt.agentName),
+      ...Object.keys(partialAgents).length > 0 ? { partialAgents } : {}
     };
     if (running) {
       status.currentAgent = running.agentName;
@@ -1995,6 +2361,7 @@ var LiveSessionIndex = class {
   agentsByName = /* @__PURE__ */ new Map();
   byAgent = {};
   sessions = [];
+  cacheFailures = {};
   scanFailures = {};
   signatureCaches = /* @__PURE__ */ new Map();
   initialize(snapshot, options = {}) {
@@ -2007,6 +2374,7 @@ var LiveSessionIndex = class {
       (agent) => !options.allowedAgents || options.allowedAgents.has(agent.name.toLowerCase())
     );
     this.agentsByName = new Map(this.agents.map((agent) => [agent.name, agent]));
+    this.cacheFailures = { ...snapshot.cacheFailures };
     this.scanFailures = { ...snapshot.scanFailures };
     this.byAgent = Object.fromEntries(
       this.agents.flatMap((agent) => {
@@ -2022,6 +2390,7 @@ var LiveSessionIndex = class {
       agents: this.agents,
       byAgent: this.byAgent,
       sessions: this.sessions,
+      ...Object.keys(this.cacheFailures).length > 0 ? { cacheFailures: this.cacheFailures } : {},
       ...Object.keys(this.scanFailures).length > 0 ? { scanFailures: this.scanFailures } : {}
     };
   }
@@ -2029,6 +2398,7 @@ var LiveSessionIndex = class {
     return this.agentsByName.get(agentName);
   }
   commitAgentSessions(agentName, nextSessions, candidateChangedIds = []) {
+    delete this.cacheFailures[agentName];
     delete this.scanFailures[agentName];
     const previousSessions = this.byAgent[agentName] ?? [];
     const previousGlobalSessions = this.sessions;
@@ -2083,76 +2453,13 @@ var LiveSessionIndex = class {
   }
 };
 
-// src/latest-value-throttle.ts
-var LatestValueThrottle = class {
-  constructor(intervalMs, emit) {
-    this.intervalMs = intervalMs;
-    this.emit = emit;
-  }
-  intervalMs;
-  emit;
-  timer = null;
-  phase = null;
-  pending;
-  hasPending = false;
-  push(value, phase) {
-    if (this.phase !== phase) {
-      this.flush();
-      this.phase = phase;
-      this.emit(value);
-      this.schedule();
-      return;
-    }
-    if (this.timer) {
-      this.pending = value;
-      this.hasPending = true;
-      return;
-    }
-    this.emit(value);
-    this.schedule();
-  }
-  flush() {
-    this.clearTimer();
-    if (!this.hasPending) return;
-    const pending = this.pending;
-    this.pending = void 0;
-    this.hasPending = false;
-    this.emit(pending);
-  }
-  cancel() {
-    this.dropPending();
-    this.phase = null;
-  }
-  schedule() {
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      if (!this.hasPending) return;
-      const pending = this.pending;
-      this.pending = void 0;
-      this.hasPending = false;
-      this.emit(pending);
-      this.schedule();
-    }, this.intervalMs);
-  }
-  clearTimer() {
-    if (!this.timer) return;
-    clearTimeout(this.timer);
-    this.timer = null;
-  }
-  dropPending() {
-    this.clearTimer();
-    this.pending = void 0;
-    this.hasPending = false;
-  }
-};
-
 // src/search-index-job-runner.ts
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { Worker } from "worker_threads";
+import { Worker as Worker2 } from "worker_threads";
 
 // src/errors.ts
-function toError(value) {
+function toError2(value) {
   return value instanceof Error ? value : new Error(String(value));
 }
 
@@ -2322,7 +2629,7 @@ function changesJobFromPending(pending) {
 }
 
 // src/search-index-job-runner.ts
-var SHUTDOWN_ERROR_MESSAGE = "Live scan store shut down";
+var SHUTDOWN_ERROR_MESSAGE2 = "Live scan store shut down";
 var SearchIndexJobRunner = class {
   worker = null;
   activeBatch = null;
@@ -2338,7 +2645,7 @@ var SearchIndexJobRunner = class {
   }
   enqueueIn(queue, context, jobs, onStarted) {
     if (jobs.length === 0) return Promise.resolve();
-    if (this.isShuttingDown) return Promise.reject(new Error(SHUTDOWN_ERROR_MESSAGE));
+    if (this.isShuttingDown) return Promise.reject(new Error(SHUTDOWN_ERROR_MESSAGE2));
     const batchId = this.nextBatchId++;
     const completion = queue.enqueue(batchId, context, jobs, onStarted);
     if (this.activeBatch) {
@@ -2372,7 +2679,7 @@ var SearchIndexJobRunner = class {
     const worker = this.worker;
     this.activeBatch = null;
     this.worker = null;
-    const shutdownError = new Error(SHUTDOWN_ERROR_MESSAGE);
+    const shutdownError = new Error(SHUTDOWN_ERROR_MESSAGE2);
     if (activeBatch) this.settle(activeBatch, shutdownError);
     this.pendingJobs.rejectAll(shutdownError);
     this.pendingMaintenanceJobs.rejectAll(shutdownError);
@@ -2391,14 +2698,14 @@ var SearchIndexJobRunner = class {
       appLogger.error("search_index.worker_start_listener_failed", {
         batch_id: batch.id,
         context: batch.context,
-        error: toError(error)
+        error: toError2(error)
       });
     });
     this.startBatch(batch);
   }
   startBatch(batch) {
     if (this.isShuttingDown) {
-      this.settle(batch, new Error(SHUTDOWN_ERROR_MESSAGE));
+      this.settle(batch, new Error(SHUTDOWN_ERROR_MESSAGE2));
       return;
     }
     const request = {
@@ -2413,7 +2720,7 @@ var SearchIndexJobRunner = class {
       try {
         existingWorker.postMessage(request);
       } catch (error) {
-        this.invalidateWorker(existingWorker, toError(error));
+        this.invalidateWorker(existingWorker, toError2(error));
       }
       return;
     }
@@ -2431,9 +2738,9 @@ var SearchIndexJobRunner = class {
     });
     let worker;
     try {
-      worker = new Worker(workerUrl, { workerData: request });
+      worker = new Worker2(workerUrl, { workerData: request });
     } catch (error) {
-      this.settle(batch, toError(error));
+      this.settle(batch, toError2(error));
       this.startNextBatch();
       return;
     }
@@ -2458,15 +2765,24 @@ var SearchIndexJobRunner = class {
           agent: message.agentName,
           sessions: message.sessions
         });
-        this.finishBatch(
-          activeBatch,
-          new Error(
-            `Search index worker failed to persist ${message.stage} for ${message.agentName}`
-          )
-        );
+        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
+        });
+      }
       appLogger.info(`${message.context}.done`, {
         duration_ms: Math.round(message.durationMs),
         sessions: message.sessions
@@ -2478,7 +2794,7 @@ var SearchIndexJobRunner = class {
         context: this.activeBatch?.context ?? batch.context,
         error
       });
-      this.invalidateWorker(worker, toError(error));
+      this.invalidateWorker(worker, toError2(error));
     });
     worker.on("exit", (code) => this.finishWorker(worker, code));
   }
@@ -2588,7 +2904,7 @@ var SearchIndexMaintenanceScheduler = class {
           this.failedAgents.add(agentName);
           appLogger.error("search_index.maintenance_failed", {
             agent: agentName,
-            error: toError(error)
+            error: toError2(error)
           });
         }
       } finally {
@@ -2671,6 +2987,69 @@ var SearchIndexMaintenanceScheduler = class {
   }
 };
 
+// src/latest-value-throttle.ts
+var LatestValueThrottle = class {
+  constructor(intervalMs, emit) {
+    this.intervalMs = intervalMs;
+    this.emit = emit;
+  }
+  intervalMs;
+  emit;
+  timer = null;
+  phase = null;
+  pending;
+  hasPending = false;
+  push(value, phase) {
+    if (this.phase !== phase) {
+      this.flush();
+      this.phase = phase;
+      this.emit(value);
+      this.schedule();
+      return;
+    }
+    if (this.timer) {
+      this.pending = value;
+      this.hasPending = true;
+      return;
+    }
+    this.emit(value);
+    this.schedule();
+  }
+  flush() {
+    this.clearTimer();
+    if (!this.hasPending) return;
+    const pending = this.pending;
+    this.pending = void 0;
+    this.hasPending = false;
+    this.emit(pending);
+  }
+  cancel() {
+    this.dropPending();
+    this.phase = null;
+  }
+  schedule() {
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      if (!this.hasPending) return;
+      const pending = this.pending;
+      this.pending = void 0;
+      this.hasPending = false;
+      this.emit(pending);
+      this.schedule();
+    }, this.intervalMs);
+  }
+  clearTimer() {
+    if (!this.timer) return;
+    clearTimeout(this.timer);
+    this.timer = null;
+  }
+  dropPending() {
+    this.clearTimer();
+    this.pending = void 0;
+    this.hasPending = false;
+  }
+};
+
 // src/scan-status-model.ts
 var ScanStatusModel = class {
   status = {
@@ -2702,6 +3081,16 @@ var ScanStatusModel = class {
     } else {
       delete backfill.progress;
     }
+    if (this.status.backfill.partialAgents) {
+      backfill.partialAgents = Object.fromEntries(
+        Object.entries(this.status.backfill.partialAgents).map(([agentName, completion]) => [
+          agentName,
+          { ...completion }
+        ])
+      );
+    } else {
+      delete backfill.partialAgents;
+    }
     return {
       type: "scan-status",
       ...this.status,
@@ -2847,7 +3236,7 @@ var ScanStatusModel = class {
       updatedAt: now
     });
   }
-  finishAgent(agentName, sessionCount) {
+  finishAgent(agentName, sessionCount, completion = { completeness: "complete" }) {
     const pendingAgents = this.status.pendingAgents.filter((agent) => agent !== agentName);
     const scanningAgents = this.status.scanningAgents.filter((agent) => agent !== agentName);
     const completedAgents = [.../* @__PURE__ */ new Set([...this.status.completedAgents, agentName])];
@@ -2860,6 +3249,7 @@ var ScanStatusModel = class {
       [agentName]: {
         agentName,
         status: "complete",
+        ...completion,
         total,
         processed: total,
         sessions: sessionCount ?? previousStatus?.sessions ?? 0,
@@ -2926,6 +3316,7 @@ var ScanStatusModel = class {
           status.status === "failed" ? { ...status, completedAt: status.completedAt ?? now, updatedAt: now } : {
             ...status,
             status: "complete",
+            completeness: status.completeness ?? "complete",
             completedAt: status.completedAt ?? now,
             updatedAt: now
           }
@@ -2943,7 +3334,15 @@ var ScanStatusModel = class {
         pendingAgents: [...backfill.pendingAgents],
         completedAgents: [...backfill.completedAgents],
         failedAgents: [...backfill.failedAgents],
-        progress: backfill.progress ? { ...backfill.progress } : void 0
+        progress: backfill.progress ? { ...backfill.progress } : void 0,
+        ...backfill.partialAgents ? {
+          partialAgents: Object.fromEntries(
+            Object.entries(backfill.partialAgents).map(([agentName, completion]) => [
+              agentName,
+              { ...completion }
+            ])
+          )
+        } : {}
       },
       updatedAt: Date.now()
     });
@@ -2967,11 +3366,236 @@ var ScanStatusModel = class {
     })) {
       return "publishing";
     }
-    return this.status.phase === "initializing" ? "initializing" : "scanning";
-  }
-  set(status) {
-    this.status = status;
-    return this.snapshot();
+    return this.status.phase === "initializing" ? "initializing" : "scanning";
+  }
+  set(status) {
+    this.status = status;
+    return this.snapshot();
+  }
+};
+
+// src/scan-status-reporter.ts
+var STATUS_PROGRESS_INTERVAL_MS = 100;
+var ScanStatusReporter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  scanStatus = new ScanStatusModel();
+  listeners = /* @__PURE__ */ new Set();
+  progressThrottles = /* @__PURE__ */ new Map();
+  shuttingDown = false;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  status() {
+    return this.scanStatus.snapshot();
+  }
+  markShuttingDown() {
+    this.shuttingDown = true;
+    this.cancelProgressStatuses();
+  }
+  /** Record a failure without publishing (initialization-time bookkeeping). */
+  recordAgentFailure(agentName, message, sessionCount) {
+    this.scanStatus.failAgent(agentName, message, sessionCount);
+  }
+  failAgent(agentName, message) {
+    this.flushProgressStatus(`scan:${agentName}`);
+    this.publishStatus(this.scanStatus.failAgent(agentName, message));
+  }
+  updateSearchIndexMaintenance(status) {
+    this.publishStatus(this.scanStatus.updateSearchIndexMaintenance(status));
+  }
+  startScanBatch(agentNames, phase) {
+    const sessionCounts = Object.fromEntries(
+      agentNames.map((agentName) => [agentName, this.options.sessionCount(agentName) ?? 0])
+    );
+    this.publishStatus(this.scanStatus.startBatch(agentNames, phase, sessionCounts));
+  }
+  setScanPhase(phase) {
+    this.publishStatus(this.scanStatus.setPhase(phase));
+  }
+  beginAgentScan(agentName) {
+    this.cancelProgressStatus(`scan:${agentName}`);
+    if (!this.scanStatus.snapshot().active) this.startScanBatch([agentName], "scanning");
+    this.publishStatus(
+      this.scanStatus.beginAgent(agentName, this.options.sessionCount(agentName) ?? 0)
+    );
+  }
+  updateAgentScanProgress(agentName, progress, backfillAttempt) {
+    const backfills = this.options.backfills;
+    if (backfillAttempt) {
+      const key2 = `backfill:${agentName}`;
+      const current = backfills.stateFor(agentName);
+      if (current?.status !== "running" || current.attemptId !== backfillAttempt.attemptId) {
+        return;
+      }
+      const currentPhase2 = current.progress?.phase ?? "scanning";
+      const nextPhase2 = progress.phase ?? "scanning";
+      if (currentPhase2 && currentPhase2 !== nextPhase2) this.flushProgressStatus(key2);
+      if (backfills.updateProgress(backfillAttempt, {
+        phase: progress.phase,
+        total: progress.total,
+        processed: progress.processed,
+        sessions: progress.sessions
+      })) {
+        this.publishProgressStatus(
+          key2,
+          nextPhase2,
+          this.scanStatus.updateBackfill(backfills.status())
+        );
+      }
+      return;
+    }
+    const key = `scan:${agentName}`;
+    const currentPhase = this.scanStatus.snapshot().agentStatuses[agentName]?.status;
+    const nextPhase = progress.phase === "finalizing" ? "finalizing" : "scanning";
+    if (currentPhase && currentPhase !== nextPhase) this.flushProgressStatus(key);
+    const status = this.scanStatus.updateAgent(agentName, progress);
+    this.publishProgressStatus(key, status?.agentStatuses[agentName]?.status ?? nextPhase, status);
+  }
+  beginAgentPublishing(agentName) {
+    this.flushProgressStatus(`scan:${agentName}`);
+    this.publishStatus(this.scanStatus.publishAgent(agentName));
+  }
+  queueAgentPublication(agentName) {
+    this.flushProgressStatus(`scan:${agentName}`);
+    this.publishStatus(this.scanStatus.queueAgentPublication(agentName));
+  }
+  finishAgentScan(agentName, completion) {
+    this.flushProgressStatus(`scan:${agentName}`);
+    this.publishStatus(
+      this.scanStatus.finishAgent(agentName, this.options.sessionCount(agentName), completion)
+    );
+  }
+  finishScanBatch() {
+    this.flushProgressStatuses("scan:");
+    this.publishStatus(this.scanStatus.finishBatch());
+  }
+  publishBackfillStatus() {
+    this.publishStatus(this.scanStatus.updateBackfill(this.options.backfills.status()));
+  }
+  publishBackfillProgress(key, phase) {
+    this.publishProgressStatus(
+      key,
+      phase,
+      this.scanStatus.updateBackfill(this.options.backfills.status())
+    );
+  }
+  flushProgressStatus(key) {
+    const throttle = this.progressThrottles.get(key);
+    if (!throttle) return;
+    throttle.flush();
+    throttle.cancel();
+    this.progressThrottles.delete(key);
+  }
+  cancelProgressStatus(key) {
+    const throttle = this.progressThrottles.get(key);
+    if (!throttle) return;
+    throttle.cancel();
+    this.progressThrottles.delete(key);
+  }
+  flushProgressStatuses(prefix) {
+    for (const key of this.progressThrottles.keys()) {
+      if (key.startsWith(prefix)) this.flushProgressStatus(key);
+    }
+  }
+  cancelProgressStatuses() {
+    for (const throttle of this.progressThrottles.values()) throttle.cancel();
+    this.progressThrottles.clear();
+  }
+  publishStatus(event) {
+    if (!event || this.shuttingDown) return;
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        appLogger.error("scan.status_listener.error", { error });
+      }
+    }
+  }
+  publishProgressStatus(key, phase, event) {
+    if (!event) return;
+    let throttle = this.progressThrottles.get(key);
+    if (!throttle) {
+      throttle = new LatestValueThrottle(STATUS_PROGRESS_INTERVAL_MS, () => {
+        this.publishStatus(this.scanStatus.snapshot());
+      });
+      this.progressThrottles.set(key, throttle);
+    }
+    throttle.push(void 0, phase);
+  }
+};
+
+// src/search-index-publisher.ts
+var SearchIndexPublisher = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  nextPublicationId = 1;
+  buildFullSearchIndexJobs(context) {
+    const snapshot = this.options.snapshot();
+    return snapshot.agents.flatMap((agent) => {
+      if (!(agent.name in snapshot.byAgent)) return [];
+      const cached = this.options.readCachedSessions(agent.name);
+      return [
+        cached ? {
+          kind: "full",
+          context,
+          agentName: agent.name,
+          sessions: cached.sessions,
+          meta: cached.meta,
+          completeness: "partial",
+          removedSessionIds: [],
+          searchIndexOptions: { includePendingReindex: false }
+        } : {
+          kind: "full",
+          context,
+          agentName: agent.name,
+          sessions: snapshot.byAgent[agent.name] ?? [],
+          meta: buildAgentCacheMeta(agent),
+          completeness: "partial",
+          removedSessionIds: [],
+          searchIndexOptions: { includePendingReindex: false }
+        }
+      ];
+    });
+  }
+  publicationId(context, agentName) {
+    const id = this.nextPublicationId++;
+    return agentName ? `${context}:${agentName}:${id}` : `${context}:${id}`;
+  }
+  async commitSearchIndex(context, jobs, details) {
+    appLogger.info("session.publication.prepared", {
+      publication_id: details.publicationId,
+      context,
+      agent: details.agent,
+      agents: details.agents,
+      jobs: jobs.length
+    });
+    try {
+      const publicationJobs = jobs.map((job) => ({
+        ...job,
+        publicationId: details.publicationId
+      }));
+      await (details.onStarted ? this.options.jobs.enqueue(context, publicationJobs, details.onStarted) : this.options.jobs.enqueue(context, publicationJobs));
+    } catch (error) {
+      appLogger.error("session.publication.failed", {
+        publication_id: details.publicationId,
+        context,
+        agent: details.agent,
+        stage: "search_index",
+        error
+      });
+      throw error;
+    }
+    appLogger.info("session.publication.index_committed", {
+      publication_id: details.publicationId,
+      context,
+      agent: details.agent
+    });
   }
 };
 
@@ -2981,7 +3605,7 @@ var EMPTY_AGENT_REFRESH_DEBOUNCE_MS = 3e4;
 var SEARCH_INDEX_BULK_PENDING_PATH_THRESHOLD = 100;
 var BACKFILL_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CACHE_TRUNCATION_COVERAGE = 0.5;
-var STATUS_PROGRESS_INTERVAL_MS = 100;
+var SOURCE_FAILURE_SUMMARY_MAX_LENGTH = 160;
 function buildPersistenceDiff(previousSessions, nextSessions, candidateChangedIds = [], completeness = "complete", explicitRemovedSessionIds = []) {
   const { changes, removedSessionIds } = computeSessionDiff(
     previousSessions,
@@ -2998,9 +3622,15 @@ function buildPersistenceDiff(previousSessions, nextSessions, candidateChangedId
     removedSessionIds: removedSessionIds.filter((sessionId) => explicitRemovals.has(sessionId))
   };
 }
-function sourceFailureError(failures) {
-  const noun = failures.length === 1 ? "source" : "sources";
-  return new Error(`${failures.length} session ${noun} failed; last-known-good data retained`);
+function buildScanCompletion(completeness, sourceFailures) {
+  if (sourceFailures.length === 0) return { completeness };
+  const firstFailure = sourceFailures[0];
+  const summary = `${firstFailure.errorClass}: ${firstFailure.message}`;
+  return {
+    completeness: "partial",
+    sourceFailureCount: sourceFailures.length,
+    sourceFailureSummary: summary.length > SOURCE_FAILURE_SUMMARY_MAX_LENGTH ? `${summary.slice(0, SOURCE_FAILURE_SUMMARY_MAX_LENGTH - 1)}\u2026` : summary
+  };
 }
 function restoreAgentCacheMeta(agent, cached) {
   agent.setSessionMetaMap(new Map(Object.entries(cached.meta)));
@@ -3009,10 +3639,19 @@ var AgentSyncEngine = class {
   constructor(options) {
     this.options = options;
     this.scheduler = new AgentOperationScheduler((agentName) => this.performRefresh(agentName));
+    this.statusReporter = new ScanStatusReporter({
+      sessionCount: (agentName) => this.sessionIndex.snapshot().byAgent[agentName]?.length,
+      backfills: this.backfills
+    });
     this.searchIndexJobs = new SearchIndexJobRunner();
+    this.indexPublisher = new SearchIndexPublisher({
+      jobs: this.searchIndexJobs,
+      snapshot: () => this.sessionIndex.snapshot(),
+      readCachedSessions: (agentName) => this.readCachedSessionsOrWarn("search.index", agentName)
+    });
     this.searchIndexMaintenance = new SearchIndexMaintenanceScheduler(
       this.searchIndexJobs,
-      (status) => this.publishStatus(this.scanStatus.updateSearchIndexMaintenance(status))
+      (status) => this.statusReporter.updateSearchIndexMaintenance(status)
     );
   }
   options;
@@ -3022,12 +3661,10 @@ var AgentSyncEngine = class {
   backfills = new BackfillLifecycle();
   cacheIntegrityValidUntilByAgent = /* @__PURE__ */ new Map();
   sessionsChangedListeners = /* @__PURE__ */ new Set();
-  statusChangedListeners = /* @__PURE__ */ new Set();
-  statusProgressThrottles = /* @__PURE__ */ new Map();
-  scanStatus = new ScanStatusModel();
+  statusReporter;
+  indexPublisher;
   searchIndexJobs;
   searchIndexMaintenance;
-  nextPublicationId = 1;
   backgroundRefreshTimer = null;
   isShuttingDown = false;
   initialize(snapshot, options = {}) {
@@ -3040,7 +3677,7 @@ var AgentSyncEngine = class {
       );
     }
     for (const [agentName, failure] of Object.entries(snapshot.scanFailures ?? {})) {
-      this.scanStatus.failAgent(
+      this.statusReporter.recordAgentFailure(
         agentName,
         `${failure.stage}: ${failure.message}`,
         snapshot.byAgent[agentName]?.length ?? 0
@@ -3051,20 +3688,19 @@ var AgentSyncEngine = class {
     return this.sessionIndex.snapshot();
   }
   status() {
-    return this.scanStatus.snapshot();
+    return this.statusReporter.status();
   }
   subscribeSessionsChanged(listener) {
     this.sessionsChangedListeners.add(listener);
     return () => this.sessionsChangedListeners.delete(listener);
   }
   subscribeStatusChanged(listener) {
-    this.statusChangedListeners.add(listener);
-    return () => this.statusChangedListeners.delete(listener);
+    return this.statusReporter.subscribe(listener);
   }
   async syncInitialIndex() {
-    const jobs = this.buildFullSearchIndexJobs("scan.initial");
-    await this.commitSearchIndex("scan.initial", jobs, {
-      publicationId: this.publicationId("scan.initial"),
+    const jobs = this.indexPublisher.buildFullSearchIndexJobs("scan.initial");
+    await this.indexPublisher.commitSearchIndex("scan.initial", jobs, {
+      publicationId: this.indexPublisher.publicationId("scan.initial"),
       agents: jobs.map((job) => job.agentName)
     });
     for (const job of jobs) this.searchIndexMaintenance.enqueue(job.agentName);
@@ -3079,11 +3715,11 @@ var AgentSyncEngine = class {
   startBackgroundRefresh() {
     if (this.backgroundRefreshTimer) return;
     const agentNames = this.sessionIndex.snapshot().agents.map((agent) => agent.name);
-    this.startScanBatch(agentNames, "scanning");
+    this.statusReporter.startScanBatch(agentNames, "scanning");
     this.backgroundRefreshTimer = setTimeout(() => {
       this.backgroundRefreshTimer = null;
       for (const agentName of agentNames) this.scheduler.schedule(agentName, 0);
-      if (agentNames.length === 0) this.finishScanBatch();
+      if (agentNames.length === 0) this.statusReporter.finishScanBatch();
     }, 0);
   }
   async refresh(agentName) {
@@ -3108,7 +3744,7 @@ var AgentSyncEngine = class {
     }
     this.backfills.cancelAll();
     this.searchIndexMaintenance.stop();
-    this.cancelProgressStatuses();
+    this.statusReporter.markShuttingDown();
     this.cacheIntegrityValidUntilByAgent.clear();
     const searchIndexSnapshot = this.searchIndexJobs.snapshot();
     appLogger.info("search_index.shutdown.started", {
@@ -3125,156 +3761,95 @@ var AgentSyncEngine = class {
       pending_batches: stoppedSearchIndexSnapshot.pendingBatches
     });
   }
-  startScanBatch(agentNames, phase) {
-    const snapshot = this.sessionIndex.snapshot();
-    const sessionCounts = Object.fromEntries(
-      agentNames.map((agentName) => [agentName, snapshot.byAgent[agentName]?.length ?? 0])
-    );
-    this.publishStatus(this.scanStatus.startBatch(agentNames, phase, sessionCounts));
-  }
-  setScanPhase(phase) {
-    this.publishStatus(this.scanStatus.setPhase(phase));
-  }
-  beginAgentScan(agentName) {
-    this.cancelProgressStatus(`scan:${agentName}`);
-    const snapshot = this.sessionIndex.snapshot();
-    if (!this.scanStatus.snapshot().active) this.startScanBatch([agentName], "scanning");
-    this.publishStatus(
-      this.scanStatus.beginAgent(agentName, snapshot.byAgent[agentName]?.length ?? 0)
-    );
-  }
-  updateAgentScanProgress(agentName, progress, backfillAttempt) {
-    if (backfillAttempt) {
-      const key2 = `backfill:${agentName}`;
-      const current = this.backfills.stateFor(agentName);
-      if (current?.status !== "running" || current.attemptId !== backfillAttempt.attemptId) {
-        return;
-      }
-      const currentPhase2 = current.progress?.phase ?? "scanning";
-      const nextPhase2 = progress.phase ?? "scanning";
-      if (currentPhase2 && currentPhase2 !== nextPhase2) this.flushProgressStatus(key2);
-      if (this.backfills.updateProgress(backfillAttempt, {
-        phase: progress.phase,
-        total: progress.total,
-        processed: progress.processed,
-        sessions: progress.sessions
-      })) {
-        this.publishProgressStatus(
-          key2,
-          nextPhase2,
-          this.scanStatus.updateBackfill(this.backfills.status())
-        );
-      }
-      return;
-    }
-    const key = `scan:${agentName}`;
-    const currentPhase = this.scanStatus.snapshot().agentStatuses[agentName]?.status;
-    const nextPhase = progress.phase === "finalizing" ? "finalizing" : "scanning";
-    if (currentPhase && currentPhase !== nextPhase) this.flushProgressStatus(key);
-    const status = this.scanStatus.updateAgent(agentName, progress);
-    this.publishProgressStatus(key, status?.agentStatuses[agentName]?.status ?? nextPhase, status);
-  }
-  beginAgentPublishing(agentName) {
-    this.flushProgressStatus(`scan:${agentName}`);
-    this.publishStatus(this.scanStatus.publishAgent(agentName));
-  }
-  queueAgentPublication(agentName) {
-    this.flushProgressStatus(`scan:${agentName}`);
-    this.publishStatus(this.scanStatus.queueAgentPublication(agentName));
-  }
-  finishAgentScan(agentName) {
-    this.flushProgressStatus(`scan:${agentName}`);
-    const count = this.sessionIndex.snapshot().byAgent[agentName]?.length;
-    this.publishStatus(this.scanStatus.finishAgent(agentName, count));
-  }
-  finishScanBatch() {
-    this.flushProgressStatuses("scan:");
-    this.publishStatus(this.scanStatus.finishBatch());
-  }
-  publishBackfillStatus() {
-    this.publishStatus(this.scanStatus.updateBackfill(this.backfills.status()));
-  }
-  publishStatus(event) {
-    if (!event || this.isShuttingDown) return;
-    for (const listener of this.statusChangedListeners) {
+  emitSessionsChanged(change) {
+    if (this.isShuttingDown) return;
+    for (const listener of this.sessionsChangedListeners) {
       try {
-        listener(event);
+        listener(change);
       } catch (error) {
-        appLogger.error("scan.status_listener.error", { error });
+        this.reportPostCommitError("session.publication", change.agentName, error);
       }
     }
   }
-  publishProgressStatus(key, phase, event) {
-    if (!event) return;
-    let throttle = this.statusProgressThrottles.get(key);
-    if (!throttle) {
-      throttle = new LatestValueThrottle(STATUS_PROGRESS_INTERVAL_MS, () => {
-        this.publishStatus(this.scanStatus.snapshot());
-      });
-      this.statusProgressThrottles.set(key, throttle);
-    }
-    throttle.push(void 0, phase);
-  }
-  flushProgressStatus(key) {
-    const throttle = this.statusProgressThrottles.get(key);
-    if (!throttle) return;
-    throttle.flush();
-    throttle.cancel();
-    this.statusProgressThrottles.delete(key);
-  }
-  cancelProgressStatus(key) {
-    const throttle = this.statusProgressThrottles.get(key);
-    if (!throttle) return;
-    throttle.cancel();
-    this.statusProgressThrottles.delete(key);
+  reportPostCommitError(operation, agentName, error) {
+    appLogger.error(`${operation}.post_commit_error`, { agent: agentName, error });
   }
-  flushProgressStatuses(prefix) {
-    for (const key of this.statusProgressThrottles.keys()) {
-      if (key.startsWith(prefix)) this.flushProgressStatus(key);
+  finishCommittedAgentScan(agentName, completion) {
+    try {
+      this.statusReporter.finishAgentScan(agentName, completion);
+    } catch (error) {
+      this.reportPostCommitError("scan.refresh", agentName, error);
+      try {
+        this.statusReporter.finishAgentScan(agentName, completion);
+      } catch (recoveryError) {
+        this.reportPostCommitError("scan.refresh", agentName, recoveryError);
+      }
     }
   }
-  cancelProgressStatuses() {
-    for (const throttle of this.statusProgressThrottles.values()) throttle.cancel();
-    this.statusProgressThrottles.clear();
-  }
-  emitSessionsChanged(change) {
-    if (this.isShuttingDown) return;
-    for (const listener of this.sessionsChangedListeners) listener(change);
-  }
   async performRefresh(agentName) {
-    this.beginAgentScan(agentName);
+    this.statusReporter.beginAgentScan(agentName);
     const startedAt = performance.now();
     let failed = false;
+    let durableCommitted = false;
     let cached = null;
-    let result = null;
+    let result = "failed";
+    let completion = { completeness: "complete" };
     try {
-      if (this.findAgent(agentName)) cached = loadCachedSessions(agentName);
-      result = await this.runRefresh(agentName, cached, startedAt);
-      return result;
+      if (this.findAgent(agentName))
+        cached = this.readCachedSessionsOrWarn("scan.refresh", agentName);
+      const refresh = await this.runRefresh(agentName, cached, startedAt, (committedCompletion) => {
+        durableCommitted = true;
+        completion = committedCompletion;
+        result = "committed";
+      });
+      result = refresh.result;
+      completion = refresh.completion;
     } catch (error) {
-      this.options.workerRunner.discard?.(agentName);
-      failed = true;
-      const failure = toError(error);
-      appLogger.error("scan.refresh.error", { agent: agentName, error });
-      console.error(`[${agentName}] Session refresh failed:`, error);
-      this.flushProgressStatus(`scan:${agentName}`);
-      this.publishStatus(this.scanStatus.failAgent(agentName, failure.message));
-      return "failed";
-    } finally {
-      if (!failed) this.finishAgentScan(agentName);
+      if (durableCommitted) {
+        this.reportPostCommitError("scan.refresh", agentName, error);
+        result = "committed";
+      } else {
+        this.options.workerRunner.discard?.(agentName);
+        failed = true;
+        const failure = toError2(error);
+        if (failure instanceof AgentUnavailableDuringScanError) {
+          appLogger.warn("scan.refresh.worker_agent_unavailable", {
+            agent: agentName,
+            error: failure.message
+          });
+        } else {
+          appLogger.error("scan.refresh.error", { agent: agentName, error });
+        }
+        console.error(`[${agentName}] Session refresh failed:`, error);
+        this.statusReporter.failAgent(agentName, failure.message);
+      }
+    }
+    try {
+      if (!failed) {
+        if (durableCommitted) this.finishCommittedAgentScan(agentName, completion);
+        else this.statusReporter.finishAgentScan(agentName, completion);
+      }
+    } catch (error) {
+      if (!durableCommitted) throw error;
+      this.reportPostCommitError("scan.refresh", agentName, error);
+    }
+    try {
       const agent = this.findAgent(agentName);
       if (agent && this.needsBackfill(agent, cached, failed || result === "committed")) {
         this.enqueueBackfill(agentName);
       }
       if (agent) this.searchIndexMaintenance.enqueue(agentName);
+    } catch (error) {
+      appLogger.warn("scan.refresh.backfill_probe_failed", { agent: agentName, error });
     }
+    return result;
   }
-  async runRefresh(agentName, cached, startedAt) {
+  async runRefresh(agentName, cached, startedAt, onDurableCommit) {
     const pendingPathCount = this.scheduler.takePendingSignalCount(agentName);
     const agent = this.findAgent(agentName);
     if (!agent) {
       appLogger.warn("scan.refresh.missing_agent", { agent: agentName });
-      return "skipped";
+      return { result: "skipped", completion: { completeness: "complete" } };
     }
     const previousSessions = this.sessionIndex.snapshot().byAgent[agentName] ?? [];
     const refreshBaseline = cached?.sessions ?? previousSessions;
@@ -3288,7 +3863,7 @@ var AgentSyncEngine = class {
         agent: agentName,
         state: "initialization"
       });
-      return "unchanged";
+      return { result: "unchanged", completion: { completeness: "complete" } };
     }
     const isInitialized = initialization.value;
     const availabilityStartedAt = performance.now();
@@ -3313,7 +3888,10 @@ var AgentSyncEngine = class {
     }
     if (strategyResult.status === "unchanged") {
       this.options.workerRunner.commit?.(agentName);
-      return "unchanged";
+      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;
@@ -3355,7 +3933,12 @@ var AgentSyncEngine = class {
       saveCache: true,
       ...searchIndexOptions ? { searchIndexOptions } : {}
     };
-    this.queueAgentPublication(agentName);
+    const completion = buildScanCompletion(
+      strategyResult.completeness,
+      strategyResult.sourceFailures
+    );
+    this.statusReporter.queueAgentPublication(agentName);
+    let publicationCommitted = false;
     let publication;
     try {
       publication = await this.commitSessionPublication({
@@ -3364,12 +3947,18 @@ var AgentSyncEngine = class {
         sessions: nextSessions,
         candidateChangedIds: strategyResult.preciseChangedIds ?? [],
         indexJob: persistentJob,
-        onPublishing: () => this.beginAgentPublishing(agentName)
+        onPublishing: () => this.statusReporter.beginAgentPublishing(agentName),
+        onCommitted: () => {
+          publicationCommitted = true;
+          onDurableCommit(completion);
+        }
       });
     } catch (error) {
-      agent.setSessionMetaMap(durableMeta);
-      if (durableLastRefreshAt == null) this.lastRefreshAtByAgent.delete(agentName);
-      else this.lastRefreshAtByAgent.set(agentName, durableLastRefreshAt);
+      if (!publicationCommitted) {
+        agent.setSessionMetaMap(durableMeta);
+        if (durableLastRefreshAt == null) this.lastRefreshAtByAgent.delete(agentName);
+        else this.lastRefreshAtByAgent.set(agentName, durableLastRefreshAt);
+      }
       throw error;
     }
     this.options.workerRunner.commit?.(agentName);
@@ -3402,9 +3991,8 @@ var AgentSyncEngine = class {
         agent: agentName,
         failures: strategyResult.sourceFailures
       });
-      throw sourceFailureError(strategyResult.sourceFailures);
     }
-    return "committed";
+    return { result: "committed", completion };
   }
   /**
    * An agent that cannot be reached was never scanned, so there is nothing to
@@ -3425,7 +4013,7 @@ var AgentSyncEngine = class {
     return this.refreshStrategyResult([], "partial", {});
   }
   async initializeAgent(agent, previousSessions) {
-    this.setScanPhase("initializing");
+    this.statusReporter.setScanPhase("initializing");
     const scanStartedAt = performance.now();
     const scope = this.startupScanOptions();
     const result = await this.runWorker(agent, previousSessions, { kind: "full-scan" }, scope);
@@ -3483,12 +4071,13 @@ var AgentSyncEngine = class {
         { status: "unchanged", checkDuration }
       );
     }
-    this.lastRefreshAtByAgent.set(agent.name, checkResult.timestamp);
     if (!checkResult.hasChanges) {
       const scanStartedAt2 = performance.now();
       const result = await this.runWorker(agent, baseline, { kind: "recompute-derived" }, {});
       agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
       const sessions2 = attachMissingProjectIdentities(result.sessions);
+      agent.commitChangeCheck();
+      this.lastRefreshAtByAgent.set(agent.name, checkResult.timestamp);
       const persistenceDiff = buildPersistenceDiff(baseline, sessions2);
       if (persistenceDiff.changedSessions.length === 0 && persistenceDiff.removedSessionIds.length === 0) {
         this.logUnchangedRefresh(agent.name, refreshStartedAt);
@@ -3521,6 +4110,8 @@ var AgentSyncEngine = class {
       const result = await this.runWorker(agent, baseline, { kind: "full-scan" }, scope);
       agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
       const sessions2 = attachMissingProjectIdentities(result.sessions);
+      agent.commitChangeCheck();
+      this.lastRefreshAtByAgent.set(agent.name, checkResult.timestamp);
       return this.refreshStrategyResult(sessions2, result.completeness, scope, {
         // Meta-only changes (e.g. a pricing capture epoch bump) leave the head
         // signature intact; without the worker-reported ids they would never
@@ -3543,6 +4134,8 @@ var AgentSyncEngine = class {
         agent.incrementalScan(baseline, preciseChangedIds, checkResult.refs, scope)
       )
     );
+    agent.commitChangeCheck();
+    this.lastRefreshAtByAgent.set(agent.name, checkResult.timestamp);
     const sourceFailures = checkResult.sourceFailures ?? [];
     const completeness = scope.from == null && scope.to == null && sourceFailures.length === 0 ? "complete" : "partial";
     return this.refreshStrategyResult(sessions, completeness, scope, {
@@ -3595,19 +4188,40 @@ var AgentSyncEngine = class {
       operation,
       scanOptions,
       meta: runOptions.meta ?? buildAgentCacheMeta(agent),
-      onProgress: (progress) => this.updateAgentScanProgress(agent.name, progress, runOptions.backfillAttempt),
+      onProgress: (progress) => this.statusReporter.updateAgentScanProgress(
+        agent.name,
+        progress,
+        runOptions.backfillAttempt
+      ),
       onCheckpoint: runOptions.onCheckpoint
     });
   }
   handleBackfillCheckpoint(agentName, checkpoint) {
     if (checkpoint.stage !== "finalizing" || !checkpoint.backfillCursor) return;
-    markAgentFullSyncProgress(agentName, checkpoint.backfillCursor);
+    if (!markAgentFullSyncProgress(agentName, checkpoint.backfillCursor)) {
+      appLogger.warn("scan.backfill.checkpoint_not_durable", {
+        agent: agentName,
+        cursor: checkpoint.backfillCursor
+      });
+      return;
+    }
     appLogger.debug("scan.backfill.checkpoint", {
       agent: agentName,
       cursor: checkpoint.backfillCursor,
       sessions: checkpoint.changes.length
     });
   }
+  readCachedSessionsOrWarn(scope, agentName) {
+    const outcome = readCachedSessions(agentName);
+    if (outcome.status === "failed") {
+      appLogger.warn(`${scope}.cache_state_unavailable`, {
+        agent: agentName,
+        state: "cached_sessions"
+      });
+      return null;
+    }
+    return outcome.value;
+  }
   needsBackfill(agent, cached, reloadCached = false) {
     const startupScanOptions = this.startupScanOptions();
     if (startupScanOptions.from == null && startupScanOptions.to == null) return false;
@@ -3627,7 +4241,18 @@ var AgentSyncEngine = class {
     }
     if (!(agent instanceof FileSystemSessionSource)) return false;
     if (!agent.isAvailable()) return false;
-    const cachedSessions = reloadCached || cached === void 0 ? loadCachedSessions(agent.name) : cached;
+    let cachedSessions = cached;
+    if (reloadCached || cached === void 0) {
+      const outcome = readCachedSessions(agent.name);
+      if (outcome.status === "failed") {
+        appLogger.warn("scan.backfill.cache_state_unavailable", {
+          agent: agent.name,
+          state: "cached_sessions"
+        });
+        return false;
+      }
+      cachedSessions = outcome.value;
+    }
     const sourceCount = agent.listSessionSources().length;
     const cachedCount = cachedSessions?.sessions.length ?? 0;
     this.cacheIntegrityValidUntilByAgent.set(agent.name, lastSyncAt + BACKFILL_INTERVAL_MS);
@@ -3644,21 +4269,21 @@ var AgentSyncEngine = class {
   }
   enqueueBackfill(agentName) {
     if (this.isShuttingDown || !this.backfills.enqueue(agentName)) return;
-    this.publishBackfillStatus();
+    this.statusReporter.publishBackfillStatus();
     this.pumpBackfillQueue();
   }
   pumpBackfillQueue() {
     if (this.isShuttingDown) return;
     const attempt = this.backfills.startNext();
     if (!attempt) return;
-    this.publishBackfillStatus();
+    this.statusReporter.publishBackfillStatus();
     void this.runBackfill(attempt).then((result) => this.completeBackfillAttempt(attempt, result)).catch((error) => this.rejectBackfillAttempt(attempt, error));
   }
   completeBackfillAttempt(attempt, result) {
     if (this.isShuttingDown) return;
     const current = this.backfills.stateFor(attempt.agentName);
     if (current?.status === "running" && current.attemptId === attempt.attemptId) {
-      this.flushProgressStatus(`backfill:${attempt.agentName}`);
+      this.statusReporter.flushProgressStatus(`backfill:${attempt.agentName}`);
       if (this.backfills.complete(attempt, result)) {
         if (result === "failed") {
           this.cacheIntegrityValidUntilByAgent.delete(attempt.agentName);
@@ -3668,7 +4293,7 @@ var AgentSyncEngine = class {
             Date.now() + BACKFILL_INTERVAL_MS
           );
         }
-        this.publishBackfillStatus();
+        this.statusReporter.publishBackfillStatus();
       }
     }
     this.pumpBackfillQueue();
@@ -3686,14 +4311,19 @@ var AgentSyncEngine = class {
     const agent = this.findAgent(agentName);
     if (!agent || !agent.isAvailable()) return "skipped";
     const snapshot = this.sessionIndex.snapshot();
-    const cached = loadCachedSessions(agentName);
+    const cached = this.readCachedSessionsOrWarn("scan.backfill", agentName);
     const baseline = cached?.sessions ?? snapshot.byAgent[agentName] ?? [];
     const meta = cached?.meta ?? buildAgentCacheMeta(agent);
     const backfillCursor = getAgentFullSyncCursor(agentName);
     if (cached) restoreAgentCacheMeta(agent, cached);
     let durableCommitted = false;
     try {
-      markAgentFullSyncStarted(agentName);
+      if (!markAgentFullSyncStarted(agentName)) {
+        appLogger.warn("scan.backfill.cache_state_unavailable", {
+          agent: agentName,
+          state: "full_sync_started"
+        });
+      }
       const operation = agent instanceof FileSystemSessionSource ? { kind: "source-backfill", cursor: backfillCursor, checkpoint: "durable" } : { kind: "full-backfill", cursor: backfillCursor, checkpoint: "durable" };
       appLogger.info("scan.backfill.started", {
         agent: agentName,
@@ -3713,21 +4343,18 @@ var AgentSyncEngine = class {
       );
       agent.setSessionMetaMap(new Map(Object.entries(result.meta)));
       const fullSessions = attachMissingProjectIdentities(result.sessions);
-      this.flushProgressStatus(`backfill:${agentName}`);
+      const completion = buildScanCompletion(result.completeness, result.sourceFailures ?? []);
+      this.statusReporter.flushProgressStatus(`backfill:${agentName}`);
       const updatePublicationPhase = (phase) => {
         if (this.backfills.updateProgress(attempt, {
           phase,
           sessions: fullSessions.length
         })) {
-          this.publishProgressStatus(
-            `backfill:${agentName}`,
-            phase,
-            this.scanStatus.updateBackfill(this.backfills.status())
-          );
+          this.statusReporter.publishBackfillProgress(`backfill:${agentName}`, phase);
         }
       };
       updatePublicationPhase("publish-queued");
-      await this.commitSessionPublication({
+      const publication = await this.commitSessionPublication({
         context: "scan.backfill",
         agentName,
         sessions: fullSessions,
@@ -3742,92 +4369,54 @@ var AgentSyncEngine = class {
           removedSessionIds: result.explicitRemovedSessionIds,
           saveCache: true
         },
-        onPublishing: () => updatePublicationPhase("publishing")
+        onPublishing: () => updatePublicationPhase("publishing"),
+        onCommitted: () => {
+          durableCommitted = true;
+          if (completion.completeness === "partial") {
+            this.backfills.recordCompletion(attempt, completion);
+          }
+        }
       });
-      durableCommitted = true;
+      durableCommitted = publication.durableCommitted;
       this.options.workerRunner.commit?.(agentName);
-      if (result.sourceFailures?.length) throw sourceFailureError(result.sourceFailures);
-      markAgentFullSyncCompleted(agentName);
-      appLogger.info("scan.backfill.done", {
-        agent: agentName,
-        duration_ms: Math.round(performance.now() - startedAt),
-        sessions: fullSessions.length,
-        changed: result.changedIds?.length ?? 0
-      });
+      if (!markAgentFullSyncCompleted(agentName)) {
+        appLogger.warn("scan.backfill.completion_not_durable", { agent: agentName });
+      }
+      appLogger.info(
+        result.sourceFailures?.length ? "scan.backfill.partial" : "scan.backfill.done",
+        {
+          agent: agentName,
+          duration_ms: Math.round(performance.now() - startedAt),
+          sessions: fullSessions.length,
+          changed: result.changedIds?.length ?? 0,
+          failed_sources: result.sourceFailures?.length ?? 0
+        }
+      );
+      if (result.sourceFailures?.length) {
+        appLogger.warn("scan.backfill.source_failures", {
+          agent: agentName,
+          failures: result.sourceFailures
+        });
+      }
       return "committed";
     } catch (error) {
-      if (!durableCommitted) agent.setSessionMetaMap(new Map(Object.entries(meta)));
+      if (durableCommitted) {
+        this.reportPostCommitError("scan.backfill", agentName, error);
+        return "committed";
+      }
+      agent.setSessionMetaMap(new Map(Object.entries(meta)));
       this.options.workerRunner.discard?.(agentName);
       appLogger.error("scan.backfill.error", { agent: agentName, error });
       console.error(`[${agentName}] Backfill failed:`, error);
       return "failed";
     }
   }
-  buildFullSearchIndexJobs(context) {
-    const snapshot = this.sessionIndex.snapshot();
-    return snapshot.agents.flatMap((agent) => {
-      if (!(agent.name in snapshot.byAgent)) return [];
-      const cached = loadCachedSessions(agent.name);
-      return [
-        cached ? {
-          kind: "full",
-          context,
-          agentName: agent.name,
-          sessions: cached.sessions,
-          meta: cached.meta,
-          completeness: "partial",
-          removedSessionIds: [],
-          searchIndexOptions: { includePendingReindex: false }
-        } : {
-          kind: "full",
-          context,
-          agentName: agent.name,
-          sessions: snapshot.byAgent[agent.name] ?? [],
-          meta: buildAgentCacheMeta(agent),
-          completeness: "partial",
-          removedSessionIds: [],
-          searchIndexOptions: { includePendingReindex: false }
-        }
-      ];
-    });
-  }
-  publicationId(context, agentName) {
-    const id = this.nextPublicationId++;
-    return agentName ? `${context}:${agentName}:${id}` : `${context}:${id}`;
-  }
-  async commitSearchIndex(context, jobs, details) {
-    appLogger.info("session.publication.prepared", {
-      publication_id: details.publicationId,
-      context,
-      agent: details.agent,
-      agents: details.agents,
-      jobs: jobs.length
-    });
-    try {
-      const publicationJobs = jobs.map((job) => ({
-        ...job,
-        publicationId: details.publicationId
-      }));
-      await (details.onStarted ? this.searchIndexJobs.enqueue(context, publicationJobs, details.onStarted) : this.searchIndexJobs.enqueue(context, publicationJobs));
-    } catch (error) {
-      appLogger.error("session.publication.failed", {
-        publication_id: details.publicationId,
-        context,
-        agent: details.agent,
-        stage: "search_index",
-        error
-      });
-      throw error;
-    }
-    appLogger.info("session.publication.index_committed", {
-      publication_id: details.publicationId,
-      context,
-      agent: details.agent
-    });
-  }
   async commitSessionPublication(publication) {
-    const publicationId = this.publicationId(publication.context, publication.agentName);
-    await this.commitSearchIndex(publication.context, [publication.indexJob], {
+    const publicationId = this.indexPublisher.publicationId(
+      publication.context,
+      publication.agentName
+    );
+    await this.indexPublisher.commitSearchIndex(publication.context, [publication.indexJob], {
       publicationId,
       agent: publication.agentName,
       ...publication.onPublishing ? { onStarted: publication.onPublishing } : {}
@@ -3839,6 +4428,8 @@ var AgentSyncEngine = class {
       publication.candidateChangedIds
     );
     const diffDuration = performance.now() - diffStartedAt;
+    const result = { durableCommitted: true, event, diffDuration };
+    publication.onCommitted?.(result);
     this.emitSessionsChanged({
       agentName: publication.agentName,
       sessions: this.sessionIndex.snapshot().byAgent[publication.agentName] ?? [],
@@ -3851,7 +4442,7 @@ var AgentSyncEngine = class {
       sessions: publication.sessions.length,
       has_event: event != null
     });
-    return { event, diffDuration };
+    return result;
   }
   findAgent(agentName) {
     return this.sessionIndex.findAgent(agentName);
@@ -4158,7 +4749,11 @@ var SessionWatcher = class {
   emitAgentsChanged(agentNames) {
     if (agentNames.size === 0) return;
     for (const listener of this.listeners) {
-      listener(new Set(agentNames));
+      try {
+        listener(new Set(agentNames));
+      } catch (error) {
+        appLogger.error("watch.agents_listener.error", { error });
+      }
     }
   }
   reportWatchError(event, data) {
@@ -4168,8 +4763,8 @@ var SessionWatcher = class {
 };
 
 // src/worker-runner.ts
-import { Worker as Worker2 } from "worker_threads";
-var SHUTDOWN_ERROR_MESSAGE2 = "Scan refresh worker shut down";
+import { Worker as Worker3 } from "worker_threads";
+var SHUTDOWN_ERROR_MESSAGE3 = "Scan refresh worker shut down";
 function applySessionChanges2(previousSessions, changes, removedSessionIds) {
   if (changes.length === 0 && removedSessionIds.length === 0) return previousSessions;
   const replacedIds = new Set(removedSessionIds);
@@ -4216,7 +4811,7 @@ var ThreadWorkerRunner = class {
     return count;
   }
   run(agentName, payload) {
-    if (this.isShuttingDown) return Promise.reject(new Error(SHUTDOWN_ERROR_MESSAGE2));
+    if (this.isShuttingDown) return Promise.reject(new Error(SHUTDOWN_ERROR_MESSAGE3));
     const existingSlot = this.workers.get(agentName);
     if (existingSlot && (existingSlot.pending.size > 0 || existingSlot.awaitingCommit)) {
       return Promise.reject(new Error(`Scan refresh worker for ${agentName} is busy`));
@@ -4239,7 +4834,7 @@ var ThreadWorkerRunner = class {
         try {
           slot = this.createWorker(agentName, request);
         } catch (error) {
-          reject(toError(error));
+          reject(toError2(error));
           return;
         }
       }
@@ -4256,7 +4851,7 @@ var ThreadWorkerRunner = class {
           slot.worker.postMessage(request);
         } catch (error) {
           slot.pending.delete(request.requestId);
-          reject(toError(error));
+          reject(toError2(error));
           this.invalidateWorker(agentName, slot);
         }
       }
@@ -4287,7 +4882,7 @@ var ThreadWorkerRunner = class {
     this.isShuttingDown = true;
     const slots = [...this.workers.values()];
     this.workers.clear();
-    const shutdownError = new Error(SHUTDOWN_ERROR_MESSAGE2);
+    const shutdownError = new Error(SHUTDOWN_ERROR_MESSAGE3);
     for (const slot of slots) {
       slot.closed = true;
       for (const pending of slot.pending.values()) pending.reject(shutdownError);
@@ -4296,7 +4891,7 @@ var ThreadWorkerRunner = class {
     await Promise.allSettled(slots.map((slot) => slot.worker.terminate()));
   }
   createWorker(agentName, request) {
-    const worker = new Worker2(this.workerUrl, { workerData: request });
+    const worker = new Worker3(this.workerUrl, { workerData: request });
     const slot = {
       agentName,
       worker,
@@ -4312,7 +4907,7 @@ var ThreadWorkerRunner = class {
       this.handleMessage(slot, message);
     });
     worker.on("error", (error) => {
-      this.closeWorker(agentName, slot, toError(error));
+      this.closeWorker(agentName, slot, toError2(error));
     });
     worker.on("exit", (code) => {
       if (slot.closed) return;
@@ -4345,14 +4940,16 @@ var ThreadWorkerRunner = class {
         pending.onCheckpoint?.(message.checkpoint);
       } catch (error) {
         slot.pending.delete(message.requestId);
-        pending.reject(toError(error));
+        pending.reject(toError2(error));
         this.invalidateWorker(slot.agentName, slot);
       }
       return;
     }
     slot.pending.delete(message.requestId);
     if (message.type === "error") {
-      pending.reject(new Error(message.error));
+      pending.reject(
+        message.errorCode === AGENT_UNAVAILABLE_DURING_SCAN_ERROR_CODE ? new AgentUnavailableDuringScanError(slot.agentName) : new Error(message.error)
+      );
       this.invalidateWorker(slot.agentName, slot);
       return;
     }
@@ -4378,7 +4975,7 @@ var ThreadWorkerRunner = class {
       };
       pending.resolve(result);
     } catch (error) {
-      pending.reject(toError(error));
+      pending.reject(toError2(error));
       this.invalidateWorker(slot.agentName, slot);
     }
   }
@@ -4530,7 +5127,13 @@ var LiveScanStore = class {
     this.emitNow(event);
   }
   emitNow(event) {
-    for (const listener of this.listeners) listener(event);
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        appLogger.error("scan.sessions_listener.error", { error });
+      }
+    }
   }
   queueEvent(event) {
     this.pendingEvent = this.pendingEvent ? mergeSessionsUpdatedEvents(this.pendingEvent, event) : event;
@@ -4590,6 +5193,11 @@ function formatScanFailureDiagnostics(snapshot) {
     return `[${failure.agentName}] Scan failed during ${failure.stage}${source} (${failure.errorClass}): ${failure.message}`;
   });
 }
+function formatCacheFailureDiagnostics(snapshot) {
+  return Object.values(snapshot.cacheFailures ?? {}).map(
+    (failure) => `[${failure.agentName}] Cache persistence failed; serving in-memory results without advancing the durable baseline`
+  );
+}
 function buildSessionIndexOutput(snapshot, window = {}) {
   const sessions = filterSessionTreeByActivityWindow(snapshot.sessions, window.from, window.to);
   const agents = getAgentInfoMap(
@@ -4683,6 +5291,10 @@ function startPricingRefresh(timeoutMs = REFRESH_TIMEOUT_MS) {
 }
 
 // src/index.ts
+process.on("unhandledRejection", (reason) => {
+  appLogger.error("process.unhandled_rejection", { error: reason });
+  throw reason;
+});
 var main = defineCommand({
   meta: {
     name: "codesesh",
@@ -4808,15 +5420,19 @@ var main = defineCommand({
     }
     appLogger.info("cli.start", {
       version: VERSION,
-      argv: process.argv.slice(2),
       port,
+      host: hostname,
+      transport: transport.kind,
+      remote_access: remoteAccess,
       json: jsonOnly,
       no_open: noOpen,
       cache: useCache,
+      clear_cache: clearCache,
+      trace,
       log_path: appLogger.getLogPath()
     });
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-6QTGTYZT.js");
+      const { clearCache: clear } = await import("./dist-RHDY2EZX.js");
       clear();
       appLogger.info("cache.clear");
       console.log("Cache cleared.");
@@ -4873,6 +5489,7 @@ var main = defineCommand({
         process.exitCode = 1;
         return;
       }
+      for (const diagnostic of formatCacheFailureDiagnostics(result)) console.error(diagnostic);
       const output = buildSessionIndexOutput(result, { from: listDefaultFrom, to: listDefaultTo });
       appLogger.info("cli.json_output", {
         sessions: output.sessions.length,
@@ -4912,12 +5529,14 @@ var main = defineCommand({
       await app.shutdown();
       process.exit(0);
     };
-    process.once("SIGINT", (signal) => {
-      void shutdown(signal);
-    });
-    process.once("SIGTERM", (signal) => {
-      void shutdown(signal);
-    });
+    const shutdownOnSignal = (signal) => {
+      shutdown(signal).catch((error) => {
+        appLogger.error("cli.shutdown_failed", { signal, error });
+        process.exit(1);
+      });
+    };
+    process.once("SIGINT", shutdownOnSignal);
+    process.once("SIGTERM", shutdownOnSignal);
     console.log(`  ${url}`);
     console.log("");
     appLogger.info("cli.ready", {