codexmate 0.0.25 → 0.0.27

package/web-ui/modules/app.computed.session.mjs

@@ -1,6 +1,8 @@
 import {
     buildSessionTimelineNodes,
     buildUsageChartGroups,
+    buildUsageHeatmap,
+    buildUsageHourlyHeatmap,
     isSessionQueryEnabled
 } from '../logic.mjs';
 import { SESSION_TRASH_PAGE_SIZE } from './app.constants.mjs';
@@ -56,6 +58,24 @@ function formatUsageEstimatedCost(value, options = {}) {
     }).format(numeric);
 }
 
+function formatSignedUsageSummaryNumber(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric === 0) {
+        return '0';
+    }
+    const sign = numeric > 0 ? '+' : '-';
+    return `${sign}${formatUsageSummaryNumber(Math.abs(numeric))}`;
+}
+
+function formatSignedUsageEstimatedCost(value, options = {}) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric === 0) {
+        return '$0.00';
+    }
+    const sign = numeric > 0 ? '+' : '-';
+    return `${sign}${formatUsageEstimatedCost(Math.abs(numeric), options)}`;
+}
+
 function formatUsageRangeLabel(range, t) {
     const normalized = typeof range === 'string' ? range.trim().toLowerCase() : '7d';
     if (typeof t === 'function') {
@@ -335,9 +355,13 @@ export function createSessionComputed() {
             const pinnedMap = (this.sessionPinnedMap && typeof this.sessionPinnedMap === 'object')
                 ? this.sessionPinnedMap
                 : {};
-            if (Object.keys(pinnedMap).length === 0) {
+            const sortMode = typeof this.sessionSortMode === 'string'
+                ? this.sessionSortMode.trim().toLowerCase()
+                : 'time';
+            if (sortMode !== 'hot' && Object.keys(pinnedMap).length === 0) {
                 return list;
             }
+            const now = Date.now();
             let hasPinned = false;
             const decorated = list.map((session, index) => {
                 const key = session ? this.getSessionExportKey(session) : '';
@@ -349,12 +373,28 @@ export function createSessionComputed() {
                 if (isPinned) {
                     hasPinned = true;
                 }
-                return { session, index, pinnedAt, isPinned };
+                const updatedAtMs = session ? Date.parse(session.updatedAt || '') : NaN;
+                const safeUpdatedAtMs = Number.isFinite(updatedAtMs) ? updatedAtMs : 0;
+                const messageCount = session && Number.isFinite(Number(session.messageCount))
+                    ? Math.max(0, Math.floor(Number(session.messageCount)))
+                    : 0;
+                const totalTokens = session && Number.isFinite(Number(session.totalTokens))
+                    ? Math.max(0, Math.floor(Number(session.totalTokens)))
+                    : 0;
+                const ageHours = safeUpdatedAtMs > 0 ? Math.max(0, (now - safeUpdatedAtMs) / 3600000) : 1e9;
+                const activity = Math.sqrt(Math.max(1, totalTokens || (messageCount * 120)));
+                const hotScore = activity / (1 + (ageHours / 24));
+                return { session, index, pinnedAt, isPinned, safeUpdatedAtMs, hotScore };
             });
-            if (!hasPinned) return list;
+            if (!hasPinned && sortMode !== 'hot') {
+                return list;
+            }
             decorated.sort((a, b) => {
                 if (a.isPinned !== b.isPinned) return a.isPinned ? -1 : 1;
                 if (a.isPinned && a.pinnedAt !== b.pinnedAt) return b.pinnedAt - a.pinnedAt;
+                if (sortMode === 'hot') {
+                    if (a.hotScore !== b.hotScore) return b.hotScore - a.hotScore;
+                }
                 return a.index - b.index;
             });
             return decorated.map(item => item.session);
@@ -456,6 +496,138 @@ export function createSessionComputed() {
                 range: this.sessionsUsageTimeRange
             });
         },
+        sessionUsageHeatmap() {
+            const sessions = this.sessionUsageCharts && Array.isArray(this.sessionUsageCharts.filteredSessions)
+                ? this.sessionUsageCharts.filteredSessions
+                : this.sessionsUsageList;
+            const heatmap = buildUsageHeatmap(sessions, { range: this.sessionsUsageTimeRange });
+            const t = typeof this.t === 'function' ? this.t : null;
+            const lang = typeof this.lang === 'string' ? this.lang.trim().toLowerCase() : '';
+            const weekdayAxis = lang === 'en'
+                ? ['Mon', '', 'Wed', '', 'Fri', '', '']
+                : ['周一', '', '周三', '', '周五', '', ''];
+            const months = lang === 'en'
+                ? ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+                : ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'];
+            const windowWeeks = 52;
+            const allWeeks = Array.isArray(heatmap.weeks) ? heatmap.weeks : [];
+            const safeWindowWeeks = Math.max(1, Math.min(windowWeeks, allWeeks.length));
+            const startIndex = Math.max(0, allWeeks.length - safeWindowWeeks);
+            const displayWeeksRaw = allWeeks.slice(startIndex);
+            let max = 0;
+            for (const week of displayWeeksRaw) {
+                const days = Array.isArray(week.days) ? week.days : [];
+                for (const cell of days) {
+                    if (cell && cell.isInRange) {
+                        max = Math.max(max, cell.sessionCount || 0);
+                    }
+                }
+            }
+            max = Math.max(1, max);
+            const dayMs = 24 * 60 * 60 * 1000;
+            let lastMonth = -1;
+            const weeks = displayWeeksRaw.map((week) => {
+                const idx = Number.isFinite(Number(week.weekIndex)) ? Number(week.weekIndex) : 0;
+                const weekStartMs = (Number.isFinite(Number(heatmap.alignedStart)) ? Number(heatmap.alignedStart) : 0) + (idx * 7 * dayMs);
+                const month = Number.isFinite(weekStartMs) ? new Date(weekStartMs).getUTCMonth() : -1;
+                const monthLabel = (month >= 0 && month <= 11 && month !== lastMonth) ? months[month] : '';
+                if (month >= 0 && month <= 11) {
+                    lastMonth = month;
+                }
+                return {
+                    ...week,
+                    monthLabel,
+                    days: (Array.isArray(week.days) ? week.days : []).map((cell) => {
+                    if (!cell) return null;
+                    if (!cell.isInRange) {
+                        return {
+                            ...cell,
+                            level: -1,
+                            title: '',
+                            ariaLabel: ''
+                        };
+                    }
+                    const ratio = cell.sessionCount > 0 ? (cell.sessionCount / max) : 0;
+                    const level = cell.sessionCount <= 0
+                        ? 0
+                        : (ratio <= 0.25 ? 1 : (ratio <= 0.5 ? 2 : (ratio <= 0.75 ? 3 : 4)));
+                    const tokensTitle = formatUsageSummaryNumber(cell.tokenTotal || 0);
+                    const title = t
+                        ? t('usage.heatmap.tooltip', {
+                            date: cell.dateKey,
+                            sessions: cell.sessionCount,
+                            messages: cell.messageCount,
+                            tokens: tokensTitle
+                        })
+                        : `${cell.dateKey} · sessions ${cell.sessionCount} · messages ${cell.messageCount} · tokens ${tokensTitle}`;
+                    const ariaLabel = t
+                        ? t('usage.heatmap.aria', {
+                            date: cell.dateKey,
+                            sessions: cell.sessionCount
+                        })
+                        : `${cell.dateKey} sessions ${cell.sessionCount}`;
+                    return {
+                        ...cell,
+                        level,
+                        title,
+                        ariaLabel
+                    };
+                })
+                };
+            });
+            return {
+                ...heatmap,
+                weeks,
+                weekdayAxis
+            };
+        },
+        sessionUsageHourlyHeatmap() {
+            const sessions = this.sessionUsageCharts && Array.isArray(this.sessionUsageCharts.filteredSessions)
+                ? this.sessionUsageCharts.filteredSessions
+                : this.sessionsUsageList;
+            const result = buildUsageHourlyHeatmap(sessions, { range: this.sessionsUsageTimeRange });
+            const t = typeof this.t === 'function' ? this.t : null;
+            const lang = typeof this.lang === 'string' ? this.lang.trim().toLowerCase() : '';
+            const weekdayLabelsZh = ['周一', '周二', '周三', '周四', '周五', '周六', '周日'];
+            const weekdayLabelsEn = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+            const weekdayLabels = lang === 'en' ? weekdayLabelsEn : weekdayLabelsZh;
+            const max = Math.max(1, result.maxSessionCount);
+            const grid = Array.isArray(result.grid) ? result.grid : [];
+            const rows = grid.map((cells, dayIndex) => ({
+                weekday: weekdayLabels[dayIndex] || '',
+                cells: cells.map((cell, hourIndex) => {
+                    const ratio = cell.sessionCount > 0 ? (cell.sessionCount / max) : 0;
+                    const level = cell.sessionCount <= 0
+                        ? 0
+                        : (ratio <= 0.25 ? 1 : (ratio <= 0.5 ? 2 : (ratio <= 0.75 ? 3 : 4)));
+                    const hourLabel = String(hourIndex).padStart(2, '0');
+                    const tooltipText = t
+                        ? t('usage.hourlyHeatmap.tooltip', {
+                            weekday: weekdayLabels[dayIndex],
+                            hour: hourLabel,
+                            sessions: cell.sessionCount,
+                            messages: cell.messageCount,
+                            tokens: (cell.tokenTotal || 0).toLocaleString('en-US')
+                        })
+                        : `${weekdayLabels[dayIndex] || ''} ${hourLabel}:00 · ${cell.sessionCount} sessions · ${cell.messageCount} messages · ${(cell.tokenTotal || 0).toLocaleString('en-US')} tokens`;
+                    return {
+                        hour: hourIndex,
+                        hourLabel,
+                        sessionCount: cell.sessionCount,
+                        messageCount: cell.messageCount,
+                        tokenTotal: cell.tokenTotal,
+                        level,
+                        tooltip: tooltipText
+                    };
+                })
+            }));
+            return {
+                range: result.range,
+                rows,
+                hourLabels: result.hourLabels,
+                maxSessionCount: result.maxSessionCount
+            };
+        },
         sessionUsageSummaryCards() {
             const summary = this.sessionUsageCharts && this.sessionUsageCharts.summary
                 ? this.sessionUsageCharts.summary
@@ -570,10 +742,15 @@ export function createSessionComputed() {
             const baseBuckets = this.sessionUsageCharts && Array.isArray(this.sessionUsageCharts.buckets)
                 ? this.sessionUsageCharts.buckets
                 : [];
-            const sessions = this.sessionUsageCharts && Array.isArray(this.sessionUsageCharts.filteredSessions)
-                ? this.sessionUsageCharts.filteredSessions
-                : this.sessionsUsageList;
             const pricingIndex = buildUsagePricingIndex(this.providersList);
+            const compareEnabled = this.sessionsUsageCompareEnabled === true && this.sessionsUsageTimeRange !== 'all';
+            const sessions = compareEnabled
+                ? this.sessionsUsageList
+                : (this.sessionUsageCharts && Array.isArray(this.sessionUsageCharts.filteredSessions)
+                    ? this.sessionUsageCharts.filteredSessions
+                    : this.sessionsUsageList);
+            const rangeDays = this.sessionsUsageTimeRange === '30d' ? 30 : 7;
+            const dayMs = 24 * 60 * 60 * 1000;
             const byDay = new Map();
 
             for (const bucket of baseBuckets) {
@@ -588,6 +765,24 @@ export function createSessionComputed() {
                     estimatedSessions: 0,
                     hasCostEstimate: false
                 });
+                if (compareEnabled) {
+                    const baseMs = Date.parse(`${bucket.key}T00:00:00.000Z`);
+                    if (Number.isFinite(baseMs)) {
+                        const prevKey = new Date(baseMs - (rangeDays * dayMs)).toISOString().slice(0, 10);
+                        if (!byDay.has(prevKey)) {
+                            byDay.set(prevKey, {
+                                key: prevKey,
+                                label: prevKey.slice(5),
+                                sessionCount: 0,
+                                messageCount: 0,
+                                tokenTotal: 0,
+                                estimatedCostUsd: 0,
+                                estimatedSessions: 0,
+                                hasCostEstimate: false
+                            });
+                        }
+                    }
+                }
             }
 
             for (const session of (Array.isArray(sessions) ? sessions : [])) {
@@ -618,20 +813,44 @@ export function createSessionComputed() {
                 }
             }
 
-            // UI 展示：当天在最上面（倒序）。
-            const rows = [...byDay.values()].sort((a, b) => b.key.localeCompare(a.key, 'en-US'));
-            const maxTokens = rows.reduce((max, item) => Math.max(max, item.tokenTotal), 0);
-            const maxCost = rows.reduce((max, item) => Math.max(max, item.estimatedCostUsd), 0);
+            const currentKeys = baseBuckets.map((bucket) => bucket && bucket.key).filter(Boolean);
+            const rows = currentKeys
+                .map((key) => byDay.get(key))
+                .filter(Boolean)
+                .sort((a, b) => b.key.localeCompare(a.key, 'en-US'));
+            const rowsWithCompare = rows.map((row) => {
+                if (!compareEnabled) {
+                    return { ...row, compareEnabled: false, prevKey: '', prevTokenTotal: 0, prevCostUsd: 0 };
+                }
+                const baseMs = Date.parse(`${row.key}T00:00:00.000Z`);
+                const prevKey = Number.isFinite(baseMs)
+                    ? new Date(baseMs - (rangeDays * dayMs)).toISOString().slice(0, 10)
+                    : '';
+                const prevRow = prevKey ? byDay.get(prevKey) : null;
+                return {
+                    ...row,
+                    compareEnabled: true,
+                    prevKey,
+                    prevTokenTotal: prevRow ? prevRow.tokenTotal : 0,
+                    prevCostUsd: prevRow ? prevRow.estimatedCostUsd : 0
+                };
+            });
+            const maxTokens = rowsWithCompare.reduce((max, item) => Math.max(max, item.tokenTotal, item.prevTokenTotal || 0), 0);
+            const maxCost = rowsWithCompare.reduce((max, item) => Math.max(max, item.estimatedCostUsd, item.prevCostUsd || 0), 0);
 
             return {
-                rows: rows.map((row) => ({
+                rows: rowsWithCompare.map((row) => ({
                     ...row,
                     tokenLabel: formatCompactUsageSummaryNumber(row.tokenTotal),
                     tokenTitle: formatUsageSummaryNumber(row.tokenTotal),
                     tokenPercent: maxTokens > 0 ? Math.round((row.tokenTotal / maxTokens) * 1000) / 10 : 0,
+                    prevTokenPercent: row.compareEnabled && maxTokens > 0 ? Math.round(((row.prevTokenTotal || 0) / maxTokens) * 1000) / 10 : 0,
+                    prevTokenTitle: row.compareEnabled ? formatUsageSummaryNumber(row.prevTokenTotal || 0) : '',
                     costLabel: row.hasCostEstimate ? formatUsageEstimatedCost(row.estimatedCostUsd) : '0',
                     costTitle: row.hasCostEstimate ? formatUsageEstimatedCost(row.estimatedCostUsd, { precise: true }) : '0',
-                    costPercent: maxCost > 0 ? Math.round((row.estimatedCostUsd / maxCost) * 1000) / 10 : 0
+                    costPercent: maxCost > 0 ? Math.round((row.estimatedCostUsd / maxCost) * 1000) / 10 : 0,
+                    prevCostPercent: row.compareEnabled && maxCost > 0 ? Math.round(((row.prevCostUsd || 0) / maxCost) * 1000) / 10 : 0,
+                    prevCostTitle: row.compareEnabled ? formatUsageEstimatedCost(row.prevCostUsd || 0, { precise: true }) : ''
                 })),
                 maxTokens,
                 maxCost
@@ -645,6 +864,111 @@ export function createSessionComputed() {
             return daily && Array.isArray(daily.rows) ? daily.rows : [];
         },
 
+        sessionsUsageSelectedDaySummary() {
+            const dayKey = typeof this.sessionsUsageSelectedDayKey === 'string' ? this.sessionsUsageSelectedDayKey.trim() : '';
+            if (!dayKey) return null;
+            const sessions = this.sessionUsageCharts && Array.isArray(this.sessionUsageCharts.filteredSessions)
+                ? this.sessionUsageCharts.filteredSessions
+                : this.sessionsUsageList;
+            const pricingIndex = buildUsagePricingIndex(this.providersList);
+            const compareEnabled = this.sessionsUsageCompareEnabled === true && this.sessionsUsageTimeRange !== 'all';
+            const rangeDays = this.sessionsUsageTimeRange === '30d' ? 30 : 7;
+            const dayMs = 24 * 60 * 60 * 1000;
+            const baseMs = Date.parse(`${dayKey}T00:00:00.000Z`);
+            const prevKey = compareEnabled && Number.isFinite(baseMs)
+                ? new Date(baseMs - (rangeDays * dayMs)).toISOString().slice(0, 10)
+                : '';
+            let sessionCount = 0;
+            let messageCount = 0;
+            let tokenTotal = 0;
+            let estimatedCostUsd = 0;
+            let hasCostEstimate = false;
+            let prevTokenTotal = 0;
+            let prevEstimatedCostUsd = 0;
+            let prevHasCostEstimate = false;
+            const modelMap = new Map();
+            const sessionRows = [];
+            for (const session of (Array.isArray(sessions) ? sessions : [])) {
+                if (!session || typeof session !== 'object') continue;
+                const updatedAtMs = Date.parse(session.updatedAt || '');
+                if (!Number.isFinite(updatedAtMs)) continue;
+                const key = new Date(updatedAtMs).toISOString().slice(0, 10);
+                const isCurrent = key === dayKey;
+                const isPrev = !!prevKey && key === prevKey;
+                if (!isCurrent && !isPrev) continue;
+                const msgCount = Number.isFinite(Number(session.messageCount))
+                    ? Math.max(0, Math.floor(Number(session.messageCount)))
+                    : 0;
+                const sessionTokens = Number.isFinite(Number(session.totalTokens))
+                    ? Math.max(0, Math.floor(Number(session.totalTokens)))
+                    : 0;
+                if (isCurrent) {
+                    sessionCount += 1;
+                    messageCount += msgCount;
+                    tokenTotal += sessionTokens;
+                } else if (isPrev) {
+                    prevTokenTotal += sessionTokens;
+                }
+                if (shouldEstimateUsageCostForSession(session)) {
+                    const cost = estimateUsageCostForSession(session, pricingIndex, this.currentProvider);
+                    if (cost.pricing && cost.hasTokenBreakdown) {
+                        if (isCurrent) {
+                            estimatedCostUsd += cost.estimatedUsd;
+                            hasCostEstimate = true;
+                        } else if (isPrev) {
+                            prevEstimatedCostUsd += cost.estimatedUsd;
+                            prevHasCostEstimate = true;
+                        }
+                    }
+                }
+                const model = typeof session.model === 'string' ? session.model.trim() : '';
+                if (isCurrent && model) {
+                    modelMap.set(model, (modelMap.get(model) || 0) + 1);
+                }
+                const title = typeof session.title === 'string' && session.title.trim()
+                    ? session.title.trim()
+                    : (typeof session.sessionId === 'string' && session.sessionId.trim() ? session.sessionId.trim() : '未命名会话');
+                if (isCurrent) {
+                    sessionRows.push({
+                        key: this.getSessionExportKey(session) || `${title}:${sessionCount}`,
+                        title,
+                        messageCount: msgCount
+                    });
+                }
+            }
+            sessionRows.sort((a, b) => b.messageCount - a.messageCount);
+            const lang = typeof this.lang === 'string' ? this.lang.trim().toLowerCase() : '';
+            const suffix = lang === 'en' ? 'msgs' : '条';
+            const topSessions = sessionRows.slice(0, 8).map((item) => ({
+                ...item,
+                messageCountLabel: `${item.messageCount} ${suffix}`
+            }));
+            const topModels = [...modelMap.entries()]
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 6)
+                .map(([model, count]) => ({
+                    key: model,
+                    label: `${model} · ${count}`
+                }));
+            return {
+                dayKey,
+                compareEnabled,
+                prevKey,
+                sessionCount,
+                messageCount,
+                tokenTotal,
+                tokenLabel: formatUsageSummaryNumber(tokenTotal),
+                costLabel: hasCostEstimate ? formatUsageEstimatedCost(estimatedCostUsd) : '0',
+                prevTokenTotal,
+                prevTokenLabel: compareEnabled ? formatUsageSummaryNumber(prevTokenTotal) : '0',
+                deltaTokenLabel: compareEnabled ? formatSignedUsageSummaryNumber(tokenTotal - prevTokenTotal) : '0',
+                prevCostLabel: compareEnabled ? (prevHasCostEstimate ? formatUsageEstimatedCost(prevEstimatedCostUsd) : '0') : '0',
+                deltaCostLabel: compareEnabled ? formatSignedUsageEstimatedCost(estimatedCostUsd - prevEstimatedCostUsd, { precise: true }) : '0',
+                topSessions,
+                topModels
+            };
+        },
+
         visibleSessionTrashItems() {
             const items = Array.isArray(this.sessionTrashItems) ? this.sessionTrashItems : [];
             const visibleCount = Number(this.sessionTrashVisibleCount);

package/web-ui/modules/app.methods.claude-config.mjs

@@ -4,6 +4,7 @@ export function createClaudeConfigMethods(options = {}) {
     return {
         switchClaudeConfig(name) {
             this.currentClaudeConfig = name;
+            try { localStorage.setItem('currentClaudeConfig', name || ''); } catch (_) {}
             this.refreshClaudeModelContext();
         },
 
@@ -20,6 +21,7 @@ export function createClaudeConfigMethods(options = {}) {
             }
             const existing = this.claudeConfigs[name] || {};
             this.currentClaudeModel = model;
+            this.claudeCustomModelDraft = model;
             this.claudeConfigs[name] = this.mergeClaudeConfig(existing, { model });
             this.saveClaudeConfigs();
             this.updateClaudeModelsCurrent();
@@ -30,8 +32,15 @@ export function createClaudeConfigMethods(options = {}) {
             this.applyClaudeConfig(name);
         },
 
+        onClaudeCustomModelSubmit() {
+            this.onClaudeModelChange();
+        },
+
         saveClaudeConfigs() {
-            localStorage.setItem('claudeConfigs', JSON.stringify(this.claudeConfigs));
+            try { localStorage.setItem('claudeConfigs', JSON.stringify(this.claudeConfigs)); } catch (_) {}
+            if (this.currentClaudeConfig) {
+                try { localStorage.setItem('currentClaudeConfig', this.currentClaudeConfig); } catch (_) {}
+            }
         },
 
         openEditConfigModal(name) {
@@ -138,6 +147,7 @@ export function createClaudeConfigMethods(options = {}) {
 
         async applyClaudeConfig(name) {
             this.currentClaudeConfig = name;
+            try { localStorage.setItem('currentClaudeConfig', name || ''); } catch (_) {}
             this.refreshClaudeModelContext();
             const config = this.claudeConfigs[name];
 

package/web-ui/modules/app.methods.codex-config.mjs

@@ -1,5 +1,10 @@
 import { runLatestOnlyQueue } from '../logic.mjs';
 import { normalizeConfigTemplateDiffConfirmEnabled } from './config-template-confirm-pref.mjs';
+import {
+    getConvertTargetSource,
+    normalizeSessionConvertSource
+} from '../logic.session-convert.mjs';
+import { syncSessionsFilterUrl } from './sessions-filters-url.mjs';
 
 function hasResponseError(response) {
     if (!response || typeof response !== 'object') {
@@ -75,6 +80,77 @@ export function createCodexConfigMethods(options = {}) {
             }
         },
 
+        async convertSession(session) {
+            const source = normalizeSessionConvertSource(session && session.source ? session.source : '');
+            const target = getConvertTargetSource(source);
+            if (!source || !target) {
+                this.showMessage('不支持此操作', 'error');
+                return;
+            }
+            const key = this.getSessionExportKey(session);
+            if (this.sessionConverting[key]) return;
+            this.sessionConverting[key] = true;
+            try {
+                const res = await api('convert-session', {
+                    source,
+                    target,
+                    sessionId: session.sessionId,
+                    filePath: session.filePath,
+                    maxMessages: 'all'
+                });
+                if (res && res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                const converted = res && res.session ? res.session : null;
+                if (!converted) {
+                    this.showMessage('转换失败', 'error');
+                    return;
+                }
+                if (res && res.truncated) {
+                    const maxLabel = res.maxMessages === 'all' ? 'all' : res.maxMessages;
+                    const targetLabel = converted && converted.sourceLabel ? String(converted.sourceLabel).trim() : '';
+                    if (targetLabel && typeof this.sessionFilterSource === 'string' && this.sessionFilterSource !== converted.source) {
+                        this.showMessage(`已生成派生会话（来源：${targetLabel}，已截断：最多 ${maxLabel} 条消息）`, 'info');
+                    } else {
+                        this.showMessage(`已生成派生会话（已截断：最多 ${maxLabel} 条消息）`, 'info');
+                    }
+                } else {
+                    const targetLabel = converted && converted.sourceLabel ? String(converted.sourceLabel).trim() : '';
+                    if (targetLabel && typeof this.sessionFilterSource === 'string' && this.sessionFilterSource !== converted.source) {
+                        this.showMessage(`已生成派生会话（来源：${targetLabel}）`, 'success');
+                    } else {
+                        this.showMessage('已生成派生会话', 'success');
+                    }
+                }
+
+                if (converted && converted.source && typeof this.sessionFilterSource === 'string') {
+                    if (this.sessionFilterSource !== converted.source) {
+                        this.sessionFilterSource = converted.source;
+                        if (typeof this.refreshSessionPathOptions === 'function') {
+                            this.refreshSessionPathOptions(this.sessionFilterSource);
+                        }
+                        if (typeof this.persistSessionFilterCache === 'function') {
+                            this.persistSessionFilterCache();
+                        }
+                        syncSessionsFilterUrl(this);
+                        this.sessionsList = [converted];
+                    } else {
+                        const list = Array.isArray(this.sessionsList) ? this.sessionsList : [];
+                        const next = [converted, ...list.filter(item => !(item && item.filePath === converted.filePath && item.source === converted.source))];
+                        this.sessionsList = next;
+                    }
+                }
+                if (typeof this.selectSession === 'function') {
+                    await this.selectSession(converted);
+                }
+            } catch (e) {
+                this.showMessage('转换失败', 'error');
+            } finally {
+                this.sessionConverting[key] = false;
+            }
+        },
+
         async quickSwitchProvider(name) {
             const target = String(name || '').trim();
             const visualTarget = String(this.providerSwitchDisplayTarget || '').trim();

package/web-ui/modules/app.methods.navigation.mjs

@@ -55,11 +55,18 @@ export function createNavigationMethods(options = {}) {
             return null;
         }
     };
-    const persistNavState = (vm) => {
+    const persistNavState = (vm, overrides = null) => {
         if (!vm || vm.__navStateRestoring) return;
         if (typeof localStorage === 'undefined') return;
-        const mainTab = typeof vm.mainTab === 'string' ? vm.mainTab.trim().toLowerCase() : '';
-        const configMode = typeof vm.configMode === 'string' ? vm.configMode.trim().toLowerCase() : '';
+        const resolvedOverrides = overrides && typeof overrides === 'object' ? overrides : null;
+        const mainTabSource = resolvedOverrides && typeof resolvedOverrides.mainTab === 'string'
+            ? resolvedOverrides.mainTab
+            : vm.mainTab;
+        const configModeSource = resolvedOverrides && typeof resolvedOverrides.configMode === 'string'
+            ? resolvedOverrides.configMode
+            : vm.configMode;
+        const mainTab = typeof mainTabSource === 'string' ? mainTabSource.trim().toLowerCase() : '';
+        const configMode = typeof configModeSource === 'string' ? configModeSource.trim().toLowerCase() : '';
         const snapshot = {
             mainTab: MAIN_TAB_SET.has(mainTab) ? mainTab : 'dashboard',
             configMode: configModeSet && configModeSet.has(configMode) ? configMode : 'codex'
@@ -70,6 +77,34 @@ export function createNavigationMethods(options = {}) {
     };
 
     return {
+        restoreNavStateFromStorage() {
+            if (this.__navStateRestoring) return false;
+            const restored = readNavState();
+            if (!restored) return false;
+            const nextMainTab = restored && typeof restored.mainTab === 'string'
+                ? restored.mainTab.trim().toLowerCase()
+                : '';
+            const nextConfigMode = restored && typeof restored.configMode === 'string'
+                ? restored.configMode.trim().toLowerCase()
+                : '';
+            const shouldUpdateConfigMode = !!(nextConfigMode && configModeSet && configModeSet.has(nextConfigMode));
+            const shouldUpdateMainTab = !!(nextMainTab && MAIN_TAB_SET.has(nextMainTab) && nextMainTab !== this.mainTab);
+            if (!shouldUpdateConfigMode && !shouldUpdateMainTab) {
+                return false;
+            }
+            this.__navStateRestoring = true;
+            try {
+                if (shouldUpdateConfigMode) {
+                    this.configMode = nextConfigMode;
+                }
+                if (shouldUpdateMainTab) {
+                    this.switchMainTab(nextMainTab);
+                }
+            } finally {
+                this.__navStateRestoring = false;
+            }
+            return true;
+        },
         switchConfigMode(mode) {
             const normalizedMode = typeof mode === 'string'
                 ? mode.trim().toLowerCase()
@@ -101,6 +136,10 @@ export function createNavigationMethods(options = {}) {
                 persistNavState(this);
                 return;
             }
+            persistNavState(this, {
+                mainTab: 'config',
+                configMode: normalizedMode
+            });
             this.switchMainTab('config');
         },
 
@@ -254,6 +293,7 @@ export function createNavigationMethods(options = {}) {
             }
             const normalizedTab = typeof tab === 'string' ? tab.trim().toLowerCase() : '';
             if (!normalizedTab) return;
+            persistNavState(this, { mainTab: normalizedTab });
             this.setMainTabSwitchIntent(normalizedTab);
             this.applyImmediateNavIntent(normalizedTab);
             const shouldHideSessionPanel = this.mainTab === 'sessions' && normalizedTab !== 'sessions';
@@ -275,6 +315,7 @@ export function createNavigationMethods(options = {}) {
             }
             const normalizedMode = typeof mode === 'string' ? mode.trim().toLowerCase() : '';
             if (!normalizedMode) return;
+            persistNavState(this, { mainTab: 'config', configMode: normalizedMode });
             this.setMainTabSwitchIntent('config');
             if (typeof this.ensureMainTabSwitchState === 'function') {
                 this.ensureMainTabSwitchState().pendingConfigMode = normalizedMode;
@@ -345,6 +386,10 @@ export function createNavigationMethods(options = {}) {
             if (targetTab === 'orchestration' && this.taskOrchestrationTabEnabled !== true) {
                 return this.switchMainTab('config');
             }
+            persistNavState(this, {
+                mainTab: targetTab,
+                configMode: targetTab === 'config' ? this.configMode : this.configMode
+            });
             this.cancelTouchNavIntentReset();
             if (targetTab === 'sessions') {
                 this.cancelScheduledSessionTabDeferredTeardown();
@@ -583,6 +628,9 @@ export function createNavigationMethods(options = {}) {
                 this.__sessionListRef = nextRef;
             }
             this.scheduleSessionListViewportFill();
+            if (typeof this.scheduleSessionListMessageCountHydrate === 'function') {
+                this.scheduleSessionListMessageCountHydrate();
+            }
         },
 
         resetSessionPreviewMessageRender() {