@vibelet/cli 0.1.34 → 0.1.36

package/src/session-inventory.test.ts

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