codexmate 0.0.25 → 0.0.27

package/cli.js

@@ -115,6 +115,7 @@ const {
 const {
     createZipCommandController
 } = require('./cli/zip-commands');
+const { cmdConvertSession } = require('./cli/session-convert');
 const {
     getCodexSkillsDir,
     getClaudeSkillsDir,
@@ -196,6 +197,11 @@ const CLAUDE_MD_FILE_NAME = 'CLAUDE.md';
 const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 const CODEBUDDY_DIR = path.join(os.homedir(), '.codebuddy');
 const CODEBUDDY_PROJECTS_DIR = path.join(CODEBUDDY_DIR, 'projects');
+const CODEXMATE_DIR = path.join(os.homedir(), '.codexmate');
+const CODEXMATE_SESSIONS_DIR = path.join(CODEXMATE_DIR, 'sessions');
+const CODEXMATE_DERIVED_SESSIONS_DIR = path.join(CODEXMATE_SESSIONS_DIR, 'derived');
+const CODEXMATE_DERIVED_CODEX_DIR = path.join(CODEXMATE_DERIVED_SESSIONS_DIR, 'codex');
+const CODEXMATE_DERIVED_CLAUDE_DIR = path.join(CODEXMATE_DERIVED_SESSIONS_DIR, 'claude');
 const GEMINI_DIR = path.join(os.homedir(), '.gemini');
 const GEMINI_TMP_DIR = path.join(GEMINI_DIR, 'tmp');
 const RECENT_CONFIGS_FILE = path.join(CONFIG_DIR, 'recent-configs.json');
@@ -216,6 +222,7 @@ const DEFAULT_MODELS = ['gpt-5.3-codex', 'gpt-5.1-codex-max', 'gpt-4-turbo', 'gp
 const SPEED_TEST_TIMEOUT_MS = 8000;
 const MAX_SESSION_LIST_SIZE = 300;
 const MAX_SESSION_TRASH_LIST_SIZE = 500;
+const DEFAULT_SESSION_TRASH_RETENTION_DAYS = 30;
 const MAX_EXPORT_MESSAGES = 1000;
 const DEFAULT_SESSION_DETAIL_MESSAGES = 300;
 const MAX_SESSION_DETAIL_MESSAGES = 1000;
@@ -1308,6 +1315,58 @@ function getCodeBuddyProjectsDir() {
     return resolveExistingDir(candidates, CODEBUDDY_PROJECTS_DIR);
 }
 
+function getCodexmateDerivedSessionsRoot(target) {
+    if (target === 'claude') {
+        return CODEXMATE_DERIVED_CLAUDE_DIR;
+    }
+    return CODEXMATE_DERIVED_CODEX_DIR;
+}
+
+function normalizeSessionDerivedTarget(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'codex' || normalized === 'claude') {
+        return normalized;
+    }
+    return '';
+}
+
+function normalizeSessionDerivedSource(value) {
+    return normalizeSessionDerivedTarget(value);
+}
+
+function buildSessionDerivedSourceKey(source, sessionId, filePath) {
+    const baseSource = normalizeSessionDerivedSource(source);
+    const id = typeof sessionId === 'string' ? sessionId.trim() : '';
+    const pathValue = typeof filePath === 'string' ? filePath.trim() : '';
+    const seed = `${baseSource}|${id}|${pathValue}`;
+    return crypto.createHash('sha1').update(seed).digest('hex').slice(0, 16);
+}
+
+function formatCompactTimestamp(value = Date.now()) {
+    const stamp = new Date(value);
+    const year = String(stamp.getFullYear());
+    const month = String(stamp.getMonth() + 1).padStart(2, '0');
+    const day = String(stamp.getDate()).padStart(2, '0');
+    const hour = String(stamp.getHours()).padStart(2, '0');
+    const minute = String(stamp.getMinutes()).padStart(2, '0');
+    const second = String(stamp.getSeconds()).padStart(2, '0');
+    return `${year}${month}${day}-${hour}${minute}${second}`;
+}
+
+function buildDerivedSessionId(baseId) {
+    const safeBase = typeof baseId === 'string' && baseId.trim() ? baseId.trim() : 'session';
+    const normalized = safeBase.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64) || 'session';
+    const suffix = crypto.randomBytes(3).toString('hex');
+    return `${normalized}-${formatCompactTimestamp()}-${suffix}`;
+}
+
+function buildDerivedSessionOutputDir(target, source, sourceKey) {
+    const targetRoot = getCodexmateDerivedSessionsRoot(target);
+    const safeSource = normalizeSessionDerivedSource(source) || 'codex';
+    const safeKey = typeof sourceKey === 'string' && sourceKey.trim() ? sourceKey.trim() : 'unknown';
+    return path.join(targetRoot, safeSource, safeKey);
+}
+
 function readModelsCacheEntry(cacheKey) {
     if (!cacheKey) return null;
     const entry = g_modelsCache.get(cacheKey);
@@ -2869,6 +2928,46 @@ async function hydrateSessionItemsExactMessageCount(items) {
     });
 }
 
+function getSessionExportKeyForApi(item) {
+    const source = item && item.source ? String(item.source).trim() : '';
+    const sessionId = item && item.sessionId ? String(item.sessionId) : '';
+    const filePath = item && item.filePath ? String(item.filePath) : '';
+    return `${source || 'unknown'}:${sessionId}:${filePath}`;
+}
+
+async function readSessionMessageCounts(params = {}) {
+    const rawItems = Array.isArray(params.items) ? params.items : [];
+    const rawLimit = Number(params.limit);
+    const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.min(Math.floor(rawLimit), 80)) : 40;
+    const items = rawItems.slice(0, limit);
+    const hydrated = await mapWithConcurrency(items, 4, async (item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            return undefined;
+        }
+        const key = getSessionExportKeyForApi(item);
+        const source = item.source === 'claude'
+            ? 'claude'
+            : (item.source === 'codex'
+                ? 'codex'
+                : (item.source === 'gemini' ? 'gemini' : (item.source === 'codebuddy' ? 'codebuddy' : '')));
+        const filePath = typeof item.filePath === 'string' ? item.filePath : '';
+        if (!source || !filePath || !fs.existsSync(filePath)) {
+            return { key };
+        }
+        const exactMessageCount = await countConversationMessagesInFile(filePath, source);
+        if (!Number.isFinite(Number(exactMessageCount))) {
+            return { key };
+        }
+        return {
+            key,
+            messageCount: Math.max(0, Math.floor(Number(exactMessageCount)))
+        };
+    });
+    return {
+        items: hydrated.filter(Boolean)
+    };
+}
+
 function sortSessionsByUpdatedAt(items) {
     items.sort((a, b) => {
         const aTime = Date.parse(a.updatedAt || '') || 0;
@@ -3279,6 +3378,57 @@ function collectRecentJsonlFiles(rootDir, options = {}) {
     return filesMeta.slice(0, returnCount).map(item => item.filePath);
 }
 
+function collectRecentJsonlFilesFromRoots(rootDirs, options = {}) {
+    const roots = Array.isArray(rootDirs)
+        ? rootDirs.filter((dirPath) => typeof dirPath === 'string' && dirPath.trim() && fs.existsSync(dirPath.trim()))
+        : [];
+    if (roots.length === 0) {
+        return [];
+    }
+
+    const returnCount = Math.max(1, Number(options.returnCount) || 1);
+    const maxFilesScanned = Math.max(returnCount, Number(options.maxFilesScanned) || 2000);
+    const ignoreSubPath = typeof options.ignoreSubPath === 'string' ? options.ignoreSubPath : '';
+    const stack = roots.map((dirPath) => dirPath.trim());
+    const filesMeta = [];
+    let scanned = 0;
+
+    while (stack.length > 0 && scanned < maxFilesScanned) {
+        const dir = stack.pop();
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch (_) {
+            continue;
+        }
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl')) {
+                continue;
+            }
+            if (ignoreSubPath && fullPath.includes(ignoreSubPath)) {
+                continue;
+            }
+            scanned += 1;
+            try {
+                const stat = fs.statSync(fullPath);
+                filesMeta.push({ filePath: fullPath, mtimeMs: stat.mtimeMs || 0 });
+            } catch (_) {}
+            if (scanned >= maxFilesScanned) {
+                break;
+            }
+        }
+    }
+
+    filesMeta.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return filesMeta.slice(0, returnCount).map(item => item.filePath);
+}
+
 function getSessionListCache(cacheKey, forceRefresh = false) {
     if (forceRefresh) {
         g_sessionListCache.delete(cacheKey);
@@ -4394,7 +4544,7 @@ function listCodexSessions(limit, options = {}) {
     const titleReadBytes = Number.isFinite(Number(options.titleReadBytes))
         ? Math.max(1024, Math.floor(Number(options.titleReadBytes)))
         : SESSION_TITLE_READ_BYTES;
-    const files = collectRecentJsonlFiles(codexSessionsDir, {
+    const files = collectRecentJsonlFilesFromRoots([codexSessionsDir, getCodexmateDerivedSessionsRoot('codex')], {
         returnCount: scanCount,
         maxFilesScanned
     });
@@ -4406,7 +4556,10 @@ function listCodexSessions(limit, options = {}) {
             titleReadBytes
         });
         if (summary) {
-            sessions.push(summary);
+            sessions.push({
+                ...summary,
+                derived: isDerivedSessionFile(filePath)
+            });
         }
 
         if (sessions.length >= targetCount) {
@@ -4419,7 +4572,10 @@ function listCodexSessions(limit, options = {}) {
 
 function listClaudeSessions(limit, options = {}) {
     const claudeProjectsDir = getClaudeProjectsDir();
-    if (!fs.existsSync(claudeProjectsDir)) {
+    const derivedClaudeRoot = getCodexmateDerivedSessionsRoot('claude');
+    const hasProjectsDir = fs.existsSync(claudeProjectsDir);
+    const hasDerivedDir = fs.existsSync(derivedClaudeRoot);
+    if (!hasProjectsDir && !hasDerivedDir) {
         return [];
     }
 
@@ -4447,12 +4603,14 @@ function listClaudeSessions(limit, options = {}) {
 
     const sessions = [];
     let projectDirs = [];
-    try {
-        projectDirs = fs.readdirSync(claudeProjectsDir, { withFileTypes: true })
-            .filter(entry => entry.isDirectory())
-            .map(entry => path.join(claudeProjectsDir, entry.name));
-    } catch (e) {
-        projectDirs = [];
+    if (hasProjectsDir) {
+        try {
+            projectDirs = fs.readdirSync(claudeProjectsDir, { withFileTypes: true })
+                .filter(entry => entry.isDirectory())
+                .map(entry => path.join(claudeProjectsDir, entry.name));
+        } catch (e) {
+            projectDirs = [];
+        }
     }
 
     for (const projectDir of projectDirs) {
@@ -4583,6 +4741,7 @@ function listClaudeSessions(limit, options = {}) {
                 models,
                 __messageCountExact: quickRecords.length > 0 && isSessionSummaryMessageCountExact(fileStat, summaryReadBytes),
                 filePath,
+                derived: isDerivedSessionFile(filePath),
                 keywords,
                 capabilities
             });
@@ -4609,7 +4768,10 @@ function listClaudeSessions(limit, options = {}) {
                 titleReadBytes
             });
             if (summary) {
-                sessions.push(summary);
+                sessions.push({
+                    ...summary,
+                    derived: isDerivedSessionFile(filePath)
+                });
             }
 
             if (sessions.length >= targetCount) {
@@ -4618,6 +4780,28 @@ function listClaudeSessions(limit, options = {}) {
         }
     }
 
+    if (fs.existsSync(derivedClaudeRoot)) {
+        const seen = new Set(sessions.map((item) => (item && item.filePath ? item.filePath : '')).filter(Boolean));
+        const derivedFiles = collectRecentJsonlFiles(derivedClaudeRoot, {
+            returnCount: scanCount,
+            maxFilesScanned
+        });
+        for (const filePath of derivedFiles) {
+            if (seen.has(filePath)) continue;
+            const summary = parseClaudeSessionSummary(filePath, {
+                summaryReadBytes,
+                titleReadBytes
+            });
+            if (summary) {
+                sessions.push({
+                    ...summary,
+                    derived: isDerivedSessionFile(filePath)
+                });
+            }
+            seen.add(filePath);
+        }
+    }
+
     return mergeAndLimitSessions(sessions, limit);
 }
 
@@ -4962,19 +5146,25 @@ function resolveSessionFilePath(source, filePath, sessionId) {
     const normalizedSource = source === 'claude' || source === 'gemini' || source === 'codebuddy'
         ? source
         : 'codex';
-    const root = normalizedSource === 'claude'
-        ? getClaudeProjectsDir()
+    const homeDir = process && process.env && process.env.HOME ? process.env.HOME : '';
+    const derivedCodexDir = homeDir ? `${homeDir}/.codexmate/sessions/derived/codex` : '';
+    const derivedClaudeDir = homeDir ? `${homeDir}/.codexmate/sessions/derived/claude` : '';
+    const roots = normalizedSource === 'claude'
+        ? [getClaudeProjectsDir(), derivedClaudeDir]
         : (normalizedSource === 'gemini'
-            ? getGeminiTmpDir()
-            : (normalizedSource === 'codebuddy' ? getCodeBuddyProjectsDir() : getCodexSessionsDir()));
-    if (!root || !fs.existsSync(root)) {
+            ? [getGeminiTmpDir()]
+            : (normalizedSource === 'codebuddy'
+                ? [getCodeBuddyProjectsDir()]
+                : [getCodexSessionsDir(), derivedCodexDir]));
+    const availableRoots = roots.filter((dirPath) => dirPath && fs.existsSync(dirPath));
+    if (availableRoots.length === 0) {
         return '';
     }
 
     if (typeof filePath === 'string' && filePath.trim()) {
         const expandedPath = expandHomePath(filePath.trim());
         const targetPath = expandedPath ? path.resolve(expandedPath) : '';
-        if (targetPath && fs.existsSync(targetPath) && isPathInside(targetPath, root)) {
+        if (targetPath && fs.existsSync(targetPath) && availableRoots.some((rootPath) => isPathInside(targetPath, rootPath))) {
             return targetPath;
         }
     }
@@ -4984,7 +5174,7 @@ function resolveSessionFilePath(source, filePath, sessionId) {
         const lookupStore = g_sessionFileLookupCache[normalizedSource];
         if (lookupStore instanceof Map && lookupStore.has(targetId)) {
             const cachedPath = lookupStore.get(targetId);
-            if (cachedPath && fs.existsSync(cachedPath) && isPathInside(cachedPath, root)) {
+            if (cachedPath && fs.existsSync(cachedPath) && availableRoots.some((rootPath) => isPathInside(cachedPath, rootPath))) {
                 return cachedPath;
             }
             lookupStore.delete(targetId);
@@ -5019,7 +5209,11 @@ function resolveSessionFilePath(source, filePath, sessionId) {
             }
             matchedFile = filesMeta.find(item => path.basename(item, '.json').toLowerCase() === targetId) || '';
         } else {
-            const files = collectJsonlFiles(root, 5000);
+            const files = [];
+            for (const rootPath of availableRoots) {
+                files.push(...collectJsonlFiles(rootPath, 5000));
+                if (files.length >= 5000) break;
+            }
             matchedFile = files.find(item => path.basename(item, '.jsonl').toLowerCase() === targetId) || '';
         }
         if (matchedFile && fs.existsSync(matchedFile)) {
@@ -5067,6 +5261,65 @@ function findClaudeSessionIndexPath(sessionFilePath) {
     return '';
 }
 
+function resolveClaudeProjectDirForCwd(cwd) {
+    const projectsDir = getClaudeProjectsDir();
+    const raw = typeof cwd === 'string' ? cwd.trim() : '';
+    if (!projectsDir || !raw) {
+        return '';
+    }
+    const ignoreCase = process.platform === 'win32';
+    const resolvedCwd = path.resolve(expandHomePath(raw));
+    let entries = [];
+    try {
+        entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+    } catch (_) {
+        entries = [];
+    }
+    for (const entry of entries) {
+        if (!entry || !entry.isDirectory()) continue;
+        const projectDir = path.join(projectsDir, entry.name);
+        const indexPath = path.join(projectDir, 'sessions-index.json');
+        if (!fs.existsSync(indexPath)) continue;
+        const index = readJsonFile(indexPath, null);
+        const originalPathRaw = index && typeof index.originalPath === 'string' ? index.originalPath.trim() : '';
+        if (!originalPathRaw) continue;
+        const resolvedOriginal = path.resolve(expandHomePath(originalPathRaw));
+        if (normalizePathForCompare(resolvedOriginal, { ignoreCase }) === normalizePathForCompare(resolvedCwd, { ignoreCase })) {
+            return projectDir;
+        }
+    }
+    const hash = crypto.createHash('sha1').update(resolvedCwd).digest('hex').slice(0, 12);
+    return path.join(projectsDir, `codexmate-${hash}`);
+}
+
+function ensureClaudeSessionsIndex(indexPath, originalPath) {
+    if (!indexPath) return;
+    const resolvedOriginal = typeof originalPath === 'string' && originalPath.trim()
+        ? path.resolve(expandHomePath(originalPath.trim()))
+        : '';
+    const existing = readJsonFile(indexPath, null);
+    const index = existing && typeof existing === 'object' && !Array.isArray(existing)
+        ? { ...existing }
+        : { entries: [] };
+    if (!Array.isArray(index.entries)) {
+        index.entries = [];
+    }
+    if (!index.originalPath && resolvedOriginal) {
+        index.originalPath = resolvedOriginal;
+    }
+    if (!fs.existsSync(indexPath)) {
+        if (!index.originalPath) {
+            index.originalPath = resolvedOriginal || path.dirname(indexPath);
+        }
+        writeJsonAtomic(indexPath, index);
+        return;
+    }
+    if (existing && typeof existing === 'object' && !Array.isArray(existing) && existing.originalPath === index.originalPath) {
+        return;
+    }
+    writeJsonAtomic(indexPath, index);
+}
+
 const {
     findAvailablePort,
     saveBuiltinProxySettings,
@@ -5349,6 +5602,35 @@ function readSessionTrashEntries(options = {}) {
     return normalizedEntries;
 }
 
+function purgeExpiredSessionTrashEntries(retentionDays) {
+    const days = Number.isFinite(Number(retentionDays)) && Number(retentionDays) > 0
+        ? Math.floor(Number(retentionDays))
+        : DEFAULT_SESSION_TRASH_RETENTION_DAYS;
+    const cutoffMs = Date.now() - days * 24 * 60 * 60 * 1000;
+    const entries = readSessionTrashEntries({ cleanup: false });
+    if (entries.length === 0) {
+        return { purged: 0 };
+    }
+    const remaining = [];
+    let purgedCount = 0;
+    for (const entry of entries) {
+        const deletedAtMs = Date.parse(entry.deletedAt || entry.updatedAt || '') || 0;
+        if (deletedAtMs > 0 && deletedAtMs < cutoffMs) {
+            const trashFilePath = resolveSessionTrashFilePath(entry);
+            if (trashFilePath) {
+                try { fs.unlinkSync(trashFilePath); } catch (_) {}
+            }
+            purgedCount += 1;
+        } else {
+            remaining.push(entry);
+        }
+    }
+    if (purgedCount > 0) {
+        writeSessionTrashEntries(remaining);
+    }
+    return { purged: purgedCount };
+}
+
 function buildSessionTrashEntry(summary, options = {}) {
     const source = options.source === 'claude' ? 'claude' : 'codex';
     const sessionId = options.sessionId || summary.sessionId || path.basename(options.originalFilePath || summary.filePath || '', '.jsonl');
@@ -5560,6 +5842,9 @@ async function listSessionTrashItems(params = {}) {
     const limit = Number.isFinite(rawLimit)
         ? Math.max(1, Math.min(rawLimit, MAX_SESSION_TRASH_LIST_SIZE))
         : 200;
+    if (params.autoPurge !== false) {
+        purgeExpiredSessionTrashEntries(params.retentionDays);
+    }
     const allEntries = readSessionTrashEntries();
     let items = source === 'codex' || source === 'claude' || source === 'gemini' || source === 'codebuddy'
         ? allEntries.filter((entry) => entry.source === source)
@@ -6122,6 +6407,28 @@ function buildSessionPlainText(messages) {
     return lines.join('\n');
 }
 
+function getDerivedSessionMetaPath(filePath) {
+    if (!filePath) return '';
+    const base = filePath.toLowerCase().endsWith('.jsonl')
+        ? filePath.slice(0, -5)
+        : filePath;
+    return `${base}.meta.json`;
+}
+
+function isDerivedSessionFile(filePath) {
+    const metaPath = getDerivedSessionMetaPath(filePath);
+    if (!metaPath) return false;
+    try {
+        if (fs.existsSync(metaPath)) {
+            return true;
+        }
+    } catch (_) {
+        return false;
+    }
+    const base = path.basename(filePath || '', path.extname(filePath || ''));
+    return /-\d{8}-\d{6}-[0-9a-f]{6}$/i.test(base);
+}
+
 function resolveStateMaxMessages(state) {
     if (!state || typeof state !== 'object') {
         return MAX_EXPORT_MESSAGES;
@@ -6467,6 +6774,20 @@ async function readSessionDetail(params = {}) {
         sessionId,
         cwd: extracted.cwd || '',
         updatedAt: extracted.updatedAt || '',
+        derived: (() => {
+            try {
+                const metaPath = filePath.toLowerCase().endsWith('.jsonl')
+                    ? `${filePath.slice(0, -5)}.meta.json`
+                    : `${filePath}.meta.json`;
+                if (fs.existsSync(metaPath)) {
+                    return true;
+                }
+            } catch (_) {
+                return false;
+            }
+            const base = path.basename(filePath || '', path.extname(filePath || ''));
+            return /-\d{8}-\d{6}-[0-9a-f]{6}$/i.test(base);
+        })(),
         totalMessages: hasExactTotalMessages ? extracted.totalMessages : null,
         clipped: typeof extracted.clipped === 'boolean'
             ? extracted.clipped
@@ -6494,6 +6815,15 @@ async function readSessionPlain(params = {}) {
         return { error: 'Session file not found' };
     }
 
+    const rawMaxMessages = params.maxMessages;
+    const maxMessages = rawMaxMessages === Infinity || rawMaxMessages === 'all'
+        ? Infinity
+        : (
+            Number.isFinite(Number(rawMaxMessages))
+                ? Math.max(1, Math.floor(Number(rawMaxMessages)))
+                : 50
+        );
+
     let extracted;
     if (source === 'gemini') {
         let json;
@@ -6514,15 +6844,19 @@ async function readSessionPlain(params = {}) {
             const text = extractMessageText(extractGeminiMessageText(entry.content ?? entry.message ?? entry.text));
             if (!text && role !== 'system') continue;
             messages.push({ role, text });
+            if (maxMessages !== Infinity && messages.length >= maxMessages) {
+                break;
+            }
         }
         extracted = {
             sessionId: typeof json.sessionId === 'string' && json.sessionId.trim() ? json.sessionId.trim() : path.basename(filePath, '.json'),
             cwd: typeof json.projectRoot === 'string' ? json.projectRoot : '',
-            messages
+            messages,
+            truncated: maxMessages !== Infinity && rawMessages.length > messages.length
         };
     } else {
         try {
-            extracted = await extractMessagesFromFile(filePath, source, { maxMessages: Infinity });
+            extracted = await extractMessagesFromFile(filePath, source, { maxMessages });
         } catch (e) {
             extracted = null;
         }
@@ -6536,7 +6870,7 @@ async function readSessionPlain(params = {}) {
             if (fallbackRecords.length === 0) {
                 return { error: 'Session file is empty' };
             }
-            extracted = extractMessagesFromRecords(fallbackRecords, source, { maxMessages: Infinity });
+            extracted = extractMessagesFromRecords(fallbackRecords, source, { maxMessages });
         }
     }
 
@@ -6555,7 +6889,8 @@ async function readSessionPlain(params = {}) {
         sessionId,
         title: sessionId,
         filePath,
-        text
+        text,
+        clipped: maxMessages !== Infinity && !!(extracted && extracted.truncated)
     };
 }
 
@@ -6663,6 +6998,163 @@ async function exportSessionData(params = {}) {
     };
 }
 
+async function convertSessionToDerived(params = {}) {
+    const source = normalizeSessionDerivedSource(params.source);
+    const target = normalizeSessionDerivedTarget(params.target || params.to);
+    if (!source || !target) {
+        return { error: 'Invalid source/target' };
+    }
+    if (source === target) {
+        return { error: 'source and target must be different' };
+    }
+
+    const maxMessages = resolveMaxMessagesValue(params.maxMessages, MAX_EXPORT_MESSAGES);
+    const filePath = resolveSessionFilePath(source, getSessionFileArg(params), params.sessionId);
+    if (!filePath) {
+        return { error: 'Session file not found' };
+    }
+
+    let extracted;
+    try {
+        extracted = await extractMessagesFromFile(filePath, source, { maxMessages });
+    } catch (_) {
+        extracted = null;
+    }
+    if (!extracted) {
+        return { error: 'Failed to parse session file' };
+    }
+
+    const baseSessionId = extracted.sessionId || params.sessionId || path.basename(filePath, '.jsonl');
+    const derivedSessionId = buildDerivedSessionId(baseSessionId);
+    const sourceKey = buildSessionDerivedSourceKey(source, baseSessionId, filePath);
+    const outputDir = target === 'codex'
+        ? getCodexSessionsDir()
+        : (target === 'claude'
+            ? (resolveClaudeProjectDirForCwd(extracted.cwd || '') || path.join(getClaudeProjectsDir(), 'codexmate-derived'))
+            : buildDerivedSessionOutputDir(target, source, sourceKey));
+    ensureDir(outputDir);
+    const outputPath = path.join(outputDir, `${derivedSessionId}.jsonl`);
+    const metaPath = path.join(outputDir, `${derivedSessionId}.meta.json`);
+
+    const cwd = typeof extracted.cwd === 'string' ? extracted.cwd : '';
+    const resolvedCwd = cwd ? path.resolve(expandHomePath(cwd)) : '';
+    const messages = removeLeadingSystemMessage(Array.isArray(extracted.messages) ? extracted.messages : []);
+    const now = Date.now();
+    const baseTime = new Date(now).toISOString();
+    const lines = [];
+
+    if (target === 'codex') {
+        lines.push(JSON.stringify({ type: 'session_meta', timestamp: baseTime, payload: { id: derivedSessionId, cwd } }));
+        for (let i = 0; i < messages.length; i += 1) {
+            const message = messages[i];
+            if (!message) continue;
+            const role = normalizeRole(message.role);
+            if (role !== 'user' && role !== 'assistant' && role !== 'system') continue;
+            const text = typeof message.text === 'string' ? message.text : '';
+            if (!text) continue;
+            lines.push(JSON.stringify({
+                type: 'response_item',
+                timestamp: toIsoTime(message.timestamp, '') || new Date(now + i).toISOString(),
+                payload: { type: 'message', role, content: text }
+            }));
+        }
+    } else {
+        const claudeIndexPath = target === 'claude' ? path.join(outputDir, 'sessions-index.json') : '';
+        for (let i = 0; i < messages.length; i += 1) {
+            const message = messages[i];
+            if (!message) continue;
+            const role = normalizeRole(message.role);
+            if (role !== 'user' && role !== 'assistant' && role !== 'system') continue;
+            const text = typeof message.text === 'string' ? message.text : '';
+            if (!text) continue;
+            lines.push(JSON.stringify({
+                type: role,
+                timestamp: toIsoTime(message.timestamp, '') || new Date(now + i).toISOString(),
+                sessionId: derivedSessionId,
+                cwd,
+                message: { content: text }
+            }));
+        }
+        if (claudeIndexPath) {
+            ensureClaudeSessionsIndex(claudeIndexPath, resolvedCwd);
+        }
+    }
+
+    fs.writeFileSync(outputPath, `${lines.join('\n')}\n`, 'utf-8');
+    writeJsonAtomic(metaPath, {
+        version: 1,
+        createdAt: baseTime,
+        source: {
+            type: source,
+            sessionId: baseSessionId,
+            filePath
+        },
+        target: {
+            type: target,
+            sessionId: derivedSessionId,
+            filePath: outputPath
+        },
+        options: {
+            maxMessages: maxMessages === Infinity ? 'all' : maxMessages
+        }
+    });
+
+    invalidateSessionListCache();
+
+    const summary = target === 'codex'
+        ? parseCodexSessionSummary(outputPath, { summaryReadBytes: SESSION_BROWSE_SUMMARY_READ_BYTES, titleReadBytes: SESSION_BROWSE_SUMMARY_READ_BYTES })
+        : parseClaudeSessionSummary(outputPath, { summaryReadBytes: SESSION_BROWSE_SUMMARY_READ_BYTES, titleReadBytes: SESSION_BROWSE_SUMMARY_READ_BYTES });
+    if (target === 'claude' && summary) {
+        const indexPath = path.join(outputDir, 'sessions-index.json');
+        ensureClaudeSessionsIndex(indexPath, resolvedCwd);
+        upsertClaudeSessionIndexEntry(indexPath, outputPath, {
+            source: 'claude',
+            trashId: summary.sessionId,
+            trashFileName: `${summary.sessionId}.jsonl`,
+            sessionId: summary.sessionId,
+            title: summary.title,
+            cwd: summary.cwd,
+            createdAt: summary.createdAt,
+            updatedAt: summary.updatedAt,
+            messageCount: summary.messageCount,
+            provider: summary.provider,
+            keywords: summary.keywords,
+            capabilities: summary.capabilities,
+            claudeIndexEntry: resolvedCwd ? { projectPath: resolvedCwd } : null
+        });
+    }
+    const maxMessagesLabel = maxMessages === Infinity ? 'all' : maxMessages;
+
+    return {
+        derived: true,
+        source,
+        target,
+        truncated: !!extracted.truncated,
+        maxMessages: maxMessagesLabel,
+        session: summary ? { ...summary, derived: true } : {
+            source: target,
+            sourceLabel: target === 'codex' ? 'Codex' : 'Claude Code',
+            sessionId: derivedSessionId,
+            title: derivedSessionId,
+            cwd,
+            createdAt: baseTime,
+            updatedAt: baseTime,
+            messageCount: messages.length,
+            totalTokens: 0,
+            contextWindow: 0,
+            inputTokens: 0,
+            cachedInputTokens: 0,
+            outputTokens: 0,
+            reasoningOutputTokens: 0,
+            __messageCountExact: true,
+            filePath: outputPath,
+            derived: true,
+            keywords: [],
+            capabilities: {}
+        }
+    };
+}
+
 function buildExportPayload(includeKeys) {
     const { config } = readConfigOrVirtualDefault();
     const providers = config.model_providers || {};
@@ -8294,17 +8786,32 @@ function probeCliBinary(binName) {
     let lastError = '';
 
     for (const args of attempts) {
-        const argString = args.join(' ').trim();
-        const commandLine = argString ? `${binName} ${argString}` : binName;
         try {
-            const stdout = execSync(commandLine, {
-                encoding: 'utf8',
-                windowsHide: true,
-                timeout: 5000,
-                stdio: ['ignore', 'pipe', 'pipe'],
-                shell: process.platform === 'win32'
-            });
-            const version = parseBinaryVersionOutput(String(stdout || ''));
+            let output = '';
+            let status = 0;
+            if (process.platform === 'win32') {
+                const argString = args.join(' ').trim();
+                const commandLine = argString ? `${binName} ${argString}` : binName;
+                const stdout = execSync(commandLine, {
+                    encoding: 'utf8',
+                    windowsHide: true,
+                    timeout: 5000,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    shell: true
+                });
+                output = String(stdout || '');
+            } else {
+                const cmd = resolveSpawnCommand(binName);
+                const probe = spawnSync(cmd, args, {
+                    encoding: 'utf8',
+                    windowsHide: true,
+                    timeout: 5000,
+                    stdio: ['ignore', 'pipe', 'pipe']
+                });
+                status = Number.isFinite(probe.status) ? probe.status : (probe.error ? 1 : 0);
+                output = `${probe.stdout || ''}\n${probe.stderr || ''}`.trim();
+            }
+            const version = parseBinaryVersionOutput(output);
             return {
                 installed: true,
                 bin: binName,
@@ -9831,12 +10338,18 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'export-session':
                             result = await exportSessionData(params);
                             break;
+                        case 'convert-session':
+                            result = await convertSessionToDerived(params || {});
+                            break;
                         case 'delete-session':
                             result = await deleteSessionData(params || {});
                             break;
                         case 'clone-session':
                             result = await cloneCodexSession(params || {});
                             break;
+                        case 'session-message-counts':
+                            result = await readSessionMessageCounts(params || {});
+                            break;
                         case 'session-detail':
                             result = await readSessionDetail(params);
                             break;
@@ -14614,6 +15127,7 @@ function printMainHelp() {
     console.log('  codexmate qwen [参数...]   等同于 qwen --yolo');
     console.log('  codexmate mcp [serve] [--transport stdio] [--allow-write|--read-only]');
     console.log('  codexmate export-session --source <codex|claude|gemini|codebuddy> (--session-id <ID>|--file <PATH>) [--output <PATH>] [--max-messages <N|all|Infinity>]');
+    console.log('  codexmate convert-session --from <codex|claude> --to <codex|claude> (--session-id <ID>|--file <PATH>) [--output <PATH>] [--max-messages <N|all|Infinity>]');
     console.log('  codexmate zip <路径> [--max:级别]  压缩（系统 zip 优先，其次 zip-lib）');
     console.log('  codexmate unzip <zip文件> [输出目录]  解压（zip-lib）');
     console.log('  codexmate unzip-ext <zip目录> [输出目录] [--ext:后缀[,后缀...]] [--no-recursive]  批量提取 ZIP 指定后缀文件（默认递归）');
@@ -14712,6 +15226,7 @@ async function main() {
         }
         case 'mcp': await cmdMcp(args.slice(1)); break;
         case 'export-session': await cmdExportSession(args.slice(1)); break;
+        case 'convert-session': await cmdConvertSession(args.slice(1), { resolveSessionFilePath }); break;
         case 'zip': {
             const { targetPath, options } = parseZipCommandArgs(args.slice(1));
             await cmdZip(targetPath, options);