@omercnet/paseo-context-mode 3.1.4-next.382.1 → 3.1.4-next.434.1

package/server/analytics.ts

@@ -1,56 +1,50 @@
-import { basename } from "node:path";
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
 import type {
+  AgentAnalytics,
   AnalyticsByteAccounting,
   AnalyticsDashboard,
   AnalyticsWarning,
   IndexedSourceAnalytics,
-  ProviderAnalytics,
+  ProjectAnalytics,
+  SessionAnalytics,
 } from "../shared/analytics";
+import { CONTEXT_MODE_ANALYTICS_SCHEMA_VERSION } from "../shared/analytics";
 import {
-  CONTEXT_MODE_ANALYTICS_SCHEMA_VERSION,
-  SUPPORTED_CONTEXT_MODE_DATABASE_VERSION,
-} from "../shared/analytics";
+  CONTEXT_MODE_PROVIDERS,
+  IN_PROCESS_PROVIDERS,
+  providerForPlatform,
+} from "../shared/providers";
 import {
   ContextModeDatabaseError,
   type ContextModeDatabaseSnapshot,
+  type DatabaseSavings,
   readContextModeDatabase,
-  type SessionDatabaseSnapshot,
-} from "./context-mode-db";
-import { type ProviderConfigSource, readProviderOverrides } from "./integration";
+} from "./database";
+import { type ProviderOverrides, resolveProvider } from "./integration";
 import {
-  discoverContextModeStorageRoots,
-  listRegularContextModeDatabases,
-  type StorageDiscoveryOptions,
-  type StorageDiscoveryResult,
+  type ContextModeProjectDatabase,
+  discoverContextModeDatabases,
+  resolveContextModeDataDir,
 } from "./storage-discovery";
 
 const MAX_WARNINGS = 20;
 const MAX_SOURCES = 2_000;
-const MAX_PROVIDERS = 32;
+const MAX_AGENTS = 32;
+const MAX_PROJECTS = 50;
+const MAX_RECENT_SESSIONS = 20;
 const MAX_CATEGORIES = 128;
 const MAX_DAYS = 400;
 
-interface MutableByteAccounting {
-  eventDataBytes: number;
-  avoidedBytes: number;
-  returnedBytes: number;
-  snapshotBytes: number;
+interface MutableBytes extends DatabaseSavings {
   indexedBytes: number;
 }
 
-interface MutableAggregate {
-  databases: number;
-  events: number;
-  toolCalls: number;
+interface MutableAgent extends MutableBytes {
+  agent: string;
+  projects: number;
+  sessions: number;
   indexedSources: number;
-  indexedChunks: number;
-  sessions: Set<string>;
-  projects: Set<string>;
-  bytes: MutableByteAccounting;
-}
-
-interface MutableProviderAggregate extends MutableAggregate {
-  provider: string;
 }
 
 interface MutableSummary {
@@ -58,22 +52,16 @@ interface MutableSummary {
   savedBytes: number;
 }
 
-interface MutableSource {
-  provider: string;
-  source: string;
-  chunks: number;
-  codeChunks: number;
-  indexedBytes: number;
-  indexedAt: string | null;
-  state: "ready" | "empty" | "unavailable";
-  detail?: string;
-}
-
-export interface ContextModeAnalyticsDependencies extends StorageDiscoveryOptions {
+export interface ContextModeAnalyticsDependencies {
+  home?: string;
+  env?: NodeJS.ProcessEnv;
   now?: () => Date;
-  discoverStorage?: (options?: StorageDiscoveryOptions) => Promise<StorageDiscoveryResult>;
-  listDatabases?: typeof listRegularContextModeDatabases;
+  discover?: typeof discoverContextModeDatabases;
   readDatabase?: (path: string) => ContextModeDatabaseSnapshot;
+  /** Detected Context Mode runtime version; must resolve to null rather than reject. */
+  resolveVersion?: () => Promise<string | null>;
+  /** Paseo's configured providers; each may move its agents' data dir through its own env. */
+  providers?: ProviderOverrides;
 }
 
 class WarningCollector {
@@ -81,14 +69,13 @@ class WarningCollector {
   #omitted = 0;
 
   add(warning: AnalyticsWarning): void {
-    const normalized: AnalyticsWarning = {
-      ...warning,
-      ...(warning.provider ? { provider: warning.provider.slice(0, 128) } : {}),
-      ...(warning.database ? { database: warning.database.slice(0, 512) } : {}),
-      message: warning.message.slice(0, 512),
-    };
-    if (this.items.length < MAX_WARNINGS - 1) this.items.push(normalized);
-    else this.#omitted++;
+    if (this.items.length < MAX_WARNINGS - 1) {
+      this.items.push({
+        ...warning,
+        ...(warning.project ? { project: warning.project.slice(0, 128) } : {}),
+        message: warning.message.slice(0, 512),
+      });
+    } else this.#omitted++;
   }
 
   finish(): AnalyticsWarning[] {
@@ -106,147 +93,66 @@ class WarningCollector {
   }
 }
 
-function createAggregate(): MutableAggregate {
-  return {
-    databases: 0,
-    events: 0,
-    toolCalls: 0,
-    indexedSources: 0,
-    indexedChunks: 0,
-    sessions: new Set<string>(),
-    projects: new Set<string>(),
-    bytes: {
-      eventDataBytes: 0,
-      avoidedBytes: 0,
-      returnedBytes: 0,
-      snapshotBytes: 0,
-      indexedBytes: 0,
-    },
-  };
-}
-
 function boundedAdd(left: number, right: number): number {
   return Math.min(Number.MAX_SAFE_INTEGER, left + right);
 }
 
-function addBytes(target: MutableByteAccounting, source: Partial<MutableByteAccounting>): void {
-  target.eventDataBytes = boundedAdd(target.eventDataBytes, source.eventDataBytes ?? 0);
-  target.avoidedBytes = boundedAdd(target.avoidedBytes, source.avoidedBytes ?? 0);
-  target.returnedBytes = boundedAdd(target.returnedBytes, source.returnedBytes ?? 0);
-  target.snapshotBytes = boundedAdd(target.snapshotBytes, source.snapshotBytes ?? 0);
-  target.indexedBytes = boundedAdd(target.indexedBytes, source.indexedBytes ?? 0);
+function emptyBytes(): MutableBytes {
+  return { calls: 0, producedBytes: 0, returnedBytes: 0, savedBytes: 0, indexedBytes: 0 };
 }
 
-function savedBytes(bytes: MutableByteAccounting): number {
-  return [bytes.eventDataBytes, bytes.avoidedBytes, bytes.snapshotBytes, bytes.indexedBytes].reduce(
-    boundedAdd,
-    0,
-  );
-}
-
-function byteAccounting(bytes: MutableByteAccounting): AnalyticsByteAccounting {
-  return { ...bytes, savedBytes: savedBytes(bytes) };
-}
-
-function tokenFields(bytes: MutableByteAccounting): {
-  inputTokens: number;
-  outputTokens: number;
-  savedTokens: number;
-  savingsPercent: number;
-} {
-  const saved = savedBytes(bytes);
-  const possibleInput = boundedAdd(saved, bytes.returnedBytes);
-  return {
-    inputTokens: Math.floor(possibleInput / 4),
-    outputTokens: Math.floor(bytes.returnedBytes / 4),
-    savedTokens: Math.floor(saved / 4),
-    savingsPercent: possibleInput > 0 ? Math.round((saved / possibleInput) * 1_000) / 10 : 0,
-  };
+function addBytes(target: MutableBytes, source: MutableBytes): void {
+  target.calls = boundedAdd(target.calls, source.calls);
+  target.producedBytes = boundedAdd(target.producedBytes, source.producedBytes);
+  target.returnedBytes = boundedAdd(target.returnedBytes, source.returnedBytes);
+  target.savedBytes = boundedAdd(target.savedBytes, source.savedBytes);
+  target.indexedBytes = boundedAdd(target.indexedBytes, source.indexedBytes);
 }
 
 function incrementSummary(
   summaries: Map<string, MutableSummary>,
   key: string,
   count: number,
-  bytes: number,
+  savedBytes: number,
 ): void {
   const current = summaries.get(key) ?? { count: 0, savedBytes: 0 };
   current.count = boundedAdd(current.count, count);
-  current.savedBytes = boundedAdd(current.savedBytes, bytes);
+  current.savedBytes = boundedAdd(current.savedBytes, savedBytes);
   summaries.set(key, current);
 }
 
-function mergeSessionSnapshot(
-  target: MutableAggregate,
-  snapshot: SessionDatabaseSnapshot,
-  sessionNamespace: string,
-  categoryTotals?: Map<string, MutableSummary>,
-  dayTotals?: Map<string, MutableSummary>,
-): void {
-  target.events = boundedAdd(target.events, snapshot.events);
-  target.toolCalls = boundedAdd(target.toolCalls, snapshot.toolCalls);
-  addBytes(target.bytes, snapshot);
-  for (const session of snapshot.sessions) target.sessions.add(`${sessionNamespace}\0${session}`);
-  for (const project of snapshot.projects) target.projects.add(project);
-  if (categoryTotals) {
-    for (const category of snapshot.byCategory) {
-      incrementSummary(categoryTotals, category.category, category.count, category.savedBytes);
-    }
-  }
-  if (dayTotals) {
-    for (const day of snapshot.byDay) {
-      incrementSummary(dayTotals, day.date, day.calls, day.savedBytes);
-    }
-  }
-}
-
-function mergeSource(target: Map<string, MutableSource>, source: MutableSource): void {
-  const key = `${source.provider}\0${source.source}`;
-  const current = target.get(key);
-  if (!current) {
-    target.set(key, source);
-    return;
-  }
-  current.chunks = boundedAdd(current.chunks, source.chunks);
-  current.codeChunks = boundedAdd(current.codeChunks, source.codeChunks);
-  current.indexedBytes = boundedAdd(current.indexedBytes, source.indexedBytes);
-  if (source.indexedAt && (!current.indexedAt || source.indexedAt > current.indexedAt)) {
-    current.indexedAt = source.indexedAt;
-  }
-  if (source.state === "ready") current.state = "ready";
-  else if (source.state === "unavailable" && current.state === "empty")
-    current.state = "unavailable";
-  if (!current.detail && source.detail) current.detail = source.detail;
-}
-
-function providerOutput(aggregate: MutableProviderAggregate): ProviderAnalytics {
+/** Token estimate at 4 bytes per token; reduction is saved over produced, as `ctx_stats` reports. */
+function savingsFields(bytes: MutableBytes): {
+  savedTokens: number;
+  savingsPercent: number;
+  byteAccounting: AnalyticsByteAccounting;
+} {
+  const reduction = bytes.producedBytes > 0 ? bytes.savedBytes / bytes.producedBytes : 0;
   return {
-    provider: aggregate.provider,
-    databases: aggregate.databases,
-    projects: aggregate.projects.size,
-    sessions: aggregate.sessions.size,
-    events: aggregate.events,
-    toolCalls: aggregate.toolCalls,
-    indexedSources: aggregate.indexedSources,
-    indexedChunks: aggregate.indexedChunks,
-    ...tokenFields(aggregate.bytes),
-    byteAccounting: byteAccounting(aggregate.bytes),
+    savedTokens: Math.floor(bytes.savedBytes / 4),
+    savingsPercent: Math.min(100, Math.round(reduction * 1_000) / 10),
+    byteAccounting: {
+      producedBytes: bytes.producedBytes,
+      returnedBytes: bytes.returnedBytes,
+      savedBytes: bytes.savedBytes,
+      indexedBytes: bytes.indexedBytes,
+    },
   };
 }
 
-function databaseWarning(provider: string, path: string, error: unknown): AnalyticsWarning {
+function laterTimestamp(left: string | null, right: string | null): string | null {
+  if (!left) return right;
+  if (!right) return left;
+  return right > left ? right : left;
+}
+
+function databaseWarning(project: string, error: unknown): AnalyticsWarning {
   if (error instanceof ContextModeDatabaseError) {
-    return {
-      code: error.code,
-      provider,
-      database: error.database,
-      message: error.message,
-    };
+    return { code: error.code, project: error.project, message: error.message };
   }
   return {
     code: "database-query-failed",
-    provider,
-    database: basename(path),
+    project,
     message: "The database could not be inspected.",
   };
 }
@@ -254,118 +160,158 @@ function databaseWarning(provider: string, path: string, error: unknown): Analyt
 export async function collectContextModeAnalytics(
   dependencies: ContextModeAnalyticsDependencies = {},
 ): Promise<AnalyticsDashboard> {
-  const discoverStorage = dependencies.discoverStorage ?? discoverContextModeStorageRoots;
-  const listDatabases = dependencies.listDatabases ?? listRegularContextModeDatabases;
+  const discover = dependencies.discover ?? discoverContextModeDatabases;
   const readDatabase = dependencies.readDatabase ?? readContextModeDatabase;
-  const warningCollector = new WarningCollector();
-  const discovery = await discoverStorage({
-    home: dependencies.home,
-    env: dependencies.env,
-    providers: dependencies.providers,
-  });
-  for (const warning of discovery.warnings) warningCollector.add(warning);
+  const env = dependencies.env ?? process.env;
+  const home = dependencies.home ?? homedir();
+  const providers = dependencies.providers ?? {};
+  const dataDirOf = (id: string) =>
+    resolveContextModeDataDir({ ...env, ...resolveProvider(id, providers).env }, home);
+  // Symlinked aliases of one directory must not count its databases twice.
+  const canonical = (dir: string) => realpath(dir).catch(() => dir);
+  // A configured provider's own CONTEXT_MODE_DATA_DIR is where its injected agents write.
+  const dataDirs = new Set(
+    await Promise.all(
+      [resolveContextModeDataDir(env, home), ...Object.keys(providers).map(dataDirOf)].map(
+        canonical,
+      ),
+    ),
+  );
+  // Resume and Forget run through a provider, so each row names one that reaches its store,
+  // preferring the provider that recorded it.
+  const actionable = [
+    ...CONTEXT_MODE_PROVIDERS.map((entry) => entry.provider),
+    ...IN_PROCESS_PROVIDERS.map((entry) => entry.provider),
+    ...Object.keys(providers).filter((id) => {
+      const { base, platform } = resolveProvider(id, providers);
+      return platform !== null || IN_PROCESS_PROVIDERS.some((entry) => entry.provider === base);
+    }),
+  ];
+  const storeOf = new Map(
+    await Promise.all(actionable.map(async (id) => [id, await canonical(dataDirOf(id))] as const)),
+  );
+  const storeProvider = (agent: string, dataDir: string): string | null => {
+    const own = providerForPlatform(agent)?.provider;
+    const candidates = own ? [own, ...actionable] : actionable;
+    return candidates.find((id) => storeOf.get(id) === dataDir) ?? null;
+  };
+  const warnings = new WarningCollector();
+  const databases: (ContextModeProjectDatabase & { dataDir: string })[] = [];
+  for (const dataDir of dataDirs) {
+    const discovery = await discover(dataDir);
+    databases.push(...discovery.databases.map((database) => ({ ...database, dataDir })));
+    for (const warning of discovery.warnings) warnings.add(warning);
+  }
 
-  const total = createAggregate();
-  const providers: MutableProviderAggregate[] = [];
+  const total = emptyBytes();
+  let sessions = 0;
+  let events = 0;
+  let indexedSources = 0;
+  let indexedChunks = 0;
+  let lastActivityAt: string | null = null;
+  const agents = new Map<string, MutableAgent>();
+  const projects: ProjectAnalytics[] = [];
   const categories = new Map<string, MutableSummary>();
   const days = new Map<string, MutableSummary>();
-  const sourceMap = new Map<string, MutableSource>();
-  let attemptedDatabases = 0;
-  let successfulDatabases = 0;
-
-  for (const root of discovery.roots) {
-    const provider: MutableProviderAggregate = { provider: root.provider, ...createAggregate() };
-    providers.push(provider);
-
-    for (const [directoryKind, directory] of [
-      ["session", root.sessionsDir],
-      ["content", root.contentDir],
-    ] as const) {
-      const listing = await listDatabases(root.provider, directory);
-      for (const warning of listing.warnings) warningCollector.add(warning);
-
-      for (const path of listing.files) {
-        attemptedDatabases++;
-        try {
-          const snapshot = readDatabase(path);
-          successfulDatabases++;
-          total.databases = boundedAdd(total.databases, 1);
-          provider.databases = boundedAdd(provider.databases, 1);
-
-          if (snapshot.kind === "session") {
-            mergeSessionSnapshot(total, snapshot, root.provider, categories, days);
-            mergeSessionSnapshot(provider, snapshot, root.provider);
-            continue;
-          }
-
-          total.indexedSources = boundedAdd(total.indexedSources, snapshot.sources.length);
-          total.indexedChunks = boundedAdd(total.indexedChunks, snapshot.chunks);
-          provider.indexedSources = boundedAdd(provider.indexedSources, snapshot.sources.length);
-          provider.indexedChunks = boundedAdd(provider.indexedChunks, snapshot.chunks);
-          addBytes(total.bytes, { indexedBytes: snapshot.indexedBytes });
-          addBytes(provider.bytes, { indexedBytes: snapshot.indexedBytes });
-          for (const day of snapshot.byDay) {
-            incrementSummary(days, day.date, day.calls, day.savedBytes);
-          }
-          for (const source of snapshot.sources) {
-            mergeSource(sourceMap, {
-              provider: root.provider,
-              source: source.source,
-              chunks: source.chunks,
-              codeChunks: source.codeChunks,
-              indexedBytes: source.indexedBytes,
-              indexedAt: source.indexedAt,
-              state: source.chunks > 0 ? "ready" : "empty",
-              ...(source.detail ? { detail: source.detail } : {}),
-            });
-          }
-          for (const message of snapshot.inconsistencies) {
-            warningCollector.add({
-              code: "inconsistent-index",
-              provider: root.provider,
-              database: basename(path),
-              message,
-            });
-          }
-        } catch (error) {
-          const warning = databaseWarning(root.provider, path, error);
-          warningCollector.add(warning);
-          if (directoryKind === "content") {
-            mergeSource(sourceMap, {
-              provider: root.provider,
-              source: `[database] ${basename(path)}`,
-              chunks: 0,
-              codeChunks: 0,
-              indexedBytes: 0,
-              indexedAt: null,
-              state: "unavailable",
-              detail: warning.message,
-            });
-          }
-        }
+  const sources: IndexedSourceAnalytics[] = [];
+  const recentSessions: SessionAnalytics[] = [];
+  let unsupportedSchema = false;
+
+  for (const database of databases) {
+    let snapshot: ContextModeDatabaseSnapshot;
+    try {
+      snapshot = readDatabase(database.path);
+    } catch (error) {
+      if (error instanceof ContextModeDatabaseError && error.code === "unsupported-schema") {
+        unsupportedSchema = true;
       }
+      warnings.add(databaseWarning(database.project, error));
+      continue;
     }
-  }
 
-  const allSources = [...sourceMap.values()].sort(
-    (left, right) =>
-      left.provider.localeCompare(right.provider) || left.source.localeCompare(right.source),
-  );
-  if (allSources.length > MAX_SOURCES) {
-    warningCollector.add({
-      code: "result-truncated",
-      message: `Only the first ${MAX_SOURCES} indexed sources are included in the dashboard.`,
+    addBytes(total, snapshot);
+    sessions = boundedAdd(sessions, snapshot.sessions);
+    events = boundedAdd(events, snapshot.events);
+    indexedSources = boundedAdd(indexedSources, snapshot.indexedSources);
+    indexedChunks = boundedAdd(indexedChunks, snapshot.indexedChunks);
+    lastActivityAt = laterTimestamp(lastActivityAt, snapshot.lastActivityAt);
+    projects.push({
+      path: snapshot.worktrees[0] ?? database.project,
+      worktrees: snapshot.worktrees.length,
+      sessions: snapshot.sessions,
+      toolCalls: snapshot.calls,
+      indexedSources: snapshot.indexedSources,
+      ...savingsFields(snapshot),
+      lastActivityAt: snapshot.lastActivityAt,
     });
+
+    for (const summary of snapshot.byAgent) {
+      const agent = agents.get(summary.agent) ?? {
+        agent: summary.agent,
+        projects: 0,
+        sessions: 0,
+        indexedSources: 0,
+        ...emptyBytes(),
+      };
+      agent.projects = boundedAdd(agent.projects, 1);
+      agent.sessions = boundedAdd(agent.sessions, summary.sessions);
+      agent.indexedSources = boundedAdd(agent.indexedSources, summary.indexedSources);
+      addBytes(agent, summary);
+      agents.set(summary.agent, agent);
+    }
+    for (const tool of snapshot.byTool) {
+      incrementSummary(categories, tool.tool, tool.calls, tool.savedBytes);
+    }
+    for (const day of snapshot.byDay) incrementSummary(days, day.date, day.calls, day.savedBytes);
+    for (const source of snapshot.sources) {
+      sources.push({
+        agent: source.agent,
+        projectPath: source.projectPath,
+        source: source.label,
+        kind: source.kind,
+        chunks: source.chunks,
+        indexedBytes: source.bytes,
+        indexedAt: source.createdAt,
+        provider: storeProvider(source.agent, database.dataDir),
+      });
+    }
+    recentSessions.push(
+      ...snapshot.sessionList.map((session) => ({
+        ...session,
+        provider: storeProvider(session.agent, database.dataDir),
+      })),
+    );
+    for (const message of snapshot.truncated) {
+      warnings.add({ code: "result-truncated", project: database.project, message });
+    }
   }
-  const sources: IndexedSourceAnalytics[] = allSources.slice(0, MAX_SOURCES);
-  const allProviders = providers.map(providerOutput);
+
+  const allAgents = [...agents.values()]
+    .sort(
+      (left, right) => right.savedBytes - left.savedBytes || left.agent.localeCompare(right.agent),
+    )
+    .map(
+      (agent): AgentAnalytics => ({
+        agent: agent.agent,
+        projects: agent.projects,
+        sessions: agent.sessions,
+        toolCalls: agent.calls,
+        indexedSources: agent.indexedSources,
+        ...savingsFields(agent),
+      }),
+    );
   const allCategories = [...categories]
     .map(([category, summary]) => ({
       category,
       count: summary.count,
       savedTokens: Math.floor(summary.savedBytes / 4),
     }))
-    .sort((left, right) => right.count - left.count || left.category.localeCompare(right.category));
+    .sort(
+      (left, right) =>
+        right.savedTokens - left.savedTokens ||
+        right.count - left.count ||
+        left.category.localeCompare(right.category),
+    );
   const allDays = [...days]
     .map(([date, summary]) => ({
       date,
@@ -373,64 +319,67 @@ export async function collectContextModeAnalytics(
       savedTokens: Math.floor(summary.savedBytes / 4),
     }))
     .sort((left, right) => left.date.localeCompare(right.date));
+  sources.sort(
+    (left, right) =>
+      (right.indexedAt ?? "").localeCompare(left.indexedAt ?? "") ||
+      left.source.localeCompare(right.source),
+  );
+  recentSessions.sort(
+    (left, right) =>
+      (right.lastActivityAt ?? "").localeCompare(left.lastActivityAt ?? "") ||
+      left.sessionId.localeCompare(right.sessionId),
+  );
+  projects.sort(
+    (left, right) =>
+      right.byteAccounting.savedBytes - left.byteAccounting.savedBytes ||
+      left.path.localeCompare(right.path),
+  );
   for (const [count, maximum, label] of [
-    [allProviders.length, MAX_PROVIDERS, "provider"],
-    [allCategories.length, MAX_CATEGORIES, "category"],
+    [allAgents.length, MAX_AGENTS, "agent"],
+    [allCategories.length, MAX_CATEGORIES, "tool"],
     [allDays.length, MAX_DAYS, "daily"],
+    [sources.length, MAX_SOURCES, "indexed source"],
+    [projects.length, MAX_PROJECTS, "project"],
   ] as const) {
     if (count > maximum) {
-      warningCollector.add({
+      warnings.add({
         code: "result-truncated",
         message: `Only the first ${maximum} ${label} analytics rows are included.`,
       });
     }
   }
-  const byProvider = allProviders.slice(0, MAX_PROVIDERS);
-  const byCategory = allCategories.slice(0, MAX_CATEGORIES);
-  const byDay = allDays.slice(-MAX_DAYS);
-  const hadWarnings = warningCollector.hasWarnings;
-  const completeness =
-    attemptedDatabases > 0 && successfulDatabases === 0
-      ? "unsupported"
-      : hadWarnings
-        ? "partial"
-        : "complete";
-  const warnings = warningCollector.finish();
+
+  // A locked or unopenable store is a transient gap; only a schema mismatch warrants "update Context Mode".
+  const unsupported = projects.length === 0 && unsupportedSchema;
+  const coverage = warnings.hasWarnings ? "partial" : "complete";
+  const contextModeVersion = dependencies.resolveVersion
+    ? await dependencies.resolveVersion()
+    : null;
 
   return {
     schemaVersion: CONTEXT_MODE_ANALYTICS_SCHEMA_VERSION,
-    contextModeVersion: SUPPORTED_CONTEXT_MODE_DATABASE_VERSION,
-    completeness,
-    warnings,
+    contextModeVersion,
+    completeness: unsupported ? "unsupported" : coverage,
+    warnings: warnings.finish(),
     totals: {
-      providers: providers.length,
-      databases: total.databases,
-      projects: total.projects.size,
-      sessions: total.sessions.size,
-      events: total.events,
-      toolCalls: total.toolCalls,
-      indexedSources: total.indexedSources,
-      indexedChunks: total.indexedChunks,
-      ...tokenFields(total.bytes),
-      byteAccounting: byteAccounting(total.bytes),
+      agents: agents.size,
+      projects: projects.length,
+      sessions,
+      events,
+      toolCalls: total.calls,
+      indexedSources,
+      indexedChunks,
+      inputTokens: Math.floor(total.producedBytes / 4),
+      outputTokens: Math.floor(total.returnedBytes / 4),
+      ...savingsFields(total),
+      lastActivityAt,
     },
-    byProvider,
-    byCategory,
-    byDay,
-    sources,
+    byAgent: allAgents.slice(0, MAX_AGENTS),
+    byProject: projects.slice(0, MAX_PROJECTS),
+    recentSessions: recentSessions.slice(0, MAX_RECENT_SESSIONS),
+    byCategory: allCategories.slice(0, MAX_CATEGORIES),
+    byDay: allDays.slice(-MAX_DAYS),
+    sources: sources.slice(0, MAX_SOURCES),
     generatedAt: (dependencies.now ?? (() => new Date()))().toISOString(),
   };
 }
-
-export function createContextModeAnalyticsHandler(
-  dependencies: ContextModeAnalyticsDependencies = {},
-): (
-  _input: Record<string, never>,
-  context?: { paseo?: ProviderConfigSource },
-) => Promise<AnalyticsDashboard> {
-  return async (_input, context) =>
-    collectContextModeAnalytics({
-      ...dependencies,
-      providers: dependencies.providers ?? (await readProviderOverrides(context?.paseo)),
-    });
-}