coding-tool-x 3.7.3 → 3.7.5

package/src/server/api/dashboard.js

@@ -5,30 +5,119 @@ const { loadConfig } = require('../../config/loader');
 // Services
 const { loadUIConfig } = require('../services/ui-config');
 const { loadFavorites } = require('../services/favorites');
-const { getAllChannels } = require('../services/channels');
 const { getProxyStatus } = require('../proxy-server');
 const { getCodexProxyStatus } = require('../codex-proxy-server');
 const { getGeminiProxyStatus } = require('../gemini-proxy-server');
 const { getOpenCodeProxyStatus } = require('../opencode-proxy-server');
 const { getOmpProxyStatus } = require('../omp-proxy-server');
-const { getProjectAndSessionCounts: getClaudeCounts } = require('../services/sessions');
-const { getProjectAndSessionCounts: getCodexCounts } = require('../services/codex-sessions');
-const { getProjectAndSessionCounts: getGeminiCounts } = require('../services/gemini-sessions');
-const { getProjectAndSessionCounts: getOpenCodeCounts } = require('../services/opencode-sessions');
-const { getProjectAndSessionCounts: getOmpCounts } = require('../services/omp-sessions');
-
-// Channel-specific services
-const { getChannels: getCodexChannels } = require('../services/codex-channels');
-const { getChannels: getGeminiChannels } = require('../services/gemini-channels');
-const { getChannels: getOpenCodeChannels } = require('../services/opencode-channels');
-const { getChannels: getOmpChannels } = require('../services/omp-channels');
-
-// Statistics
-const { getTodayStatistics: getClaudeTodayStatistics } = require('../services/claude-statistics-service');
-const { getTodayStatistics: getCodexTodayStatistics } = require('../services/codex-statistics-service');
-const { getTodayStatistics: getGeminiTodayStatistics } = require('../services/gemini-statistics-service');
-const { getTodayStatistics: getOpenCodeTodayStatistics } = require('../services/opencode-statistics-service');
-const { getTodayStatistics: getOmpTodayStatistics } = require('../services/omp-statistics-service');
+const { getSnapshot } = require('../services/snapshot-cache');
+const { projectCountKey } = require('../services/project-snapshots');
+const { runDashboardSnapshotWorker } = require('../services/dashboard-snapshot-worker');
+
+const SNAPSHOT_TTL_MS = 60 * 1000;
+const DASHBOARD_SNAPSHOT_DEFER_MS = 0;
+const EMPTY_COUNTS = { projectCount: 0, sessionCount: 0 };
+const EMPTY_STATS = { requests: 0, tokens: 0, cost: 0, byModel: {}, byChannel: {} };
+
+function safeRead(label, reader, fallback) {
+  try {
+    return reader();
+  } catch (error) {
+    console.warn(`[Dashboard] ${label} failed:`, error.message);
+    return fallback;
+  }
+}
+
+function channelSnapshotKey(source) {
+  return `dashboard:channels:${source}`;
+}
+
+function todayStatsSnapshotKey(source) {
+  return `dashboard:today-stats:${source}`;
+}
+
+function normalizeChannelTokens(tokens) {
+  if (tokens && typeof tokens === 'object') {
+    return Number(tokens.total ?? tokens.input ?? 0) || 0;
+  }
+  return Number(tokens) || 0;
+}
+
+function normalizeByChannel(byChannel = {}) {
+  if (!byChannel || typeof byChannel !== 'object') {
+    return {};
+  }
+
+  return Object.fromEntries(Object.entries(byChannel).map(([channelId, item = {}]) => [
+    channelId,
+    {
+      ...item,
+      requests: Number(item.requests) || 0,
+      tokens: normalizeChannelTokens(item.tokens),
+      cost: Number(item.cost) || 0
+    }
+  ]));
+}
+
+// 格式化统计数据：取 summary、byModel 和 byChannel 中的数据
+function formatStats(stats) {
+  if (stats && stats.summary) {
+    return {
+      requests: stats.summary.requests || 0,
+      tokens: normalizeChannelTokens(stats.summary.tokens),
+      cost: stats.summary.cost || 0,
+      byModel: stats.byModel || {},
+      byChannel: normalizeByChannel(stats.byChannel || {})
+    };
+  }
+  return { ...EMPTY_STATS };
+}
+
+async function readDashboardSnapshot(kind, source, key, fallbackValue, config = {}, options = {}) {
+  const force = options.force === true;
+  return getSnapshot(key, {
+    ttlMs: SNAPSHOT_TTL_MS,
+    fallbackValue,
+    force,
+    staleWhileForce: force,
+    deferMs: DASHBOARD_SNAPSHOT_DEFER_MS,
+    refresh: () => runDashboardSnapshotWorker(kind, source, config, { force })
+  });
+}
+
+function summarizePart(partSnapshots = {}) {
+  const items = {};
+  let stale = false;
+  let refreshing = false;
+  let generatedAt = null;
+
+  Object.entries(partSnapshots).forEach(([source, snapshot]) => {
+    const meta = snapshot.meta || {};
+    items[source] = meta;
+    stale = stale || Boolean(meta.stale);
+    refreshing = refreshing || Boolean(meta.refreshing);
+    if (meta.generatedAt && (!generatedAt || meta.generatedAt > generatedAt)) {
+      generatedAt = meta.generatedAt;
+    }
+  });
+
+  return {
+    generatedAt,
+    stale,
+    refreshing,
+    items
+  };
+}
+
+function dashboardMeta(parts) {
+  const partValues = Object.values(parts);
+  return {
+    generatedAt: new Date().toISOString(),
+    stale: partValues.some(part => part.stale),
+    refreshing: partValues.some(part => part.refreshing),
+    parts
+  };
+}
 
 /**
  * GET /api/dashboard/init
@@ -37,21 +126,24 @@ const { getTodayStatistics: getOmpTodayStatistics } = require('../services/omp-s
 router.get('/init', async (req, res) => {
   try {
     const config = loadConfig();
+    const force = req.query?.fresh === '1' || req.query?.force === '1';
+
+    const uiConfig = safeRead('uiConfig', () => loadUIConfig(), {});
+    const favorites = safeRead('favorites', () => loadFavorites(), {});
+    const proxyStatus = {
+      claude: safeRead('claude proxy status', () => getProxyStatus(), {}),
+      codex: safeRead('codex proxy status', () => getCodexProxyStatus(), {}),
+      gemini: safeRead('gemini proxy status', () => getGeminiProxyStatus(), {}),
+      opencode: safeRead('opencode proxy status', () => getOpenCodeProxyStatus(), {}),
+      omp: safeRead('omp proxy status', () => getOmpProxyStatus(), {})
+    };
 
-    // 并行获取所有数据
     const [
-      uiConfig,
-      favorites,
       claudeChannels,
       codexChannels,
       geminiChannels,
       opencodeChannels,
       ompChannels,
-      claudeProxyStatus,
-      codexProxyStatus,
-      geminiProxyStatus,
-      opencodeProxyStatus,
-      ompProxyStatus,
       claudeTodayStats,
       codexTodayStats,
       geminiTodayStats,
@@ -63,52 +155,45 @@ router.get('/init', async (req, res) => {
       opencodeCounts,
       ompCounts
     ] = await Promise.all([
-      // UI Config
-      Promise.resolve(loadUIConfig()),
-
-      // Favorites
-      Promise.resolve(loadFavorites()),
-
-      // Channels
-      Promise.resolve(getAllChannels()),
-      Promise.resolve(getCodexChannels()),
-      Promise.resolve(getGeminiChannels()),
-      Promise.resolve(getOpenCodeChannels()),
-      Promise.resolve(getOmpChannels()),
-
-      // Proxy Status
-      Promise.resolve(getProxyStatus()),
-      Promise.resolve(getCodexProxyStatus()),
-      Promise.resolve(getGeminiProxyStatus()),
-      Promise.resolve(getOpenCodeProxyStatus()),
-      Promise.resolve(getOmpProxyStatus()),
-
-      // Today Stats (所有平台)
-      Promise.resolve(getClaudeTodayStatistics()),
-      Promise.resolve(getCodexTodayStatistics()),
-      Promise.resolve(getGeminiTodayStatistics()),
-      Promise.resolve(getOpenCodeTodayStatistics()),
-      Promise.resolve(getOmpTodayStatistics()),
-
-      // 轻量级统计
-      Promise.resolve(getClaudeCounts(config)),
-      Promise.resolve(getCodexCounts()),
-      Promise.resolve(getGeminiCounts()),
-      Promise.resolve(getOpenCodeCounts()),
-      Promise.resolve(getOmpCounts())
+      readDashboardSnapshot('channels', 'claude', channelSnapshotKey('claude'), [], config, { force }),
+      readDashboardSnapshot('channels', 'codex', channelSnapshotKey('codex'), { channels: [] }, config, { force }),
+      readDashboardSnapshot('channels', 'gemini', channelSnapshotKey('gemini'), { channels: [] }, config, { force }),
+      readDashboardSnapshot('channels', 'opencode', channelSnapshotKey('opencode'), { channels: [] }, config, { force }),
+      readDashboardSnapshot('channels', 'omp', channelSnapshotKey('omp'), { channels: [] }, config, { force }),
+      readDashboardSnapshot('todayStats', 'claude', todayStatsSnapshotKey('claude'), null, config, { force }),
+      readDashboardSnapshot('todayStats', 'codex', todayStatsSnapshotKey('codex'), null, config, { force }),
+      readDashboardSnapshot('todayStats', 'gemini', todayStatsSnapshotKey('gemini'), null, config, { force }),
+      readDashboardSnapshot('todayStats', 'opencode', todayStatsSnapshotKey('opencode'), null, config, { force }),
+      readDashboardSnapshot('todayStats', 'omp', todayStatsSnapshotKey('omp'), null, config, { force }),
+      readDashboardSnapshot('counts', 'claude', projectCountKey('claude'), EMPTY_COUNTS, config, { force }),
+      readDashboardSnapshot('counts', 'codex', projectCountKey('codex'), EMPTY_COUNTS, config, { force }),
+      readDashboardSnapshot('counts', 'gemini', projectCountKey('gemini'), EMPTY_COUNTS, config, { force }),
+      readDashboardSnapshot('counts', 'opencode', projectCountKey('opencode'), EMPTY_COUNTS, config, { force }),
+      readDashboardSnapshot('counts', 'omp', projectCountKey('omp'), EMPTY_COUNTS, config, { force })
     ]);
 
-    // 格式化统计数据：取 summary 和 byModel 中的数据
-    const formatStats = (stats) => {
-      if (stats && stats.summary) {
-        return {
-          requests: stats.summary.requests || 0,
-          tokens: stats.summary.tokens || 0,
-          cost: stats.summary.cost || 0,
-          byModel: stats.byModel || {}
-        };
-      }
-      return { requests: 0, tokens: 0, cost: 0, byModel: {} };
+    const parts = {
+      counts: summarizePart({
+        claude: claudeCounts,
+        codex: codexCounts,
+        gemini: geminiCounts,
+        opencode: opencodeCounts,
+        omp: ompCounts
+      }),
+      todayStats: summarizePart({
+        claude: claudeTodayStats,
+        codex: codexTodayStats,
+        gemini: geminiTodayStats,
+        opencode: opencodeTodayStats,
+        omp: ompTodayStats
+      }),
+      channels: summarizePart({
+        claude: claudeChannels,
+        codex: codexChannels,
+        gemini: geminiChannels,
+        opencode: opencodeChannels,
+        omp: ompChannels
+      })
     };
 
     res.json({
@@ -117,33 +202,28 @@ router.get('/init', async (req, res) => {
         uiConfig,
         favorites,
         channels: {
-          claude: claudeChannels,
-          codex: codexChannels,
-          gemini: geminiChannels,
-          opencode: opencodeChannels.channels || [],
-          omp: ompChannels.channels || []
-        },
-        proxyStatus: {
-          claude: claudeProxyStatus,
-          codex: codexProxyStatus,
-          gemini: geminiProxyStatus,
-          opencode: opencodeProxyStatus,
-          omp: ompProxyStatus
+          claude: claudeChannels.value,
+          codex: codexChannels.value,
+          gemini: geminiChannels.value,
+          opencode: opencodeChannels.value.channels || [],
+          omp: ompChannels.value.channels || []
         },
+        proxyStatus,
         counts: {
-          claude: claudeCounts || { projectCount: 0, sessionCount: 0 },
-          codex: codexCounts || { projectCount: 0, sessionCount: 0 },
-          gemini: geminiCounts || { projectCount: 0, sessionCount: 0 },
-          opencode: opencodeCounts || { projectCount: 0, sessionCount: 0 },
-          omp: ompCounts || { projectCount: 0, sessionCount: 0 }
+          claude: claudeCounts.value || EMPTY_COUNTS,
+          codex: codexCounts.value || EMPTY_COUNTS,
+          gemini: geminiCounts.value || EMPTY_COUNTS,
+          opencode: opencodeCounts.value || EMPTY_COUNTS,
+          omp: ompCounts.value || EMPTY_COUNTS
         },
         todayStats: {
-          claude: formatStats(claudeTodayStats),
-          codex: formatStats(codexTodayStats),
-          gemini: formatStats(geminiTodayStats),
-          opencode: formatStats(opencodeTodayStats),
-          omp: formatStats(ompTodayStats)
-        }
+          claude: formatStats(claudeTodayStats.value),
+          codex: formatStats(codexTodayStats.value),
+          gemini: formatStats(geminiTodayStats.value),
+          opencode: formatStats(opencodeTodayStats.value),
+          omp: formatStats(ompTodayStats.value)
+        },
+        meta: dashboardMeta(parts)
       }
     });
   } catch (error) {

package/src/server/api/gemini-projects.js

@@ -1,30 +1,39 @@
 const express = require('express');
 const router = express.Router();
-const { getProjects, saveProjectOrder, deleteProject } = require('../services/gemini-sessions');
+const { saveProjectOrder, deleteProject } = require('../services/gemini-sessions');
 const { isGeminiInstalled } = require('../services/gemini-config');
+const {
+  emptyProjectList,
+  getProjectListSnapshot,
+  invalidateProjectSnapshots
+} = require('../services/project-snapshots');
+const { invalidateSessionSnapshots } = require('../services/session-snapshots');
+const { runDashboardSnapshotWorker } = require('../services/dashboard-snapshot-worker');
 
 module.exports = (config) => {
   /**
    * GET /api/gemini/projects
    * 获取所有 Gemini 项目列表
    */
-  router.get('/', (req, res) => {
+  router.get('/', async (req, res) => {
     try {
       // 检查 Gemini 是否安装
       if (!isGeminiInstalled()) {
         return res.json({
           projects: [],
           currentProject: null,
-          error: 'Gemini CLI not installed or not found'
+          error: 'Gemini CLI not installed or not found',
+          meta: { generatedAt: new Date().toISOString(), stale: false, refreshing: false, fallback: true, error: null }
         });
       }
 
-      const projects = getProjects();
-
-      res.json({
-        projects,
-        currentProject: projects[0] ? projects[0].name : null
+      const force = req.query?.fresh === '1';
+      const snapshot = await getProjectListSnapshot('gemini', {
+        fallbackValue: emptyProjectList(null),
+        force,
+        refresh: () => runDashboardSnapshotWorker('projects', 'gemini', config, { force })
       });
+      res.json({ ...snapshot.value, meta: snapshot.meta });
     } catch (err) {
       console.error('[Gemini API] Failed to get projects:', err);
 
@@ -59,6 +68,7 @@ module.exports = (config) => {
       }
 
       saveProjectOrder(order);
+      invalidateProjectSnapshots('gemini');
 
       res.json({ success: true });
     } catch (err) {
@@ -79,6 +89,8 @@ module.exports = (config) => {
 
       const { projectHash } = req.params;
       const result = deleteProject(projectHash);
+      invalidateProjectSnapshots('gemini');
+      invalidateSessionSnapshots('gemini', projectHash);
 
       res.json(result);
     } catch (err) {

package/src/server/api/gemini-sessions.js

@@ -13,6 +13,14 @@ const {
 } = require('../services/gemini-sessions');
 const { isGeminiInstalled } = require('../services/gemini-config');
 const { loadAliases } = require('../services/alias');
+const {
+  defaultProjectInfo,
+  emptySessionList,
+  getSessionListSnapshot,
+  invalidateSessionSnapshots,
+  runSessionSnapshotWorker
+} = require('../services/session-snapshots');
+const { invalidateProjectSnapshots } = require('../services/project-snapshots');
 
 function normalizeForkOptions(body = {}) {
   const alias = typeof body.alias === 'string' ? body.alias.trim() : '';
@@ -90,39 +98,23 @@ module.exports = (config) => {
    * GET /api/gemini/sessions/:projectHash
    * 获取项目的所有会话
    */
-  router.get('/:projectHash', (req, res) => {
+  router.get('/:projectHash', async (req, res) => {
     try {
       if (!isGeminiInstalled()) {
         return res.status(404).json({ error: 'Gemini CLI not installed' });
       }
 
       const { projectHash } = req.params;
-      const sessions = getProjectSessions(projectHash);
-
-      // 计算总大小
-      const totalSize = sessions.reduce((sum, session) => {
-        return sum + (session.size || 0);
-      }, 0);
-
-      // 获取别名
-      const aliases = loadAliases();
-
-      // 使用彩虹表解析真实路径
-      const realPath = getProjectPath(projectHash);
-      const path = require('path');
-      const displayName = realPath ? path.basename(realPath) : `Project ${projectHash.substring(0, 8)}`;
-
-      res.json({
-        sessions,
-        totalSize,
-        aliases,
-        projectInfo: {
-          name: projectHash,
-          fullPath: realPath || projectHash,
-          path: realPath || projectHash,
-          displayName
-        }
+      const force = req.query?.fresh === '1';
+      const snapshot = await getSessionListSnapshot('gemini', projectHash, {
+        fallbackValue: emptySessionList(projectHash, {
+          aliases: loadAliases(),
+          projectInfo: defaultProjectInfo(projectHash)
+        }),
+        force,
+        refresh: () => runSessionSnapshotWorker('gemini', projectHash, {}, { force })
       });
+      res.json({ ...snapshot.value, meta: snapshot.meta });
     } catch (err) {
       console.error('[Gemini API] Failed to get sessions:', err);
       res.status(500).json({ error: err.message });
@@ -328,6 +320,8 @@ module.exports = (config) => {
 
       const { sessionId } = req.params;
       const result = deleteSession(sessionId);
+      invalidateSessionSnapshots('gemini', req.params.projectHash);
+      invalidateProjectSnapshots('gemini');
 
       res.json(result);
     } catch (err) {
@@ -377,6 +371,11 @@ module.exports = (config) => {
         }
       });
 
+      if (deletedSessionIds.length > 0) {
+        invalidateSessionSnapshots('gemini', req.params.projectHash);
+        invalidateProjectSnapshots('gemini');
+      }
+
       res.json({
         success: failed.length === 0,
         requestedCount: uniqueSessionIds.length,
@@ -402,6 +401,8 @@ module.exports = (config) => {
 
       const { sessionId } = req.params;
       const result = forkSession(sessionId, normalizeForkOptions(req.body));
+      invalidateSessionSnapshots('gemini', req.params.projectHash);
+      invalidateProjectSnapshots('gemini');
 
       res.json(result);
     } catch (err) {
@@ -428,6 +429,7 @@ module.exports = (config) => {
       }
 
       saveSessionOrder(projectHash, order);
+      invalidateSessionSnapshots('gemini', projectHash);
 
       res.json({ success: true });
     } catch (err) {

package/src/server/api/omp-projects.js

@@ -1,32 +1,41 @@
 const express = require('express');
 const router = express.Router();
 const {
-  getProjects,
   saveProjectOrder,
   deleteProject,
   isOmpInstalled
 } = require('../services/omp-sessions');
+const {
+  emptyProjectList,
+  getProjectListSnapshot,
+  invalidateProjectSnapshots
+} = require('../services/project-snapshots');
+const { invalidateSessionSnapshots } = require('../services/session-snapshots');
+const { runDashboardSnapshotWorker } = require('../services/dashboard-snapshot-worker');
 
 function isNotFoundError(error) {
   return !!(error && error.message === 'Project not found');
 }
 
 module.exports = () => {
-  router.get('/', (req, res) => {
+  router.get('/', async (req, res) => {
     try {
       if (!isOmpInstalled()) {
         return res.json({
           projects: [],
           currentProject: null,
-          error: 'OMP CLI not installed or not found'
+          error: 'OMP CLI not installed or not found',
+          meta: { generatedAt: new Date().toISOString(), stale: false, refreshing: false, fallback: true, error: null }
         });
       }
 
-      const projects = getProjects();
-      res.json({
-        projects,
-        currentProject: projects[0] ? projects[0].name : null
+      const force = req.query?.fresh === '1';
+      const snapshot = await getProjectListSnapshot('omp', {
+        fallbackValue: emptyProjectList(null),
+        force,
+        refresh: () => runDashboardSnapshotWorker('projects', 'omp', {}, { force })
       });
+      res.json({ ...snapshot.value, meta: snapshot.meta });
     } catch (err) {
       console.error('[OMP API] Failed to get projects:', err);
       if (err.code === 'ENOENT') {
@@ -49,6 +58,7 @@ module.exports = () => {
         return res.status(400).json({ error: 'order must be an array' });
       }
       saveProjectOrder(order);
+      invalidateProjectSnapshots('omp');
       res.json({ success: true });
     } catch (err) {
       console.error('[OMP API] Failed to save project order:', err);
@@ -62,6 +72,8 @@ module.exports = () => {
         return res.status(404).json({ error: 'OMP CLI not installed' });
       }
       const result = deleteProject(req.params.projectName);
+      invalidateProjectSnapshots('omp');
+      invalidateSessionSnapshots('omp', req.params.projectName);
       res.json(result);
     } catch (err) {
       if (isNotFoundError(err)) {

package/src/server/api/omp-sessions.js

@@ -16,6 +16,14 @@ const {
 } = require('../services/omp-sessions');
 const { loadAliases } = require('../services/alias');
 const { broadcastLog } = require('../websocket-server');
+const {
+  defaultProjectInfo,
+  emptySessionList,
+  getSessionListSnapshot,
+  invalidateSessionSnapshots,
+  runSessionSnapshotWorker
+} = require('../services/session-snapshots');
+const { invalidateProjectSnapshots } = require('../services/project-snapshots');
 
 function isNotFoundError(error) {
   if (!error || !error.message) return false;
@@ -81,27 +89,22 @@ module.exports = () => {
     }
   });
 
-  router.get('/:projectName', (req, res) => {
+  router.get('/:projectName', async (req, res) => {
     try {
       if (!isOmpInstalled()) {
         return res.status(404).json({ error: 'OMP CLI not installed' });
       }
       const { projectName } = req.params;
-      const sessions = getSessionsByProject(projectName);
-      const aliases = loadAliases();
-      const project = getProjects().find(p => p.name === projectName);
-      const totalSize = sessions.reduce((sum, session) => sum + (session.size || 0), 0);
-      res.json({
-        sessions,
-        totalSize,
-        aliases,
-        projectInfo: {
-          name: projectName,
-          fullPath: project?.fullPath || project?.path || projectName,
-          path: project?.path || projectName,
-          displayName: project?.displayName || projectName
-        }
+      const force = req.query?.fresh === '1';
+      const snapshot = await getSessionListSnapshot('omp', projectName, {
+        fallbackValue: emptySessionList(projectName, {
+          aliases: loadAliases(),
+          projectInfo: defaultProjectInfo(projectName)
+        }),
+        force,
+        refresh: () => runSessionSnapshotWorker('omp', projectName, {}, { force })
       });
+      res.json({ ...snapshot.value, meta: snapshot.meta });
     } catch (err) {
       console.error('[OMP API] Failed to get sessions:', err);
       res.status(500).json({ error: err.message });
@@ -206,7 +209,10 @@ module.exports = () => {
       if (!isOmpInstalled()) {
         return res.status(404).json({ error: 'OMP CLI not installed' });
       }
-      res.json(deleteSession(req.params.sessionId));
+      const result = deleteSession(req.params.sessionId);
+      invalidateSessionSnapshots('omp', req.params.projectName);
+      invalidateProjectSnapshots('omp');
+      res.json(result);
     } catch (err) {
       if (isNotFoundError(err)) {
         return res.status(404).json({ error: err.message });
@@ -244,6 +250,10 @@ module.exports = () => {
           failed.push({ sessionId, error: err.message });
         }
       });
+      if (deletedSessionIds.length > 0) {
+        invalidateSessionSnapshots('omp', req.params.projectName);
+        invalidateProjectSnapshots('omp');
+      }
       res.json({
         success: failed.length === 0,
         requestedCount: uniqueSessionIds.length,
@@ -262,7 +272,10 @@ module.exports = () => {
       if (!isOmpInstalled()) {
         return res.status(404).json({ error: 'OMP CLI not installed' });
       }
-      res.json(forkSession(req.params.sessionId, req.body || {}));
+      const result = forkSession(req.params.sessionId, req.body || {});
+      invalidateSessionSnapshots('omp', req.params.projectName);
+      invalidateProjectSnapshots('omp');
+      res.json(result);
     } catch (err) {
       if (isNotFoundError(err)) {
         return res.status(404).json({ error: err.message });
@@ -282,6 +295,7 @@ module.exports = () => {
         return res.status(400).json({ error: 'order must be an array' });
       }
       saveSessionOrder(req.params.projectName, order);
+      invalidateSessionSnapshots('omp', req.params.projectName);
       res.json({ success: true });
     } catch (err) {
       console.error('[OMP API] Failed to save session order:', err);