@vibelet/cli 0.1.35 → 0.1.36

package/dist/session-inventory.test.js

@@ -0,0 +1,712 @@
+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