@vibelet/cli 0.1.38 → 1.0.0

package/dist/session-inventory.test.js

@@ -1,712 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { __resetExternalInventoryStateForTests, __waitForExternalInventoryRefreshForTests, buildSessionInventoryPage, getExternalInventoryHealth, listSessionPage, onExternalInventoryBackfill, } from './session-inventory.js';
-import { metrics } from './metrics.js';
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve, reject };
-}
-function idleSession(overrides) {
-    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) {
-    return {
-        activeSessions: [],
-        sessionRecords: [],
-        scannedSessions: [],
-        runningSessions: [],
-        scannedAt: '2026-03-20T12:00:00.000Z',
-        deletedSessionIds: new Set(),
-        ...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();
-    const running = createDeferred();
-    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();
-    const running = createDeferred();
-    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, 'acceptEdits');
-});
-test('listSessionPage keeps search requests on the blocking path', async () => {
-    const scanned = createDeferred();
-    const contentMatches = createDeferred();
-    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');
-});
-//# sourceMappingURL=session-inventory.test.js.map