codexmate 0.0.9 → 0.0.12

package/tests/e2e/test-session-search.js

@@ -1,114 +0,0 @@
-const http = require('http');
-const { assert } = require('./helpers');
-
-async function fetchHtml(port) {
-    return new Promise((resolve, reject) => {
-        const req = http.get({
-            hostname: '127.0.0.1',
-            port,
-            path: '/',
-            timeout: 2000
-        }, (res) => {
-            let body = '';
-            res.setEncoding('utf-8');
-            res.on('data', chunk => body += chunk);
-            res.on('end', () => resolve(body));
-        });
-        req.on('error', reject);
-        req.on('timeout', () => {
-            req.destroy(new Error('timeout'));
-        });
-    });
-}
-
-module.exports = async function testSessionSearch(ctx) {
-    const { api, sessionId, claudeSessionId, daudeSessionId } = ctx;
-
-    const claudeSearch = await api('list-sessions', { source: 'claude', query: 'claudecode', limit: 20, forceRefresh: true });
-    assert(Array.isArray(claudeSearch.sessions), 'claudecode query missing sessions');
-    const claudeHit = claudeSearch.sessions.find(item => item.sessionId === claudeSessionId);
-    assert(claudeHit, 'claudecode query missing Claude session');
-    assert(claudeHit.provider === 'claude', 'Claude session provider missing');
-    assert(claudeHit.capabilities && claudeHit.capabilities.code === true, 'Claude session code capability missing');
-    assert(Array.isArray(claudeHit.keywords) && claudeHit.keywords.includes('claude_code'), 'Claude session keyword missing');
-
-    const variantSearch = await api('list-sessions', { source: 'claude', query: 'claude-code', limit: 20, forceRefresh: true });
-    assert(variantSearch.sessions.some(item => item.sessionId === claudeSessionId), 'claude-code query missing Claude session');
-
-    const combined = await api('list-sessions', { source: 'claude', query: 'claude code hello', limit: 20, forceRefresh: true });
-    const combinedIds = combined.sessions.map(item => item.sessionId);
-    assert(combinedIds.includes(claudeSessionId), 'combined query missing Claude session');
-
-    const baseline = await api('list-sessions', { source: 'codex', query: 'hello', limit: 20, forceRefresh: true });
-    assert(baseline.sessions.some(item => item.sessionId === sessionId), 'baseline query missing codex session');
-
-    const daudeSearch = await api('list-sessions', {
-        source: 'codex',
-        query: 'daude code',
-        limit: 20,
-        forceRefresh: true
-    });
-    assert(daudeSearch.sessions.some(item => item.sessionId === daudeSessionId), 'daude code query missing session');
-
-    const daudeHyphen = await api('list-sessions', {
-        source: 'codex',
-        query: 'daude-code',
-        limit: 20,
-        forceRefresh: true
-    });
-    assert(daudeHyphen.sessions.some(item => item.sessionId === daudeSessionId), 'daude-code query missing session');
-
-    const daudeConcat = await api('list-sessions', {
-        source: 'codex',
-        query: 'daudecode',
-        limit: 20,
-        forceRefresh: true
-    });
-    assert(daudeConcat.sessions.some(item => item.sessionId === daudeSessionId), 'daudecode query missing session');
-
-    const highlighted = await api('list-sessions', {
-        source: 'claude',
-        query: 'claude code hello',
-        queryScope: 'all',
-        contentScanBytes: 8 * 1024,
-        limit: 5,
-        forceRefresh: true
-    });
-    const highlightedHit = highlighted.sessions.find(item => item.sessionId === claudeSessionId);
-    assert(highlightedHit, 'highlight query missing Claude session');
-    assert(highlightedHit.match && highlightedHit.match.hit === true, 'highlight match missing for Claude session');
-    assert(Array.isArray(highlightedHit.match.snippets) && highlightedHit.match.snippets.some(
-        snippet => typeof snippet === 'string' && snippet.toLowerCase().includes('hello from claude code session')
-    ), 'highlight snippets missing Claude code text');
-
-    const numeric = await api('list-sessions', {
-        source: 'codex',
-        query: '222',
-        queryScope: 'all',
-        contentScanBytes: 8 * 1024,
-        limit: 10,
-        forceRefresh: true
-    });
-    const numericHit = numeric.sessions.find(item => item.sessionId === daudeSessionId);
-    assert(numericHit, '222 query missing daude session');
-    assert(numericHit.match && numericHit.match.hit === true, '222 match missing daude session hit');
-    assert(Array.isArray(numericHit.match.snippets) && numericHit.match.snippets.some(
-        snippet => typeof snippet === 'string' && snippet.includes('222')
-    ), '222 snippets missing numeric token');
-
-    const paged = await api('list-sessions', {
-        source: 'claude',
-        query: 'claude code hello',
-        queryScope: 'all',
-        limit: 1,
-        forceRefresh: true
-    });
-    assert(Array.isArray(paged.sessions) && paged.sessions.length === 1, 'paged search should return first page only');
-    assert(paged.sessions[0].sessionId === claudeSessionId, 'paged search first item should be Claude session');
-
-    const html = await fetchHtml(ctx.port);
-    assert(html && html.includes('.session-item-snippet'), 'session snippet style missing');
-    const lowerHtml = (html || '').toLowerCase();
-    assert(lowerHtml.includes('white-space: nowrap'), 'snippet nowrap missing');
-    assert(lowerHtml.includes('text-overflow: ellipsis'), 'snippet ellipsis missing');
-};

package/tests/e2e/test-sessions.js

@@ -1,69 +0,0 @@
-const path = require('path');
-const { assert } = require('./helpers');
-
-module.exports = async function testSessions(ctx) {
-    const { api, sessionId, tmpHome, claudeSessionId } = ctx;
-
-    const apiSessions = await api('list-sessions', { source: 'codex', limit: 50, forceRefresh: true });
-    assert(Array.isArray(apiSessions.sessions), 'api sessions missing');
-    assert(apiSessions.sessions.some(item => item.sessionId === sessionId), 'api sessions missing codex entry');
-
-    const apiSessionsClaude = await api('list-sessions', { source: 'claude', limit: 50, forceRefresh: true });
-    assert(Array.isArray(apiSessionsClaude.sessions), 'api sessions(claude) missing');
-    assert(apiSessionsClaude.sessions.some(item => item.sessionId === claudeSessionId), 'api sessions(claude) missing claude entry');
-
-    const claudeCodeQuery = await api('list-sessions', { source: 'claude', query: 'claude code', limit: 50, forceRefresh: true });
-    assert(Array.isArray(claudeCodeQuery.sessions), 'claude code query missing sessions');
-    const claudeCodeHit = claudeCodeQuery.sessions.find(item => item.sessionId === claudeSessionId);
-    assert(claudeCodeHit, 'claude code query missing Claude session');
-    assert(claudeCodeHit.provider === 'claude', 'claude code query provider mismatch');
-    assert(claudeCodeHit.capabilities && claudeCodeHit.capabilities.code === true, 'claude code query missing code capability');
-    assert(Array.isArray(claudeCodeHit.keywords) && claudeCodeHit.keywords.includes('claude_code'), 'claude code query missing keyword');
-
-    const sessionDetail = await api('session-detail', { source: 'codex', sessionId });
-    assert(Array.isArray(sessionDetail.messages), 'session-detail missing messages');
-
-    const sessionPlain = await api('session-plain', { source: 'codex', sessionId });
-    assert(sessionPlain.text && sessionPlain.text.includes('world'), 'session-plain missing content');
-
-    const sessionPlainMissing = await api('session-plain', { source: 'codex', sessionId: 'missing-session' });
-    assert(sessionPlainMissing.error, 'session-plain should fail for missing session');
-
-    const exportSession = await api('export-session', { source: 'codex', sessionId, maxMessages: 1 });
-    assert(exportSession.content, 'export-session missing content');
-    assert(exportSession.truncated === true, 'export-session should be truncated with maxMessages');
-
-    const cloneResult = await api('clone-session', { source: 'codex', sessionId });
-    assert(cloneResult.success === true, 'clone-session failed');
-    assert(cloneResult.sessionId && cloneResult.sessionId !== sessionId, 'clone-session id invalid');
-    assert(cloneResult.filePath && cloneResult.filePath.endsWith('.jsonl'), 'clone-session file path invalid');
-    assert(cloneResult.filePath && require('fs').existsSync(cloneResult.filePath), 'clone-session file missing');
-    const cloneSessionId = cloneResult.sessionId;
-
-    const cloneInvalid = await api('clone-session', { source: 'claude', sessionId });
-    assert(cloneInvalid.error, 'clone-session should reject non-codex source');
-
-    const apiSessionsAfterClone = await api('list-sessions', { source: 'codex', limit: 50, forceRefresh: true });
-    assert(Array.isArray(apiSessionsAfterClone.sessions), 'api sessions after clone missing');
-    assert(
-        apiSessionsAfterClone.sessions[0]
-        && apiSessionsAfterClone.sessions[0].sessionId === cloneSessionId,
-        'clone session not latest'
-    );
-
-    const deleteResult = await api('delete-session', { source: 'codex', sessionId });
-    assert(deleteResult.success === true, 'delete-session failed');
-
-    const deleteMissing = await api('delete-session', { source: 'codex', sessionId });
-    assert(deleteMissing.error, 'delete-session should fail for missing session');
-
-    const detailMissing = await api('session-detail', { source: 'codex', sessionId });
-    assert(detailMissing.error, 'session-detail should fail after delete');
-
-    const apiSessionsAfterDelete = await api('list-sessions', { source: 'codex', limit: 50, forceRefresh: true });
-    assert(!apiSessionsAfterDelete.sessions.some(item => item.sessionId === sessionId), 'deleted session still listed');
-    assert(apiSessionsAfterDelete.sessions.some(item => item.sessionId === cloneSessionId), 'clone session missing after delete');
-
-    Object.assign(ctx, { cloneSessionId });
-};
-

package/tests/e2e/test-setup.js

@@ -1,159 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const {
-    assert,
-    runSync,
-    runWithInput
-} = require('./helpers');
-
-module.exports = async function testSetup(ctx) {
-    const { env, node, cliPath, mockProviderUrl, noModelsUrl, htmlModelsUrl, authFailUrl, tmpHome } = ctx;
-
-    const setupInput = [
-        '2',
-        'e2e',
-        mockProviderUrl,
-        'sk-test',
-        'e2e-model',
-        ''
-    ].join('\n');
-
-    const setupResult = await runWithInput(node, [cliPath, 'setup'], setupInput, { env });
-    if (setupResult.status !== 0) {
-        const errorText = setupResult.stderr || setupResult.stdout || '';
-        if (errorText.includes('EPERM')) {
-            ctx.skipE2E = 'child_process spawn blocked (EPERM) during setup';
-            return;
-        }
-        assert(setupResult.status === 0, `setup failed: ${errorText}`);
-    }
-
-    const configPath = path.join(tmpHome, '.codex', 'config.toml');
-    assert(fs.existsSync(configPath), 'config.toml missing');
-    const configContent = fs.readFileSync(configPath, 'utf-8');
-    assert(/model_provider\s*=\s*"e2e"/.test(configContent), 'model_provider not set');
-    assert(/model\s*=\s*"e2e-model"/.test(configContent), 'model not set');
-    assert(/\[model_providers\.e2e\]/.test(configContent), 'provider block missing');
-    assert(configContent.includes(`base_url = "${mockProviderUrl}"`), 'base_url missing or mismatched');
-
-    const authPath = path.join(tmpHome, '.codex', 'auth.json');
-    const auth = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
-    assert(auth.OPENAI_API_KEY === 'sk-test', 'auth api_key mismatch');
-
-    const modelsPath = path.join(tmpHome, '.codex', 'models.json');
-    const models = JSON.parse(fs.readFileSync(modelsPath, 'utf-8'));
-    assert(models.includes('e2e-model'), 'custom model not added');
-
-    const statusResult = runSync(node, [cliPath, 'status'], { env });
-    assert(statusResult.status === 0, 'status failed');
-    assert(statusResult.stdout.includes('e2e'), 'status provider not shown');
-    assert(statusResult.stdout.includes('e2e-model'), 'status model not shown');
-
-    const listResult = runSync(node, [cliPath, 'list'], { env });
-    assert(listResult.status === 0, 'list failed');
-    assert(listResult.stdout.includes('e2e'), 'list missing provider');
-
-    const claudeModel = 'claude-e2e';
-    const claudeResult = runSync(node, [cliPath, 'claude', mockProviderUrl, 'sk-claude', claudeModel], { env });
-    assert(claudeResult.status === 0, `claude command failed: ${claudeResult.stderr || claudeResult.stdout}`);
-    const claudeSettingsPath = path.join(tmpHome, '.claude', 'settings.json');
-    assert(fs.existsSync(claudeSettingsPath), 'claude settings missing');
-    const claudeSettings = JSON.parse(fs.readFileSync(claudeSettingsPath, 'utf-8'));
-    assert(claudeSettings.env && claudeSettings.env.ANTHROPIC_API_KEY === 'sk-claude', 'claude API key mismatch');
-    assert(claudeSettings.env.ANTHROPIC_BASE_URL === mockProviderUrl, 'claude base url mismatch');
-    assert(claudeSettings.env.ANTHROPIC_MODEL === claudeModel, 'claude model mismatch');
-
-    const sessionsDir = path.join(tmpHome, '.codex', 'sessions');
-    fs.mkdirSync(sessionsDir, { recursive: true });
-    const sessionId = 'e2e-session';
-    const sessionPath = path.join(sessionsDir, `${sessionId}.jsonl`);
-    const sessionRecords = [
-        {
-            type: 'session_meta',
-            payload: { id: sessionId, cwd: '/tmp/e2e' },
-            timestamp: '2025-01-01T00:00:00.000Z'
-        },
-        {
-            type: 'response_item',
-            payload: { type: 'message', role: 'user', content: 'hello' },
-            timestamp: '2025-01-01T00:00:01.000Z'
-        },
-        {
-            type: 'response_item',
-            payload: { type: 'message', role: 'assistant', content: 'world' },
-            timestamp: '2025-01-01T00:00:02.000Z'
-        }
-    ];
-    fs.writeFileSync(sessionPath, sessionRecords.map(record => JSON.stringify(record)).join('\n') + '\n', 'utf-8');
-
-    const daudeSessionId = 'daude-e2e-session';
-    const daudeSessionPath = path.join(sessionsDir, `${daudeSessionId}.jsonl`);
-    const daudeRecords = [
-        {
-            type: 'session_meta',
-            payload: { id: daudeSessionId, cwd: '/tmp/daude' },
-            timestamp: '2025-02-02T00:00:00.000Z'
-        },
-        {
-            type: 'response_item',
-            payload: { type: 'message', role: 'user', content: 'daude code quick start 222' },
-            timestamp: '2025-02-02T00:00:01.000Z'
-        },
-        {
-            type: 'response_item',
-            payload: { type: 'message', role: 'assistant', content: 'sharing daude-code bootstrap' },
-            timestamp: '2025-02-02T00:00:02.000Z'
-        }
-    ];
-    fs.writeFileSync(daudeSessionPath, daudeRecords.map(record => JSON.stringify(record)).join('\n') + '\n', 'utf-8');
-
-    const claudeProjectsDir = path.join(tmpHome, '.claude', 'projects');
-    const claudeProjectDir = path.join(claudeProjectsDir, 'e2e-project');
-    fs.mkdirSync(claudeProjectDir, { recursive: true });
-    const claudeSessionId = 'claude-e2e-session';
-    const claudeSessionPath = path.join(claudeProjectDir, `${claudeSessionId}.jsonl`);
-    const claudeRecords = [
-        {
-            type: 'user',
-            message: { content: 'hello from claude code session' },
-            timestamp: '2025-02-01T00:00:00.000Z'
-        },
-        {
-            type: 'assistant',
-            message: { content: 'initialized project' },
-            timestamp: '2025-02-01T00:00:01.000Z'
-        }
-    ];
-    fs.writeFileSync(claudeSessionPath, claudeRecords.map(record => JSON.stringify(record)).join('\n') + '\n', 'utf-8');
-    const claudeIndexPath = path.join(claudeProjectDir, 'sessions-index.json');
-    const claudeIndex = {
-        entries: [
-            {
-                sessionId: claudeSessionId,
-                projectPath: claudeProjectDir,
-                fullPath: claudeSessionPath,
-                created: '2025-02-01T00:00:00.000Z',
-                modified: '2025-02-01T00:00:01.000Z',
-                summary: 'Claude Code sample session',
-                provider: 'claude',
-                capabilities: { code: true },
-                keywords: ['claude_code', 'sample'],
-                messageCount: 2
-            }
-        ]
-    };
-    fs.writeFileSync(claudeIndexPath, JSON.stringify(claudeIndex, null, 2), 'utf-8');
-
-    Object.assign(ctx, {
-        claudeModel,
-        sessionId,
-        sessionPath,
-        daudeSessionId,
-        daudeSessionPath,
-        claudeSessionId,
-        claudeSessionPath,
-        noModelsUrl,
-        htmlModelsUrl,
-        authFailUrl
-    });
-};

package/tests/unit/run.mjs

@@ -1,29 +0,0 @@
-import path from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const tests = [];
-globalThis.test = (name, fn) => tests.push({ name, fn });
-
-await import(pathToFileURL(path.join(__dirname, 'web-ui-logic.test.mjs')));
-
-let failures = 0;
-for (const { name, fn } of tests) {
-    try {
-        await fn();
-        console.log(`\u2713 ${name}`);
-    } catch (err) {
-        failures += 1;
-        console.error(`\u2717 ${name}`);
-        console.error(err);
-    }
-}
-
-if (failures) {
-    console.error(`Failed ${failures} test(s).`);
-    process.exit(1);
-} else {
-    console.log(`All ${tests.length} tests passed.`);
-}

package/tests/unit/web-ui-logic.test.mjs

@@ -1,186 +0,0 @@
-import assert from 'assert';
-import path from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const logic = await import(pathToFileURL(path.join(__dirname, '..', '..', 'web-ui', 'logic.mjs')));
-const {
-    normalizeClaudeValue,
-    normalizeClaudeConfig,
-    normalizeClaudeSettingsEnv,
-    matchClaudeConfigFromSettings,
-    findDuplicateClaudeConfigName,
-    formatLatency,
-    buildSpeedTestIssue,
-    isSessionQueryEnabled,
-    buildSessionListParams
-} = logic;
-
-test('normalizeClaudeValue trims strings and ignores non-string', () => {
-    assert.strictEqual(normalizeClaudeValue('  abc  '), 'abc');
-    assert.strictEqual(normalizeClaudeValue(123), '');
-    assert.strictEqual(normalizeClaudeValue(null), '');
-});
-
-test('normalizeClaudeConfig trims all fields', () => {
-    const cfg = normalizeClaudeConfig({ apiKey: ' key ', baseUrl: ' url ', model: ' model ' });
-    assert.deepStrictEqual(cfg, { apiKey: 'key', baseUrl: 'url', model: 'model' });
-});
-
-test('normalizeClaudeSettingsEnv trims settings env', () => {
-    const env = { ANTHROPIC_API_KEY: ' key ', ANTHROPIC_BASE_URL: ' url ', ANTHROPIC_MODEL: ' model ' };
-    assert.deepStrictEqual(normalizeClaudeSettingsEnv(env), { apiKey: 'key', baseUrl: 'url', model: 'model' });
-});
-
-test('normalizeClaudeSettingsEnv fills missing fields with empty strings', () => {
-    const env = { ANTHROPIC_API_KEY: 'k' };
-    assert.deepStrictEqual(normalizeClaudeSettingsEnv(env), { apiKey: 'k', baseUrl: '', model: '' });
-});
-
-test('matchClaudeConfigFromSettings matches identical config', () => {
-    const configs = { default: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
-    const env = { ANTHROPIC_API_KEY: 'k', ANTHROPIC_BASE_URL: 'u', ANTHROPIC_MODEL: 'm' };
-    assert.strictEqual(matchClaudeConfigFromSettings(configs, env), 'default');
-});
-
-test('matchClaudeConfigFromSettings returns empty when incomplete', () => {
-    const configs = { default: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
-    const env = { ANTHROPIC_API_KEY: 'k', ANTHROPIC_BASE_URL: '', ANTHROPIC_MODEL: 'm' };
-    assert.strictEqual(matchClaudeConfigFromSettings(configs, env), '');
-});
-
-test('findDuplicateClaudeConfigName returns empty on missing fields', () => {
-    const configs = { only: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
-    const incomplete = { apiKey: 'k', baseUrl: '', model: '' };
-    assert.strictEqual(findDuplicateClaudeConfigName(configs, incomplete), '');
-});
-
-test('findDuplicateClaudeConfigName detects duplicates', () => {
-    const configs = {
-        first: { apiKey: 'k1', baseUrl: 'u1', model: 'm1' },
-        second: { apiKey: 'k2', baseUrl: 'u2', model: 'm2' }
-    };
-    const duplicate = { apiKey: 'k2', baseUrl: 'u2', model: 'm2' };
-    assert.strictEqual(findDuplicateClaudeConfigName(configs, duplicate), 'second');
-});
-
-test('findDuplicateClaudeConfigName returns empty when no match', () => {
-    const configs = { only: { apiKey: 'k', baseUrl: 'u', model: 'm' } };
-    const another = { apiKey: 'k', baseUrl: 'u', model: 'm-2' };
-    assert.strictEqual(findDuplicateClaudeConfigName(configs, another), '');
-});
-
-test('formatLatency formats success and errors', () => {
-    assert.strictEqual(formatLatency({ ok: true, durationMs: 120 }), '120ms');
-    assert.strictEqual(formatLatency({ ok: false, status: 404 }), 'ERR 404');
-    assert.strictEqual(formatLatency({ ok: false }), 'ERR');
-    assert.strictEqual(formatLatency(null), '');
-    assert.strictEqual(formatLatency({ ok: true, durationMs: undefined }), '0ms');
-    assert.strictEqual(formatLatency({ ok: true, durationMs: '12' }), '0ms');
-});
-
-test('buildSpeedTestIssue maps errors and status codes', () => {
-    assert.strictEqual(buildSpeedTestIssue('p1', null), null);
-    const missing = buildSpeedTestIssue('p1', { error: 'Provider not found' });
-    assert.strictEqual(missing.code, 'remote-speedtest-provider-missing');
-
-    const timeout = buildSpeedTestIssue('p1', { error: 'Request timeout' });
-    assert.strictEqual(timeout.code, 'remote-speedtest-timeout');
-
-    const auth = buildSpeedTestIssue('p1', { ok: false, status: 401 });
-    assert.strictEqual(auth.code, 'remote-speedtest-auth-failed');
-
-    const httpErr = buildSpeedTestIssue('p1', { ok: false, status: 500 });
-    assert.strictEqual(httpErr.code, 'remote-speedtest-http-error');
-
-    const ok = buildSpeedTestIssue('p1', { ok: true, status: 200 });
-    assert.strictEqual(ok, null);
-
-    const invalidUrl = buildSpeedTestIssue('p1', { error: 'Invalid URL' });
-    assert.strictEqual(invalidUrl.code, 'remote-speedtest-invalid-url');
-
-    const missingUrl = buildSpeedTestIssue('p1', { error: 'Missing name or url' });
-    assert.strictEqual(missingUrl.code, 'remote-speedtest-baseurl-missing');
-
-    const timeoutLower = buildSpeedTestIssue('p1', { error: 'timeout while fetching' });
-    assert.strictEqual(timeoutLower.code, 'remote-speedtest-timeout');
-
-    const generic = buildSpeedTestIssue('p1', { error: 'network unreachable' });
-    assert.strictEqual(generic.code, 'remote-speedtest-unreachable');
-
-    const auth403 = buildSpeedTestIssue('p1', { ok: false, status: 403 });
-    assert.strictEqual(auth403.code, 'remote-speedtest-auth-failed');
-
-    const http400 = buildSpeedTestIssue('p1', { ok: false, status: 400 });
-    assert.strictEqual(http400.code, 'remote-speedtest-http-error');
-});
-
-test('isSessionQueryEnabled supports codex and claude only', () => {
-    assert.strictEqual(isSessionQueryEnabled('codex'), true);
-    assert.strictEqual(isSessionQueryEnabled('CODEX'), true);
-    assert.strictEqual(isSessionQueryEnabled('claude'), true);
-    assert.strictEqual(isSessionQueryEnabled('ALL'), false);
-    assert.strictEqual(isSessionQueryEnabled('openai'), false);
-    assert.strictEqual(isSessionQueryEnabled(''), false);
-});
-
-test('buildSessionListParams keeps claude code lexicon query when enabled', () => {
-    const paramsClaude = buildSessionListParams({
-        source: 'claude',
-        query: 'claude code',
-        roleFilter: 'all'
-    });
-    assert.strictEqual(paramsClaude.query, 'claude code');
-    assert.strictEqual(paramsClaude.queryMode, 'and');
-    assert.strictEqual(paramsClaude.queryScope, 'content');
-});
-
-test('buildSessionListParams keeps query for enabled sources', () => {
-    const paramsCodex = buildSessionListParams({
-        source: 'codex',
-        query: 'test',
-        pathFilter: ''
-    });
-    assert.strictEqual(paramsCodex.query, 'test');
-    assert.strictEqual(paramsCodex.source, 'codex');
-    assert.strictEqual(paramsCodex.limit, 200);
-
-    const paramsClaude = buildSessionListParams({
-        source: 'claude',
-        query: 'claude code',
-        roleFilter: 'user'
-    });
-    assert.strictEqual(paramsClaude.query, 'claude code');
-    assert.strictEqual(paramsClaude.source, 'claude');
-    assert.strictEqual(paramsClaude.roleFilter, 'user');
-    assert.strictEqual(paramsClaude.limit, 200);
-
-    const paramsAll = buildSessionListParams({
-        source: 'codex',
-        query: 'claudecode',
-        timeRangePreset: '7d'
-    });
-    assert.strictEqual(paramsAll.query, 'claudecode');
-    assert.strictEqual(paramsAll.source, 'codex');
-    assert.strictEqual(paramsAll.timeRangePreset, '7d');
-    assert.strictEqual(paramsAll.limit, 200);
-});
-
-test('buildSessionListParams clears query for unsupported sources', () => {
-    const params = buildSessionListParams({
-        source: 'openai',
-        query: 'hello',
-        pathFilter: '/tmp',
-        roleFilter: 'assistant'
-    });
-    assert.strictEqual(params.query, '');
-    assert.strictEqual(params.source, 'openai');
-    assert.strictEqual(params.pathFilter, '/tmp');
-    assert.strictEqual(params.roleFilter, 'assistant');
-    assert.strictEqual(params.limit, 200);
-    assert.strictEqual(params.forceRefresh, true);
-    assert.strictEqual(params.queryScope, 'content');
-    assert.strictEqual(params.contentScanLimit, 50);
-});