@vibelet/cli 0.1.37 → 1.0.0

package/src/session-inventory.test.ts

@@ -1,1002 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import type { SessionInfo } from '@vibelet/shared';
-import {
-  __resetExternalInventoryStateForTests,
-  __waitForExternalInventoryRefreshForTests,
-  buildSessionInventoryPage,
-  getExternalInventoryHealth,
-  listSessionPage,
-  onExternalInventoryBackfill,
-  type InventorySources,
-} from './session-inventory.js';
-import type { RunningSessionCandidate } from './process-scanner.js';
-import { metrics } from './metrics.js';
-
-function createDeferred<T>() {
-  let resolve!: (value: T | PromiseLike<T>) => void;
-  let reject!: (reason?: unknown) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-
-function idleSession(overrides: Partial<SessionInfo>): SessionInfo {
-  return {
-    sessionId: 'session-1',
-    agent: 'codex',
-    cwd: '/repo',
-    title: 'Session',
-    createdAt: '2026-03-01T00:00:00.000Z',
-    lastActivityAt: '2026-03-20T00:00:00.000Z',
-    sources: ['scanner'],
-    runtime: {
-      state: 'idle',
-      confidence: 'high',
-      resumeMode: 'resumeSession',
-    },
-    ...overrides,
-  };
-}
-
-function sources(overrides: Partial<InventorySources>): InventorySources {
-  return {
-    activeSessions: [],
-    sessionRecords: [],
-    scannedSessions: [],
-    runningSessions: [],
-    scannedAt: '2026-03-20T12:00:00.000Z',
-    deletedSessionIds: new Set<string>(),
-    ...overrides,
-  };
-}
-
-test.beforeEach(() => {
-  __resetExternalInventoryStateForTests();
-});
-
-test('returns active sessions first and paginates only idle sessions', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      activeSessions: [
-        {
-          sessionId: 'active-1',
-          agent: 'codex',
-          cwd: '/repo',
-          title: 'Active',
-          createdAt: '2026-03-20T09:00:00.000Z',
-          lastActivityAt: '2026-03-20T12:00:00.000Z',
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'idle-new',
-          title: 'Idle New',
-          lastActivityAt: '2026-03-20T11:00:00.000Z',
-        }),
-        idleSession({
-          sessionId: 'idle-old',
-          title: 'Idle Old',
-          lastActivityAt: '2026-03-19T11:00:00.000Z',
-        }),
-      ],
-    }),
-    1,
-  );
-
-  assert.equal(page.sessions.length, 2);
-  assert.equal(page.sessions[0].sessionId, 'active-1');
-  assert.equal(page.sessions[0].runtime.state, 'daemonActive');
-  assert.equal(page.sessions[1].sessionId, 'idle-new');
-  assert.deepEqual(page.nextCursor, {
-    lastActivityAt: '2026-03-20T11:00:00.000Z',
-    sessionId: 'idle-new',
-  });
-});
-
-test('listSessionPage returns fast-path records before external backfill completes', async () => {
-  const scanned = createDeferred<SessionInfo[]>();
-  const running = createDeferred<RunningSessionCandidate[]>();
-
-  const page = await listSessionPage({
-    limit: 50,
-    activeSessions: [],
-    sessionRecords: [
-      {
-        sessionId: 'record-only',
-        agent: 'codex',
-        cwd: '/repo',
-        approvalMode: 'normal',
-        title: 'Record Only',
-        createdAt: '2026-03-01T00:00:00.000Z',
-        lastActivityAt: '2026-03-20T10:00:00.000Z',
-      },
-    ],
-    loaders: {
-      listScannedSessions: async () => scanned.promise,
-      scanRunningSessions: async () => running.promise,
-    },
-  });
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 'record-only');
-  assert.equal(page.sessions[0].runtime.state, 'idle');
-  assert.deepEqual(page.sessions[0].sources, ['record']);
-  assert.equal(getExternalInventoryHealth().backfillInFlight, true);
-
-  scanned.resolve([
-    idleSession({
-      sessionId: 'external-idle',
-      title: 'External Idle',
-      lastActivityAt: '2026-03-20T11:00:00.000Z',
-    }),
-  ]);
-  running.resolve([]);
-  await __waitForExternalInventoryRefreshForTests();
-  const health = getExternalInventoryHealth();
-  const metricsSnapshot = metrics.snapshot();
-
-  assert.equal(health.backfillInFlight, false);
-  assert.equal(health.cachedSessions, 1);
-  assert.equal(health.runningSessions, 0);
-  assert.equal(typeof health.lastBackfillDurationMs, 'number');
-  assert.equal(typeof health.lastBackfillCompletedAt, 'string');
-  assert.equal(typeof health.lastBackfillAppliedAt, 'string');
-  assert.ok(metricsSnapshot.timers['session.inventory.fast_path_latency_ms']);
-  assert.ok(metricsSnapshot.timers['session.inventory.backfill_latency_ms']);
-  assert.ok(metricsSnapshot.counters['session.inventory.backfill_applied']);
-
-  const refreshed = await listSessionPage({
-    limit: 50,
-    activeSessions: [],
-    sessionRecords: [
-      {
-        sessionId: 'record-only',
-        agent: 'codex',
-        cwd: '/repo',
-        approvalMode: 'normal',
-        title: 'Record Only',
-        createdAt: '2026-03-01T00:00:00.000Z',
-        lastActivityAt: '2026-03-20T10:00:00.000Z',
-      },
-    ],
-  });
-
-  assert.deepEqual(
-    refreshed.sessions.map((session) => session.sessionId),
-    ['external-idle', 'record-only'],
-  );
-});
-
-test('listSessionPage notifies listeners when external backfill changes inventory', async () => {
-  const scanned = createDeferred<SessionInfo[]>();
-  const running = createDeferred<RunningSessionCandidate[]>();
-  let notifications = 0;
-  const unsubscribe = onExternalInventoryBackfill(() => {
-    notifications += 1;
-  });
-
-  await listSessionPage({
-    limit: 50,
-    activeSessions: [],
-    sessionRecords: [],
-    loaders: {
-      listScannedSessions: async () => scanned.promise,
-      scanRunningSessions: async () => running.promise,
-    },
-  });
-
-  scanned.resolve([
-    idleSession({
-      sessionId: 'external-idle',
-      title: 'External Idle',
-      lastActivityAt: '2026-03-20T11:00:00.000Z',
-    }),
-  ]);
-  running.resolve([]);
-  await __waitForExternalInventoryRefreshForTests();
-  unsubscribe();
-
-  assert.equal(notifications, 1);
-});
-
-test('uses max lastActivityAt across sources and keeps later pages idle-only', () => {
-  const firstPage = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'shared',
-          agent: 'codex',
-          cwd: '/repo',
-          approvalMode: 'normal',
-          title: 'Shared Record',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-02T00:00:00.000Z',
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'shared',
-          title: 'Shared Scanner',
-          lastActivityAt: '2026-03-20T10:00:00.000Z',
-        }),
-        idleSession({
-          sessionId: 'later-idle',
-          title: 'Later Idle',
-          lastActivityAt: '2026-03-19T10:00:00.000Z',
-        }),
-      ],
-      runningSessions: [
-        {
-          agent: 'claude',
-          pid: 9001,
-          cwd: '/repo',
-          command: 'claude --continue',
-          sessionId: 'claude-live',
-          confidence: 'medium',
-          isResponding: true,
-        },
-      ],
-    }),
-    1,
-  );
-
-  assert.equal(firstPage.sessions[0].sessionId, 'claude-live');
-  assert.equal(firstPage.sessions[0].runtime.state, 'externalRunning');
-  assert.equal(firstPage.sessions[0].runtime.isResponding, true);
-  assert.equal(firstPage.sessions[1].sessionId, 'shared');
-  assert.equal(firstPage.sessions[1].lastActivityAt, '2026-03-20T10:00:00.000Z');
-  assert.deepEqual(firstPage.sessions[1].sources.sort(), ['record', 'scanner']);
-
-  const secondPage = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'shared',
-          agent: 'codex',
-          cwd: '/repo',
-          approvalMode: 'normal',
-          title: 'Shared Record',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-02T00:00:00.000Z',
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'shared',
-          title: 'Shared Scanner',
-          lastActivityAt: '2026-03-20T10:00:00.000Z',
-        }),
-        idleSession({
-          sessionId: 'later-idle',
-          title: 'Later Idle',
-          lastActivityAt: '2026-03-19T10:00:00.000Z',
-        }),
-      ],
-      runningSessions: [
-        {
-          agent: 'claude',
-          pid: 9001,
-          cwd: '/repo',
-          command: 'claude --continue',
-          sessionId: 'claude-live',
-          confidence: 'medium',
-        },
-      ],
-    }),
-    1,
-    firstPage.nextCursor,
-  );
-
-  assert.equal(secondPage.sessions.length, 1);
-  assert.equal(secondPage.sessions[0].sessionId, 'later-idle');
-  assert.equal(secondPage.sessions[0].runtime.state, 'idle');
-});
-
-test('externalRunning sessions preserve parsed approval mode', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      runningSessions: [
-        {
-          agent: 'claude',
-          pid: 9001,
-          cwd: '/repo',
-          command: 'claude --continue',
-          sessionId: 'claude-live',
-          confidence: 'medium',
-          approvalMode: 'acceptEdits',
-        },
-      ],
-    }),
-    50,
-  );
-
-  assert.equal(page.sessions[0].runtime.state, 'externalRunning');
-  assert.equal(page.sessions[0].approvalMode, undefined);
-  assert.equal(page.sessions[0].observedApprovalMode, 'acceptEdits');
-});
-
-test('record approval override survives scanner and running observed modes', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'remote-shared',
-          agent: 'claude',
-          cwd: '/repo',
-          approvalMode: 'plan',
-          title: 'Remote Shared',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-02T00:00:00.000Z',
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'remote-shared',
-          agent: 'claude',
-          observedApprovalMode: 'acceptEdits',
-          title: 'Remote Shared',
-        }),
-      ],
-      runningSessions: [
-        {
-          agent: 'claude',
-          pid: 9002,
-          cwd: '/repo',
-          command: 'claude --resume remote-shared',
-          sessionId: 'remote-shared',
-          confidence: 'high',
-          approvalMode: 'autoApprove',
-        },
-      ],
-    }),
-    50,
-  );
-
-  assert.equal(page.sessions[0].approvalMode, 'plan');
-  assert.equal(page.sessions[0].observedApprovalMode, 'autoApprove');
-});
-
-test('listSessionPage keeps search requests on the blocking path', async () => {
-  const scanned = createDeferred<SessionInfo[]>();
-  const contentMatches = createDeferred<Set<string>>();
-  let resolved = false;
-
-  const pending = listSessionPage({
-    limit: 50,
-    search: 'keyword',
-    activeSessions: [],
-    sessionRecords: [],
-    loaders: {
-      listScannedSessions: async () => scanned.promise,
-      scanRunningSessions: async () => [],
-      searchSessionContent: async () => contentMatches.promise,
-    },
-  }).then((page) => {
-    resolved = true;
-    return page;
-  });
-
-  await Promise.resolve();
-  assert.equal(resolved, false);
-
-  scanned.resolve([
-    idleSession({
-      sessionId: 'matched-search',
-      title: 'No metadata match here',
-    }),
-  ]);
-  contentMatches.resolve(new Set(['matched-search']));
-  const page = await pending;
-
-  assert.equal(resolved, true);
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 'matched-search');
-});
-
-// ===== Filtering =====
-
-test('filters by agent type', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 'codex-1', agent: 'codex', title: 'Codex' }),
-        idleSession({ sessionId: 'claude-1', agent: 'claude', title: 'Claude' }),
-      ],
-    }),
-    10,
-    undefined,
-    'claude',
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].agent, 'claude');
-});
-
-test('filters by cwd', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', cwd: '/repo-a', title: 'A' }),
-        idleSession({ sessionId: 's2', cwd: '/repo-b', title: 'B' }),
-      ],
-    }),
-    10,
-    undefined,
-    undefined,
-    '/repo-b',
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].cwd, '/repo-b');
-});
-
-test('filters by search term matching title', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', title: 'Fix login bug' }),
-        idleSession({ sessionId: 's2', title: 'Add dashboard' }),
-      ],
-    }),
-    10,
-    undefined,
-    undefined,
-    undefined,
-    'login',
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 's1');
-});
-
-test('filters by search term matching cwd', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', cwd: '/home/user/frontend', title: 'A' }),
-        idleSession({ sessionId: 's2', cwd: '/home/user/backend', title: 'B' }),
-      ],
-    }),
-    10,
-    undefined,
-    undefined,
-    undefined,
-    'frontend',
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 's1');
-});
-
-test('search with contentMatchIds includes sessions matching content', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', title: 'No match' }),
-        idleSession({ sessionId: 's2', title: 'Also no match' }),
-      ],
-    }),
-    10,
-    undefined,
-    undefined,
-    undefined,
-    'special-query',
-    new Set(['s2']),
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 's2');
-});
-
-test('search disables pagination — returns all matching sessions', () => {
-  const sessions = Array.from({ length: 80 }, (_, i) =>
-    idleSession({
-      sessionId: `s${i}`,
-      title: `Session ${i} with keyword`,
-      lastActivityAt: `2026-03-${String(20 - Math.floor(i / 4)).padStart(2, '0')}T${String(i % 24).padStart(2, '0')}:00:00.000Z`,
-    }),
-  );
-  const page = buildSessionInventoryPage(
-    sources({ scannedSessions: sessions }),
-    50,
-    undefined,
-    undefined,
-    undefined,
-    'keyword',
-  );
-
-  assert.equal(page.sessions.length, 80);
-  assert.equal(page.nextCursor, undefined);
-});
-
-test('without search, pagination limits results to pageSize', () => {
-  const sessions = Array.from({ length: 80 }, (_, i) =>
-    idleSession({
-      sessionId: `s${i}`,
-      title: `Session ${i}`,
-      lastActivityAt: `2026-03-${String(20 - Math.floor(i / 4)).padStart(2, '0')}T${String(i % 24).padStart(2, '0')}:00:00.000Z`,
-    }),
-  );
-  const page = buildSessionInventoryPage(
-    sources({ scannedSessions: sessions }),
-    50,
-  );
-
-  assert.equal(page.sessions.length, 50);
-  assert.ok(page.nextCursor);
-});
-
-test('search matches title OR content — union of both', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 'title-match', title: 'Fix login bug' }),
-        idleSession({ sessionId: 'content-match', title: 'Unrelated title' }),
-        idleSession({ sessionId: 'no-match', title: 'Something else' }),
-      ],
-    }),
-    50,
-    undefined,
-    undefined,
-    undefined,
-    'login',
-    new Set(['content-match']),
-  );
-
-  assert.equal(page.sessions.length, 2);
-  const ids = page.sessions.map(s => s.sessionId).sort();
-  assert.deepEqual(ids, ['content-match', 'title-match']);
-});
-
-test('search is case insensitive for title and cwd', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', title: 'Fix Login Bug', cwd: '/home/User/Project' }),
-        idleSession({ sessionId: 's2', title: 'other', cwd: '/tmp' }),
-      ],
-    }),
-    50,
-    undefined,
-    undefined,
-    undefined,
-    'LOGIN',
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 's1');
-});
-
-test('search matches Chinese characters in title', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', title: '修复登录问题' }),
-        idleSession({ sessionId: 's2', title: '添加仪表盘功能' }),
-      ],
-    }),
-    50,
-    undefined,
-    undefined,
-    undefined,
-    '登录',
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 's1');
-});
-
-test('search with no matches returns empty page', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', title: 'Fix bug' }),
-        idleSession({ sessionId: 's2', title: 'Add feature' }),
-      ],
-    }),
-    50,
-    undefined,
-    undefined,
-    undefined,
-    'nonexistent-term',
-    new Set(),
-  );
-
-  assert.equal(page.sessions.length, 0);
-  assert.equal(page.nextCursor, undefined);
-});
-
-test('search with contentMatchIds includes sessions not matched by meta', () => {
-  const contentIds = new Set(['s1', 's3']);
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', title: 'No meta match', cwd: '/a' }),
-        idleSession({ sessionId: 's2', title: 'No meta match', cwd: '/b' }),
-        idleSession({ sessionId: 's3', title: 'No meta match', cwd: '/c' }),
-      ],
-    }),
-    50,
-    undefined,
-    undefined,
-    undefined,
-    'xyz',
-    contentIds,
-  );
-
-  assert.equal(page.sessions.length, 2);
-  const ids = page.sessions.map(s => s.sessionId).sort();
-  assert.deepEqual(ids, ['s1', 's3']);
-});
-
-test('search combined with agent filter narrows results', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', agent: 'claude', title: 'Fix login' }),
-        idleSession({ sessionId: 's2', agent: 'codex', title: 'Fix login' }),
-      ],
-    }),
-    50,
-    undefined,
-    'claude',
-    undefined,
-    'login',
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].agent, 'claude');
-});
-
-// ===== Additional coverage tests =====
-
-test('active sessions are sorted by runtime state rank then by lastActivityAt', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      runningSessions: [
-        {
-          agent: 'codex', pid: 1, cwd: '/repo', command: 'codex',
-          sessionId: 'running-1', confidence: 'medium',
-        },
-      ],
-      activeSessions: [
-        {
-          sessionId: 'daemon-1', agent: 'codex', cwd: '/repo', title: 'Daemon',
-          createdAt: '2026-03-20T09:00:00.000Z', lastActivityAt: '2026-03-20T10:00:00.000Z',
-        },
-      ],
-    }),
-    10,
-  );
-
-  // daemonActive (rank 3) should come before externalRunning (rank 2)
-  assert.equal(page.sessions[0].runtime.state, 'daemonActive');
-  assert.equal(page.sessions[1].runtime.state, 'externalRunning');
-});
-
-test('cursor that does not match any session resets to beginning', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', lastActivityAt: '2026-03-20T10:00:00.000Z' }),
-        idleSession({ sessionId: 's2', lastActivityAt: '2026-03-19T10:00:00.000Z' }),
-      ],
-    }),
-    10,
-    { lastActivityAt: 'nonexistent', sessionId: 'nonexistent' },
-  );
-
-  // Should fall back to beginning
-  assert.equal(page.sessions.length, 2);
-  assert.equal(page.sessions[0].sessionId, 's1');
-});
-
-test('idle sessions are sorted by lastActivityAt descending', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 'old', lastActivityAt: '2026-03-01T00:00:00.000Z' }),
-        idleSession({ sessionId: 'new', lastActivityAt: '2026-03-20T00:00:00.000Z' }),
-        idleSession({ sessionId: 'mid', lastActivityAt: '2026-03-10T00:00:00.000Z' }),
-      ],
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions[0].sessionId, 'new');
-  assert.equal(page.sessions[1].sessionId, 'mid');
-  assert.equal(page.sessions[2].sessionId, 'old');
-});
-
-test('runtime state: externalRunning beats idle in sort order', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 'idle-1', lastActivityAt: '2026-03-20T12:00:00.000Z' }),
-      ],
-      runningSessions: [
-        {
-          agent: 'codex', pid: 1, cwd: '/repo', command: 'codex',
-          sessionId: 'running-1', confidence: 'low',
-        },
-      ],
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions[0].sessionId, 'running-1');
-  assert.equal(page.sessions[0].runtime.state, 'externalRunning');
-  assert.equal(page.sessions[1].sessionId, 'idle-1');
-});
-
-test('deleted sessions are filtered even when scanner finds them again', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'deleted-1',
-          agent: 'codex',
-          cwd: '/repo',
-          approvalMode: 'normal',
-          title: 'Deleted record',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-02T00:00:00.000Z',
-          managed: true,
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'deleted-1',
-          title: 'Deleted scanner',
-          lastActivityAt: '2026-03-20T10:00:00.000Z',
-        }),
-        idleSession({
-          sessionId: 'kept-1',
-          title: 'Kept session',
-          lastActivityAt: '2026-03-19T10:00:00.000Z',
-        }),
-      ],
-      deletedSessionIds: new Set(['deleted-1']),
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 'kept-1');
-});
-
-test('pickRuntime chooses higher confidence when same state', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      runningSessions: [
-        {
-          agent: 'codex', pid: 1, cwd: '/repo', command: 'codex',
-          sessionId: 'shared', confidence: 'low',
-        },
-        {
-          agent: 'codex', pid: 2, cwd: '/repo', command: 'codex resume shared',
-          sessionId: 'shared', confidence: 'high',
-        },
-      ],
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].runtime.confidence, 'high');
-});
-
-// ===== Merge edge cases =====
-
-test('merges same session from record and scanner, picks higher runtime state', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'shared',
-          agent: 'codex',
-          cwd: '/repo',
-          approvalMode: 'normal',
-          title: 'Record title',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-02T00:00:00.000Z',
-        },
-      ],
-      activeSessions: [
-        {
-          sessionId: 'shared',
-          agent: 'codex',
-          cwd: '/repo',
-          title: 'Active title',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-20T12:00:00.000Z',
-        },
-      ],
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].runtime.state, 'daemonActive');
-  assert.equal(page.sessions[0].title, 'Active title');
-});
-
-test('returns empty page when no sessions match filters', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      scannedSessions: [
-        idleSession({ sessionId: 's1', agent: 'codex' }),
-      ],
-    }),
-    10,
-    undefined,
-    'claude',
-  );
-
-  assert.equal(page.sessions.length, 0);
-  assert.equal(page.nextCursor, undefined);
-});
-
-test('uses min createdAt across merged sources', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'shared',
-          agent: 'codex',
-          cwd: '/repo',
-          title: 'Title',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-10T00:00:00.000Z',
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'shared',
-          createdAt: '2026-03-05T00:00:00.000Z',
-          lastActivityAt: '2026-03-20T00:00:00.000Z',
-        }),
-      ],
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions[0].createdAt, '2026-03-01T00:00:00.000Z');
-  assert.equal(page.sessions[0].lastActivityAt, '2026-03-20T00:00:00.000Z');
-});
-
-// ===== Title merging =====
-
-test('mergeInto does not let process scanner override daemonActive lastActivityAt', () => {
-  const fiveMinsAgo = '2026-03-20T11:55:00.000Z';
-  const scannedAt = '2026-03-20T12:00:00.000Z'; // now
-
-  const page = buildSessionInventoryPage(
-    sources({
-      activeSessions: [
-        {
-          sessionId: 'shared-session',
-          agent: 'codex',
-          cwd: '/repo',
-          title: 'Daemon session',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: fiveMinsAgo,
-        },
-      ],
-      runningSessions: [
-        {
-          agent: 'codex',
-          pid: 42,
-          cwd: '/repo',
-          command: 'codex --continue',
-          sessionId: 'shared-session',
-          confidence: 'medium',
-        },
-      ],
-      scannedAt,
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].sessionId, 'shared-session');
-  // The daemon's lastActivityAt (5 mins ago) should be preserved,
-  // NOT overwritten by the process scanner's scannedAt (now).
-  assert.equal(
-    page.sessions[0].lastActivityAt,
-    fiveMinsAgo,
-    'lastActivityAt should be the daemon timestamp, not the scanner scannedAt',
-  );
-});
-
-test('managed idle sessions are sorted with active sessions, not idle', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'managed-idle',
-          agent: 'claude',
-          cwd: '/repo',
-          title: 'Managed Session',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-20T10:00:00.000Z',
-          managed: true,
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'scanned-idle',
-          title: 'Scanned Session',
-          lastActivityAt: '2026-03-20T11:00:00.000Z',
-        }),
-      ],
-    }),
-    1,
-  );
-
-  // managed idle should appear first (in active section), scanned idle in idle section
-  assert.equal(page.sessions[0].sessionId, 'managed-idle');
-  assert.equal(page.sessions[0].managed, true);
-  assert.equal(page.sessions[1].sessionId, 'scanned-idle');
-});
-
-test('managed flag is preserved when merging record and scanner sources', () => {
-  const page = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId: 'shared',
-          agent: 'codex',
-          cwd: '/repo',
-          title: 'Record',
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-02T00:00:00.000Z',
-          managed: true,
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId: 'shared',
-          title: 'Scanned',
-          lastActivityAt: '2026-03-20T10:00:00.000Z',
-        }),
-      ],
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions.length, 1);
-  assert.equal(page.sessions[0].managed, true);
-});
-
-test('replaces id-like fallback titles with a real scanned title', () => {
-  const sessionId = '019d03e3-2672-7011-9c6d-5ba083b71111';
-  const page = buildSessionInventoryPage(
-    sources({
-      sessionRecords: [
-        {
-          sessionId,
-          agent: 'codex',
-          cwd: '/repo',
-          approvalMode: 'normal',
-          title: sessionId,
-          createdAt: '2026-03-01T00:00:00.000Z',
-          lastActivityAt: '2026-03-02T00:00:00.000Z',
-        },
-      ],
-      scannedSessions: [
-        idleSession({
-          sessionId,
-          title: 'Recovered title',
-          lastActivityAt: '2026-03-20T10:00:00.000Z',
-        }),
-      ],
-    }),
-    10,
-  );
-
-  assert.equal(page.sessions[0].title, 'Recovered title');
-});