@vibelet/cli 0.1.34 → 0.1.36

package/src/session-inventory.ts

@@ -0,0 +1,721 @@
+import type {
+  AgentType,
+  SessionConfidence,
+  SessionInfo,
+  SessionListCursor,
+  SessionListPage,
+  SessionResumeMode,
+  SessionRuntimeInfo,
+  SessionRuntimeState,
+} from '@vibelet/shared';
+import { scanRunningSessions, type RunningSessionCandidate } from './process-scanner.js';
+import { listSessions as listScannedSessions, searchSessionContent } from './scanner.js';
+import { isFallbackSessionTitle } from './session-title.js';
+import type { SessionRecord } from './session-store.js';
+import { logger as rootLogger } from './logger.js';
+import { metrics } from './metrics.js';
+
+const log = rootLogger.child({ module: 'inventory' });
+const DEFAULT_INVENTORY_SOURCE_TIMEOUT_MS = 6_000;
+const EXTERNAL_INVENTORY_BACKFILL_TTL_MS = 10_000;
+
+export type { SessionRecord } from './session-store.js';
+
+export interface ActiveSessionSnapshot {
+  sessionId: string;
+  agent: AgentType;
+  cwd: string;
+  approvalMode?: import('@vibelet/shared').ApprovalMode;
+  title: string;
+  createdAt: string;
+  lastActivityAt: string;
+  needsAttention?: boolean;
+  isResponding?: boolean;
+  managed?: boolean;
+}
+
+export interface InventorySources {
+  activeSessions: ActiveSessionSnapshot[];
+  sessionRecords: SessionRecord[];
+  scannedSessions: SessionInfo[];
+  runningSessions: RunningSessionCandidate[];
+  scannedAt: string;
+  deletedSessionIds?: ReadonlySet<string>;
+}
+
+export interface ListSessionPageOptions {
+  agent?: AgentType;
+  cwd?: string;
+  search?: string;
+  limit: number;
+  cursor?: SessionListCursor;
+  activeSessions: ActiveSessionSnapshot[];
+  sessionRecords: SessionRecord[];
+  deletedSessionIds?: ReadonlySet<string>;
+  /** @internal override inventory loaders in tests */
+  loaders?: Partial<InventoryLoaders>;
+  /** @internal per-source timeout for slow inventory probes */
+  sourceTimeoutMs?: number;
+}
+
+export interface InventoryLoaders {
+  listScannedSessions: (agent?: AgentType, cwd?: string, partial?: SessionInfo[]) => Promise<SessionInfo[]>;
+  scanRunningSessions: typeof scanRunningSessions;
+  searchSessionContent: typeof searchSessionContent;
+}
+
+const defaultInventoryLoaders: InventoryLoaders = {
+  listScannedSessions,
+  scanRunningSessions,
+  searchSessionContent,
+};
+
+interface ExternalInventorySnapshot {
+  scannedSessions: SessionInfo[];
+  runningSessions: RunningSessionCandidate[];
+  scannedAt: string;
+  refreshedAt: number;
+}
+
+interface ExternalInventoryHealthSnapshot {
+  cachedSessions: number;
+  runningSessions: number;
+  cacheAgeMs?: number;
+  backfillInFlight: boolean;
+  lastBackfillDurationMs?: number;
+  lastBackfillCompletedAt?: string;
+  lastBackfillAppliedAt?: string;
+}
+
+type ExternalInventoryBackfillListener = () => void;
+
+let externalInventorySnapshot: ExternalInventorySnapshot = createEmptyExternalInventorySnapshot();
+let externalInventoryRefreshInflight: Promise<void> | null = null;
+let externalInventoryGeneration = 0;
+let externalInventoryLastBackfillCompletedAt = 0;
+let externalInventoryLastBackfillDurationMs = 0;
+let externalInventoryLastBackfillAppliedAt = 0;
+const externalInventoryBackfillListeners = new Set<ExternalInventoryBackfillListener>();
+
+function createEmptyExternalInventorySnapshot(): ExternalInventorySnapshot {
+  return {
+    scannedSessions: [],
+    runningSessions: [],
+    scannedAt: '',
+    refreshedAt: 0,
+  };
+}
+
+function serializeSessionInfo(session: SessionInfo): string {
+  return JSON.stringify({
+    sessionId: session.sessionId,
+    agent: session.agent,
+    cwd: session.cwd,
+    title: session.title,
+    createdAt: session.createdAt,
+    lastActivityAt: session.lastActivityAt,
+    sources: [...session.sources].sort(),
+    runtime: {
+      state: session.runtime.state,
+      confidence: session.runtime.confidence,
+      resumeMode: session.runtime.resumeMode,
+      pid: session.runtime.pid,
+      command: session.runtime.command,
+      isResponding: session.runtime.isResponding,
+      needsAttention: session.runtime.needsAttention,
+    },
+    managed: session.managed,
+    approvalMode: session.approvalMode,
+    observedApprovalMode: session.observedApprovalMode,
+  });
+}
+
+function serializeRunningSession(candidate: RunningSessionCandidate): string {
+  return JSON.stringify({
+    sessionId: candidate.sessionId,
+    agent: candidate.agent,
+    cwd: candidate.cwd,
+    title: candidate.title,
+    pid: candidate.pid,
+    command: candidate.command,
+    confidence: candidate.confidence,
+    isResponding: candidate.isResponding,
+    approvalMode: candidate.approvalMode,
+  });
+}
+
+function externalInventorySignature(snapshot: ExternalInventorySnapshot): string {
+  return JSON.stringify({
+    scannedSessions: snapshot.scannedSessions.map(serializeSessionInfo).sort(),
+    runningSessions: snapshot.runningSessions.map(serializeRunningSession).sort(),
+  });
+}
+
+function notifyExternalInventoryBackfillListeners(): void {
+  for (const listener of externalInventoryBackfillListeners) {
+    try {
+      listener();
+    } catch (error) {
+      log.warn({ error: String(error) }, 'session inventory backfill listener failed');
+    }
+  }
+}
+
+function updateExternalInventoryGauges(): void {
+  metrics.gauge('session.inventory.external_cached_sessions', externalInventorySnapshot.scannedSessions.length);
+  metrics.gauge('session.inventory.external_running_sessions', externalInventorySnapshot.runningSessions.length);
+  metrics.gauge('session.inventory.backfill_inflight', externalInventoryRefreshInflight ? 1 : 0);
+}
+
+export function onExternalInventoryBackfill(listener: ExternalInventoryBackfillListener): () => void {
+  externalInventoryBackfillListeners.add(listener);
+  return () => {
+    externalInventoryBackfillListeners.delete(listener);
+  };
+}
+
+export function getExternalInventoryHealth(): ExternalInventoryHealthSnapshot {
+  return {
+    cachedSessions: externalInventorySnapshot.scannedSessions.length,
+    runningSessions: externalInventorySnapshot.runningSessions.length,
+    cacheAgeMs: externalInventorySnapshot.refreshedAt
+      ? Math.max(0, Date.now() - externalInventorySnapshot.refreshedAt)
+      : undefined,
+    backfillInFlight: Boolean(externalInventoryRefreshInflight),
+    lastBackfillDurationMs: externalInventoryLastBackfillDurationMs || undefined,
+    lastBackfillCompletedAt: externalInventoryLastBackfillCompletedAt
+      ? new Date(externalInventoryLastBackfillCompletedAt).toISOString()
+      : undefined,
+    lastBackfillAppliedAt: externalInventoryLastBackfillAppliedAt
+      ? new Date(externalInventoryLastBackfillAppliedAt).toISOString()
+      : undefined,
+  };
+}
+
+updateExternalInventoryGauges();
+
+const runtimeStateRank: Record<SessionRuntimeState, number> = {
+  daemonActive: 3,
+  externalRunning: 2,
+  idle: 1,
+};
+
+const confidenceRank: Record<SessionConfidence, number> = {
+  high: 3,
+  medium: 2,
+  low: 1,
+};
+
+function compareSessions(a: SessionInfo, b: SessionInfo): number {
+  return (
+    b.lastActivityAt.localeCompare(a.lastActivityAt) ||
+    a.sessionId.localeCompare(b.sessionId)
+  );
+}
+
+function compareActiveSessions(a: SessionInfo, b: SessionInfo): number {
+  // Sessions needing attention always come first
+  const aAttention = a.runtime.needsAttention ? 1 : 0;
+  const bAttention = b.runtime.needsAttention ? 1 : 0;
+  // Responding sessions stay pinned near top so the list doesn't shift mid-reply
+  const aResponding = a.runtime.isResponding ? 1 : 0;
+  const bResponding = b.runtime.isResponding ? 1 : 0;
+  return (
+    bAttention - aAttention ||
+    bResponding - aResponding ||
+    runtimeStateRank[b.runtime.state] - runtimeStateRank[a.runtime.state] ||
+    compareSessions(a, b)
+  );
+}
+
+function pickRuntime(current: SessionRuntimeInfo, next: SessionRuntimeInfo): SessionRuntimeInfo {
+  if (runtimeStateRank[next.state] > runtimeStateRank[current.state]) return next;
+  if (runtimeStateRank[next.state] < runtimeStateRank[current.state]) return current;
+  if (confidenceRank[next.confidence] > confidenceRank[current.confidence]) return next;
+  return current;
+}
+
+function minIso(a: string, b: string): string {
+  if (!a) return b;
+  if (!b) return a;
+  return a.localeCompare(b) <= 0 ? a : b;
+}
+
+function maxIso(a: string, b: string): string {
+  if (!a) return b;
+  if (!b) return a;
+  return a.localeCompare(b) >= 0 ? a : b;
+}
+
+function shouldOverwriteTitle(current: string | undefined, next: string | undefined): boolean {
+  if (!next) return false;
+  if (!current) return true;
+  if (isFallbackSessionTitle(next) && !isFallbackSessionTitle(current)) return false;
+  return true;
+}
+
+export function createIdleRuntime(confidence: SessionConfidence = 'high', resumeMode: SessionResumeMode = 'resumeSession'): SessionRuntimeInfo {
+  return {
+    state: 'idle',
+    confidence,
+    resumeMode,
+  };
+}
+
+function toRecordSession(record: SessionRecord): SessionInfo {
+  return {
+    sessionId: record.sessionId,
+    agent: record.agent,
+    cwd: record.cwd,
+    title: record.title,
+    createdAt: record.createdAt,
+    lastActivityAt: record.lastActivityAt,
+    sources: ['record'],
+    runtime: {
+      ...createIdleRuntime(),
+      // Note: record.isResponding is intentionally NOT restored here.
+      // If a session only exists in the store (no active driver), it
+      // cannot still be responding — the daemon was restarted mid-reply.
+    },
+    managed: record.managed,
+    approvalMode: record.approvalMode,
+  };
+}
+
+function toRunningSession(candidate: RunningSessionCandidate, scannedAt: string): SessionInfo {
+  return {
+    sessionId: candidate.sessionId,
+    agent: candidate.agent,
+    cwd: candidate.cwd,
+    title: candidate.title,
+    createdAt: scannedAt,
+    lastActivityAt: scannedAt,
+    sources: ['process'],
+    runtime: {
+      state: 'externalRunning',
+      confidence: candidate.confidence,
+      resumeMode: 'resumeSession',
+      pid: candidate.pid,
+      command: candidate.command,
+      isResponding: candidate.isResponding,
+    },
+    observedApprovalMode: candidate.approvalMode,
+  };
+}
+
+function toActiveSession(session: ActiveSessionSnapshot): SessionInfo {
+  return {
+    sessionId: session.sessionId,
+    agent: session.agent,
+    cwd: session.cwd,
+    title: session.title,
+    createdAt: session.createdAt,
+    lastActivityAt: session.lastActivityAt,
+    sources: ['daemon'],
+    runtime: {
+      state: 'daemonActive',
+      confidence: 'high',
+      resumeMode: 'reuseDriver',
+      needsAttention: session.needsAttention || undefined,
+      isResponding: session.isResponding || undefined,
+    },
+    managed: session.managed,
+    approvalMode: session.approvalMode,
+  };
+}
+
+function mergeInto(merged: Map<string, SessionInfo>, sessions: SessionInfo[]): void {
+  for (const session of sessions) {
+    const key = `${session.agent}:${session.sessionId}`;
+    const current = merged.get(key);
+    if (!current) {
+      merged.set(key, {
+        ...session,
+        sources: [...session.sources],
+        runtime: { ...session.runtime },
+      });
+      continue;
+    }
+
+    const nextTitle = shouldOverwriteTitle(current.title, session.title) ? session.title : current.title;
+    const nextCwd = session.cwd || current.cwd;
+    const nextRuntime = pickRuntime(current.runtime, session.runtime);
+
+    // Deduplicate sources without Set (at most 4 elements)
+    const nextSources = current.sources.slice();
+    for (const s of session.sources) {
+      if (!nextSources.includes(s)) nextSources.push(s);
+    }
+
+    // Process-scanner uses scannedAt (current time) as lastActivityAt which is inaccurate.
+    // Only use it if we have no better timestamp.
+    const incomingIsProcessScan = session.sources.includes('process');
+    const currentIsProcessScan = current.sources.includes('process') && !current.sources.includes('daemon');
+    const nextLastActivityAt =
+      incomingIsProcessScan ? current.lastActivityAt
+      : currentIsProcessScan ? session.lastActivityAt
+      : maxIso(current.lastActivityAt, session.lastActivityAt);
+
+    merged.set(key, {
+      ...current,
+      cwd: nextCwd,
+      title: nextTitle,
+      createdAt: minIso(current.createdAt, session.createdAt),
+      lastActivityAt: nextLastActivityAt,
+      sources: nextSources,
+      runtime: nextRuntime,
+      managed: current.managed || session.managed,
+      approvalMode: session.approvalMode ?? current.approvalMode,
+      observedApprovalMode: session.observedApprovalMode ?? current.observedApprovalMode,
+    });
+  }
+}
+
+function mergeAllSessions(...lists: SessionInfo[][]): SessionInfo[] {
+  const merged = new Map<string, SessionInfo>();
+  for (const list of lists) mergeInto(merged, list);
+  return [...merged.values()];
+}
+
+function applyFilters(
+  sessions: SessionInfo[],
+  agent?: AgentType,
+  cwd?: string,
+  search?: string,
+  contentMatchIds?: Set<string>,
+): SessionInfo[] {
+  const q = search?.toLowerCase();
+  const result = sessions.filter((session) => {
+    if (agent && session.agent !== agent) return false;
+    if (cwd && session.cwd !== cwd) return false;
+    if (q) {
+      const title = (session.title ?? '').toLowerCase();
+      const sessionCwd = (session.cwd ?? '').toLowerCase();
+      const matchesMeta = title.includes(q) || sessionCwd.includes(q);
+      const matchesContent = contentMatchIds?.has(session.sessionId) ?? false;
+      if (!matchesMeta && !matchesContent) return false;
+    }
+    return true;
+  });
+  if (search) {
+    log.info({ total: sessions.length, filtered: result.length, search, contentMatchIds: contentMatchIds?.size ?? 0 }, 'filter applied');
+  }
+  return result;
+}
+
+function cursorIndex(sessions: SessionInfo[], cursor?: SessionListCursor): number {
+  if (!cursor) return 0;
+
+  // Binary search on the sorted (desc lastActivityAt, asc sessionId) array
+  let lo = 0;
+  let hi = sessions.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    const s = sessions[mid];
+    const cmp = cursor.lastActivityAt.localeCompare(s.lastActivityAt)
+      || s.sessionId.localeCompare(cursor.sessionId);
+    if (cmp > 0) hi = mid;
+    else lo = mid + 1;
+  }
+
+  // Verify exact match at lo-1
+  if (lo > 0) {
+    const prev = sessions[lo - 1];
+    if (prev.lastActivityAt === cursor.lastActivityAt && prev.sessionId === cursor.sessionId) {
+      return lo;
+    }
+  }
+  return 0;
+}
+
+export function buildSessionInventoryPage(
+  sources: InventorySources,
+  limit: number,
+  cursor?: SessionListCursor,
+  agent?: AgentType,
+  cwd?: string,
+  search?: string,
+  contentMatchIds?: Set<string>,
+): SessionListPage {
+  const pageSize = search ? Infinity : Math.max(1, limit || 50);
+  const merged = mergeAllSessions(
+    sources.sessionRecords.map(toRecordSession),
+    sources.scannedSessions,
+    sources.runningSessions.map((session) => toRunningSession(session, sources.scannedAt)),
+    sources.activeSessions.map(toActiveSession),
+  );
+
+  const visible = sources.deletedSessionIds?.size
+    ? merged.filter((session) => !sources.deletedSessionIds?.has(session.sessionId))
+    : merged;
+  const filtered = applyFilters(visible, agent, cwd, search, contentMatchIds);
+  const activeSessions = filtered
+    .filter((session) => session.runtime.state !== 'idle' || session.managed)
+    .sort(compareActiveSessions);
+  const idleSessions = filtered
+    .filter((session) => session.runtime.state === 'idle' && !session.managed)
+    .sort(compareSessions);
+
+  const idleStart = cursorIndex(idleSessions, cursor);
+  const idleSlice = idleSessions.slice(idleStart, idleStart + pageSize);
+  const hasMoreIdle = idleStart + idleSlice.length < idleSessions.length;
+  const nextCursor = hasMoreIdle && idleSlice.length > 0
+    ? {
+      lastActivityAt: idleSlice[idleSlice.length - 1].lastActivityAt,
+      sessionId: idleSlice[idleSlice.length - 1].sessionId,
+    }
+    : undefined;
+
+  return {
+    sessions: cursor ? idleSlice : [...activeSessions, ...idleSlice],
+    nextCursor,
+  };
+}
+
+function loadInventorySource<T>(
+  source: string,
+  load: () => Promise<T>,
+  fallback: T,
+  timeoutMs: number,
+  /** Shared array populated incrementally by the loader — used as partial result on timeout */
+  partial?: T,
+): Promise<T> {
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    const finish = (value: T) => {
+      if (settled) return;
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      resolve(value);
+    };
+
+    timer = setTimeout(() => {
+      if (settled) return;
+      // Use partial results if available, otherwise fall back to empty
+      const hasPartial = Array.isArray(partial) && partial.length > 0;
+      log.warn(
+        { source, timeoutMs, durationMs: Date.now() - startedAt, partial: hasPartial ? (partial as unknown[]).length : 0 },
+        hasPartial
+          ? 'session inventory source timed out, using partial results'
+          : 'session inventory source timed out, using fallback',
+      );
+      finish(hasPartial ? partial : fallback);
+    }, timeoutMs);
+    if (typeof timer === 'object' && 'unref' in timer) {
+      timer.unref();
+    }
+
+    load()
+      .then((value) => {
+        finish(value);
+      })
+      .catch((error) => {
+        if (!settled) {
+          log.warn({ source, error: String(error) }, 'session inventory source failed, using fallback');
+        }
+        finish(fallback);
+      });
+  });
+}
+
+function shouldRefreshExternalInventory(now = Date.now()): boolean {
+  return (
+    externalInventorySnapshot.refreshedAt === 0
+    || now - externalInventorySnapshot.refreshedAt >= EXTERNAL_INVENTORY_BACKFILL_TTL_MS
+  );
+}
+
+async function loadExternalInventorySnapshot(
+  loaders: InventoryLoaders,
+  timeoutMs: number,
+): Promise<ExternalInventorySnapshot> {
+  const scannedAt = new Date().toISOString();
+  const partialScanned: SessionInfo[] = [];
+  const [scannedSessions, runningSessions] = await Promise.all([
+    loadInventorySource(
+      'scanner.sessions',
+      () => loaders.listScannedSessions(undefined, undefined, partialScanned),
+      [] as SessionInfo[],
+      timeoutMs,
+      partialScanned,
+    ),
+    loadInventorySource(
+      'process.running_sessions',
+      () => loaders.scanRunningSessions(),
+      [],
+      timeoutMs,
+    ),
+  ]);
+
+  return {
+    scannedSessions,
+    runningSessions,
+    scannedAt,
+    refreshedAt: Date.now(),
+  };
+}
+
+function scheduleExternalInventoryRefresh(loaders: InventoryLoaders, timeoutMs: number): void {
+  if (externalInventoryRefreshInflight) return;
+
+  const generation = externalInventoryGeneration;
+  const endTimer = metrics.startTimer('session.inventory.backfill_latency_ms');
+  externalInventoryRefreshInflight = loadExternalInventorySnapshot(loaders, timeoutMs)
+    .then((nextSnapshot) => {
+      if (generation !== externalInventoryGeneration) return;
+
+      const previousSignature = externalInventorySignature(externalInventorySnapshot);
+      externalInventorySnapshot = nextSnapshot;
+      const nextSignature = externalInventorySignature(nextSnapshot);
+      const durationMs = endTimer();
+      externalInventoryLastBackfillDurationMs = durationMs;
+      externalInventoryLastBackfillCompletedAt = Date.now();
+      updateExternalInventoryGauges();
+      if (previousSignature === nextSignature) return;
+
+      externalInventoryLastBackfillAppliedAt = Date.now();
+      metrics.increment('session.inventory.backfill_applied');
+      log.info(
+        {
+          durationMs,
+          scanned: nextSnapshot.scannedSessions.length,
+          running: nextSnapshot.runningSessions.length,
+        },
+        'session inventory external backfill applied',
+      );
+      notifyExternalInventoryBackfillListeners();
+    })
+    .catch((error) => {
+      if (generation !== externalInventoryGeneration) return;
+      externalInventoryLastBackfillDurationMs = endTimer();
+      externalInventoryLastBackfillCompletedAt = Date.now();
+      updateExternalInventoryGauges();
+      log.warn(
+        {
+          error: String(error),
+          durationMs: externalInventoryLastBackfillDurationMs,
+        },
+        'session inventory external backfill failed',
+      );
+    })
+    .finally(() => {
+      if (generation === externalInventoryGeneration) {
+        externalInventoryRefreshInflight = null;
+        updateExternalInventoryGauges();
+      }
+    });
+  updateExternalInventoryGauges();
+}
+
+export async function __waitForExternalInventoryRefreshForTests(): Promise<void> {
+  await externalInventoryRefreshInflight;
+}
+
+export function __emitExternalInventoryBackfillForTests(): void {
+  notifyExternalInventoryBackfillListeners();
+}
+
+export function __resetExternalInventoryStateForTests(): void {
+  externalInventoryGeneration += 1;
+  externalInventorySnapshot = createEmptyExternalInventorySnapshot();
+  externalInventoryRefreshInflight = null;
+  externalInventoryLastBackfillCompletedAt = 0;
+  externalInventoryLastBackfillDurationMs = 0;
+  externalInventoryLastBackfillAppliedAt = 0;
+  externalInventoryBackfillListeners.clear();
+  updateExternalInventoryGauges();
+}
+
+export async function listSessionPage(options: ListSessionPageOptions): Promise<SessionListPage> {
+  const loaders: InventoryLoaders = {
+    ...defaultInventoryLoaders,
+    ...(options.loaders ?? {}),
+  };
+  const timeoutMs = Math.max(250, options.sourceTimeoutMs ?? DEFAULT_INVENTORY_SOURCE_TIMEOUT_MS);
+  if (!options.search) {
+    const endFastPath = metrics.startTimer('session.inventory.fast_path_latency_ms');
+    if (shouldRefreshExternalInventory()) {
+      scheduleExternalInventoryRefresh(loaders, timeoutMs);
+    }
+
+    const snapshot = externalInventorySnapshot;
+    const page = buildSessionInventoryPage(
+      {
+        activeSessions: options.activeSessions,
+        sessionRecords: options.sessionRecords,
+        scannedSessions: snapshot.scannedSessions,
+        runningSessions: snapshot.runningSessions,
+        scannedAt: snapshot.scannedAt || new Date().toISOString(),
+        deletedSessionIds: options.deletedSessionIds,
+      },
+      options.limit,
+      options.cursor,
+      options.agent,
+      options.cwd,
+    );
+    endFastPath();
+    return page;
+  }
+
+  // Shared array that the scanner populates incrementally (mtime-sorted, recent first).
+  // On timeout, loadInventorySource returns whatever has been collected so far
+  // instead of discarding all results.
+  const partialScanned: SessionInfo[] = [];
+  const scannedAt = new Date().toISOString();
+  const search = options.search;
+  const [scannedSessions, runningSessions, contentMatchIds] = await Promise.all([
+    loadInventorySource(
+      'scanner.sessions',
+      () => loaders.listScannedSessions(options.agent, options.cwd, partialScanned),
+      [] as SessionInfo[],
+      timeoutMs,
+      partialScanned,
+    ),
+    loadInventorySource(
+      'process.running_sessions',
+      () => loaders.scanRunningSessions(),
+      [],
+      timeoutMs,
+    ),
+    loadInventorySource(
+      'scanner.search_content',
+      () => loaders.searchSessionContent(search, options.agent),
+      undefined,
+      timeoutMs,
+    ),
+  ]);
+
+  log.info(
+    {
+      search: options.search,
+      contentMatches: contentMatchIds?.size ?? 0,
+      scanned: scannedSessions.length,
+      records: options.sessionRecords.length,
+      active: options.activeSessions.length,
+    },
+    'search results',
+  );
+
+  return buildSessionInventoryPage(
+    {
+      activeSessions: options.activeSessions,
+      sessionRecords: options.sessionRecords,
+      scannedSessions,
+      runningSessions,
+      scannedAt,
+      deletedSessionIds: options.deletedSessionIds,
+    },
+    options.limit,
+    options.cursor,
+    options.agent,
+    options.cwd,
+    search,
+    contentMatchIds,
+  );
+}