@vibelet/cli 0.1.37 → 1.0.0

package/src/session-inventory.ts

@@ -1,721 +0,0 @@
-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,
-  );
-}