coding-tool-x 3.8.7 → 3.8.9

package/src/config/paths.js

@@ -53,6 +53,7 @@ const LEGACY_STATS_DIR = path.join(LEGACY_DIR, 'stats');
 const CONTROL_MANIFEST_PATH = path.join(CONFIG_DIR, 'effective-control.json');
 const SKILL_ARTIFACTS_DIR = path.join(STORAGE_DIR, 'skill-artifacts');
 const SKILL_REFRESH_TASKS_PATH = path.join(RUNTIME_DIR, 'skill-refresh-tasks.json');
+const PLUGIN_REFRESH_TASKS_PATH = path.join(RUNTIME_DIR, 'plugin-refresh-tasks.json');
 
 // 旧目录（升级时自动合并到 ~/.cc-tool）
 const LEGACY_BASE_DIRS = [
@@ -416,6 +417,7 @@ const PATHS = {
   effectiveControlManifest: CONTROL_MANIFEST_PATH,
   skillArtifacts: SKILL_ARTIFACTS_DIR,
   skillRefreshTasks: SKILL_REFRESH_TASKS_PATH,
+  pluginRefreshTasks: PLUGIN_REFRESH_TASKS_PATH,
 
   // 渠道配置
   channelsDir: CHANNELS_DIR,

package/src/platforms/channel-auth-registry.js

@@ -58,10 +58,32 @@ function scanNative(adapter) {
 }
 
 function scanOmp() {
-  const snapshot = getOmpAuthProviderSnapshot({ forceRefresh: true, accountCheck: true });
+  const snapshot = getOmpAuthProviderSnapshot({ forceRefresh: true, accountCheck: true }) || {};
   const hasAccounts = (snapshot.providers || []).some(provider => (
     provider.loggedIn === true && Array.isArray(provider.accounts) && provider.accounts.length > 0
   ));
+  if (!hasAccounts) {
+    const native = readAllNativeOAuth('omp') || [];
+    let synced = null;
+    if (native.length) {
+      try {
+        synced = oauthStore.syncLocalCredential('omp');
+      } catch {
+        synced = null;
+      }
+    }
+    const credentials = synced?.credentials || [];
+    const candidates = native.map((metadata, index) => nativeCandidate('omp', metadata, credentials[index]));
+    return {
+      candidates,
+      nativeState: {
+        available: snapshot.available === true || candidates.length > 0,
+        providers: snapshot.providers || [],
+        checkedAt: snapshot.checkedAt
+      },
+      warnings: candidates.length ? [] : [snapshot.reason || 'omp: unavailable: no logged-in local provider']
+    };
+  }
   let synced = null;
   if (hasAccounts) {
     try {
@@ -81,13 +103,14 @@ function scanOmp() {
       const credential = credentials.find(item => (
         item.providerId === provider.id
         && (item.accountId === String(accountId || '') || item.accountEmail === String(accountEmail || ''))
-      ));
+      )) || credentials
+        .filter(item => item.providerId === provider.id)[Number(accountId) - 1] || null;
       const ref = safeRef({
         credentialId: credential?.id,
         providerId: provider.id,
-        accountId,
-        identityKey,
-        accountEmail
+        accountId: credential?.accountId || accountId,
+        identityKey: credential?.identityKey || identityKey,
+        accountEmail: credential?.accountEmail || accountEmail
       });
       if (!ref.accountId && !ref.identityKey && (provider.accounts || []).length > 1) continue;
       candidates.push({
@@ -132,8 +155,15 @@ const adapters = Object.freeze({
   },
   omp: {
     scan: scanOmp,
-    quota: async () => ({ status: 'unavailable', error: 'OMP native OAuth quota is unavailable' }),
+    usage: (ref) => oauthStore.fetchCredentialUsage('omp', ref.credentialId),
+    quota: (ref) => oauthStore.fetchCredentialUsage('omp', ref.credentialId),
     channelServicePath: './drivers/omp/channels-implementation'
+  },
+  opencode: {
+    scan: () => scanNative('opencode'),
+    usage: (ref) => oauthStore.fetchCredentialUsage('opencode', ref.credentialId),
+    quota: (ref) => oauthStore.fetchCredentialUsage('opencode', ref.credentialId),
+    channelServicePath: './drivers/opencode/channels-implementation'
   }
 });
 

package/src/platforms/channel-auth-service.js

@@ -37,11 +37,21 @@ function resolveChannelAuthRef(adapter, channel) {
   const matched = candidates.find(candidate => matchChannel(channel, candidate));
   if (matched) return safeRef(matched.authRef);
 
+  // A channel may retain an old account ID after the local OAuth store rotates
+  // credentials. When there is exactly one account for the same provider, it
+  // is safe to rebind the stale reference for quota lookup.
+  const soleCandidate = candidates.length === 1 ? candidates[0] : null;
+  const soleRef = safeRef(soleCandidate?.authRef);
+  const providerId = current.providerId || String(channel?.oauthProviderId || '').trim();
+  if (soleCandidate && providerId && soleRef.providerId === providerId) {
+    return soleRef;
+  }
+
   // A channel created before OAuth credentials were synced can have no stable
   // reference. Only auto-select when the local scan found exactly one account.
   if (!current.credentialId && !current.providerId && !current.accountId
-    && !current.identityKey && !current.accountEmail && candidates.length === 1) {
-    return safeRef(candidates[0].authRef);
+    && !current.identityKey && !current.accountEmail && soleCandidate) {
+    return soleRef;
   }
 
   return current;

package/src/platforms/driver-registry.js

@@ -48,7 +48,15 @@ function getDriverRegistry() {
         'generic-mcp': createGenericMcpDriver,
         'generic-prompt': createGenericPromptDriver,
         'opencode-conversion': require('./drivers/opencode/conversion').createDriver,
-        'claude-health': require('./drivers/claude/health').createDriver
+        'claude-health': require('./drivers/claude/health').createDriver,
+        'dsh-api': require('./drivers/dsh/api-operations').createDriver,
+        'dsh-projects': require('./drivers/dsh/projects').createDriver,
+        'dsh-sessions': require('./drivers/dsh/sessions').createDriver,
+        'dsh-native-config': require('./drivers/dsh/native-config').createDriver,
+        'dsh-channels': require('./drivers/dsh/channels').createDriver,
+        'dsh-proxy': require('./drivers/dsh/proxy').createDriver,
+        'dsh-statistics': require('./drivers/dsh/statistics').createDriver,
+        'dsh-native-logs': require('./drivers/dsh/native-logs').createDriver
       }
     });
     registerLegacyDrivers(defaultRegistry);

package/src/platforms/drivers/claude/session-history-adapter.js

@@ -150,6 +150,77 @@ async function inventory({ projectsDir } = {}) {
   return descriptors;
 }
 
+/** Read a bounded prefix for project/session list summaries. */
+function readSessionSummaryHead(filePath, maxBytes = 64 * 1024) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(maxBytes);
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead).toString('utf8')
+      .split(/\r?\n/)
+      .filter(line => line.trim())
+      .map(line => {
+        try { return JSON.parse(line); } catch (_) { return null; }
+      })
+      .filter(Boolean);
+  } catch (_) {
+    return [];
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch (_) {}
+    }
+  }
+}
+
+async function summarize(descriptor) {
+  const lines = readSessionSummaryHead(descriptor.filePath);
+  const { fullPath, projectName: displayName } = parseRealProjectPath(
+    descriptor.projectHint,
+    { projectsDir: descriptor.projectsDir }
+  );
+  let firstMessage = null;
+  let gitBranch = null;
+  let provider = null;
+  let model = null;
+  let startedAt = null;
+  for (const json of lines) {
+    const payload = json.message && typeof json.message === 'object' && !Array.isArray(json.message)
+      ? json.message
+      : {};
+    const timestamp = json.timestamp || payload.timestamp || null;
+    const timestampMs = timestamp ? new Date(timestamp).getTime() : null;
+    if (timestampMs && startedAt === null) startedAt = timestampMs;
+    const metadata = json.type === 'metadata' || json.type === 'summary';
+    if (metadata) {
+      gitBranch = json.gitBranch || payload.gitBranch || gitBranch;
+      provider = json.provider || payload.provider || provider;
+      model = json.model || payload.model || model;
+    }
+    const role = json.role || payload.role
+      || (json.type === 'user' || json.type === 'human' ? 'user' : null);
+    const rawContent = json.content !== undefined ? json.content : payload.content;
+    if (!firstMessage && role === 'user') firstMessage = getClaudeUserText(rawContent) || null;
+    if (json.model || payload.model) model = json.model || payload.model;
+    if (json.provider || payload.provider) provider = json.provider || payload.provider;
+  }
+  return {
+    session: {
+      sessionId: descriptor.sessionId,
+      projectName: descriptor.projectHint || 'unknown',
+      projectDisplayName: displayName || descriptor.projectHint || 'unknown',
+      projectFullPath: fullPath || null,
+      firstMessage,
+      gitBranch,
+      provider,
+      model,
+      startedAt,
+      updatedAt: descriptor.mtimeMs,
+      extraJson: JSON.stringify({ cwd: fullPath || null })
+    }
+  };
+}
+
 /**
  * Parse a Claude session file into normalized session + messages.
  * @param {{filePath: string, size: number, mtimeMs: number, sessionId: string, projectHint: string}} descriptor
@@ -310,4 +381,4 @@ async function parse(descriptor) {
   };
 }
 
-module.exports = { configure, inventory, parse, getClaudeUserText };
+module.exports = { configure, inventory, summarize, parse, getClaudeUserText };

package/src/platforms/drivers/claude/sessions-implementation.js

@@ -208,6 +208,10 @@ async function getProjectsWithStats(config = {}, options = {}) {
   return getSessionHistoryIndex(config).listProjects('claude', { ...options, config });
 }
 
+async function getProjectsPage(config = {}, options = {}) {
+  return getSessionHistoryIndex(config).listProjectsPage('claude', { ...options, config });
+}
+
 // ===== Path resolution helpers (kept for mutation/conversion paths) =====
 
 function parseRealProjectPath(encodedName, config = {}) {
@@ -327,7 +331,7 @@ function extractCwdFromSessionHeader(sessionFile) {
 // ===== Counts: delegates to index =====
 
 async function getProjectAndSessionCounts(config = {}, options = {}) {
-  const projects = await getSessionHistoryIndex().listProjects('claude', { ...options, config });
+  const projects = await getSessionHistoryIndex().getAllProjects('claude', { ...options, config });
   let sessionCount = 0;
   for (const project of projects) sessionCount += project.sessionCount || 0;
   return { projectCount: projects.length, sessionCount };
@@ -362,6 +366,23 @@ async function getSessionsForProject(config, projectName, options = {}) {
   const totalSize = sessions.reduce((sum, s) => sum + (s.size || 0), 0);
   return { sessions, totalSize };
 }
+
+async function getSessionsPage(config, projectName, options = {}) {
+  const payload = await getSessionHistoryIndex(config).listSessionsPage('claude', projectName, { ...options, config });
+  const forkRelations = getForkRelations();
+  return {
+    ...payload,
+    sessions: payload.sessions.map(session => ({
+      sessionId: session.sessionId,
+      mtime: session.mtime,
+      size: session.size,
+      filePath: session.filePath,
+      gitBranch: session.gitBranch || null,
+      firstMessage: session.firstMessage || null,
+      forkedFrom: forkRelations[session.sessionId] || null
+    }))
+  };
+}
 // ===== Mutations (sync) =====
 
 function deleteSession(config, projectName, sessionId) {
@@ -439,6 +460,7 @@ async function searchSessions(config, projectName, keyword, contextLength = 15,
   const results = await getSessionHistoryIndex().searchSessions('claude', keyword, { projectName, contextLength, ...options, config });
   const aliases = loadAliases();
   return results.map(r => ({
+    ...r,
     sessionId: r.sessionId,
     alias: aliases[r.sessionId] || null,
     matchCount: r.matchCount,
@@ -465,18 +487,25 @@ async function getRecentSessions(config, limit = 5, options = {}) {
   }));
 }
 
-async function searchSessionsAcrossProjects(config, keyword, contextLength = 35) {
+async function searchSessionsAcrossProjects(config, keyword, limit = 35, options = {}) {
   const allResults = [];
+  const searchOptions = {
+    ...options,
+    contextLength: Number(options.contextLength) || 35,
+    limit: Math.max(1, Math.min(200, Number(limit) || 35)),
+    config,
+    projectName: options.projectName || null
+  };
 
   try {
-    const claudeResults = await getSessionHistoryIndex().searchSessions('claude', keyword, { contextLength });
+    const claudeResults = await getSessionHistoryIndex().searchSessions('claude', keyword, searchOptions);
     for (const r of claudeResults) allResults.push({ ...r, channel: 'claude' });
   } catch (_) {}
 
   try {
     if (fs.existsSync(CODEX_PROJECTS_DIR)) {
       const { searchSessions: codexSearch } = require('../codex/sessions-implementation');
-      const codexResults = await codexSearch(keyword);
+      const codexResults = await codexSearch(keyword, searchOptions);
       for (const r of codexResults) allResults.push({ ...r, channel: 'codex' });
     }
   } catch (_) {}
@@ -484,13 +513,24 @@ async function searchSessionsAcrossProjects(config, keyword, contextLength = 35)
   try {
     if (fs.existsSync(GEMINI_PROJECTS_DIR)) {
       const { searchSessions: geminiSearch } = require('../gemini/sessions-implementation');
-      const geminiResults = await geminiSearch(keyword, contextLength);
+      const geminiResults = await geminiSearch(keyword, searchOptions.contextLength, searchOptions);
       for (const r of geminiResults) allResults.push({ ...r, channel: 'gemini' });
     }
   } catch (_) {}
 
-  allResults.sort((a, b) => (b.matchCount || 0) - (a.matchCount || 0));
-  return allResults;
+  allResults.sort((a, b) => {
+    const updatedA = sessionTimestamp(a.updatedAt ?? a.lastUpdated ?? a.mtimeMs ?? a.mtime);
+    const updatedB = sessionTimestamp(b.updatedAt ?? b.lastUpdated ?? b.mtimeMs ?? b.mtime);
+    return updatedB - updatedA || String(a.sessionId || '').localeCompare(String(b.sessionId || ''));
+  });
+  return allResults.slice(0, searchOptions.limit);
+}
+
+function sessionTimestamp(value) {
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) return numeric;
+  const parsed = Date.parse(String(value || ''));
+  return Number.isFinite(parsed) ? parsed : 0;
 }
 function hasActualMessages(sessionFile) {
   if (!sessionFile || !fs.existsSync(sessionFile)) return false;
@@ -513,7 +553,9 @@ module.exports = {
   configure,
   getProjects,
   getProjectsWithStats,
+  getProjectsPage,
   getSessionsForProject,
+  getSessionsPage,
   deleteSession,
   forkSession,
   launch,

package/src/platforms/drivers/claude/sessions.js

@@ -11,7 +11,7 @@ function createDriver(context = {}) {
     servicePath: './claude/sessions-implementation',
     localServicePath: '../platforms/drivers/claude/sessions-implementation',
     adapterLocalPath: '../platforms/drivers/claude/session-history-adapter',
-    adapterMethods: { inventory: 'inventory', parse: 'parse' },
+    adapterMethods: { inventory: 'inventory', summarize: 'summarize', parse: 'parse' },
     methods: {
       launch: 'launch',
       saveSessionOrder: 'saveSessionOrder',
@@ -44,6 +44,14 @@ function createDriver(context = {}) {
           request
         );
       },
+      listSessionsPage: (service, projectNameOrRequest, options = {}) => {
+        const descriptorRequest = projectNameOrRequest && typeof projectNameOrRequest === 'object';
+        const request = descriptorRequest ? projectNameOrRequest : options;
+        const projectName = descriptorRequest
+          ? request.params?.projectName
+          : projectNameOrRequest;
+        return service.getSessionsPage(request.config || {}, projectName, request);
+      },
       recent: (service, limitOrRequest, options = {}) => {
         const descriptorRequest = limitOrRequest && typeof limitOrRequest === 'object';
         const request = descriptorRequest ? limitOrRequest : options;
@@ -59,11 +67,27 @@ function createDriver(context = {}) {
         contextLength,
         options
       ),
-      searchAcrossProjects: (service, keyword, limit, options = {}) => service.searchSessionsAcrossProjects(
-        options.config || {},
-        keyword,
-        limit
-      )
+      searchAcrossProjects: (service, requestOrKeyword, limit, options = {}) => {
+        if (requestOrKeyword && typeof requestOrKeyword === 'object' && !Array.isArray(requestOrKeyword)) {
+          const request = requestOrKeyword;
+          const query = request.query || {};
+          const requestLimit = Number.parseInt(query.limit, 10) || 35;
+          return service.searchSessionsAcrossProjects(
+            request.config || options.config || {},
+            query.keyword || query.q || query.query || '',
+            requestLimit,
+            {
+              ...request,
+              ...options,
+              config: request.config || options.config || {},
+              projectName: query.projectName || query.project || null,
+              limit: requestLimit,
+              contextLength: Number(query.context) || 35
+            }
+          );
+        }
+        return service.searchSessionsAcrossProjects(options.config || {}, requestOrKeyword, limit, options);
+      }
     },
     onSuccess: operation => {
       if (['delete', 'fork', 'saveSessionOrder'].includes(operation)) {

package/src/platforms/drivers/codex/parser.js

@@ -339,11 +339,67 @@ function parseSession(filePath) {
   };
 }
 
+/**
+ * Read only the beginning of a rollout for list views. Codex rollouts can be
+ * hundreds of megabytes; this helper must never call readJSONL/parseSession.
+ */
+function parseSessionSummary(filePath, { sessionId = null, mtimeMs = null } = {}) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(64 * 1024);
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    const lines = buffer.subarray(0, bytesRead).toString('utf8')
+      .split(/\r?\n/)
+      .filter(line => line.trim())
+      .map(line => {
+        try { return JSON.parse(line); } catch (_) { return null; }
+      })
+      .filter(Boolean);
+    const meta = extractSessionMeta(lines);
+    if (!meta) return null;
+    const firstUser = lines.find(line => {
+      const payload = line.type === 'response_item' ? line.payload : null;
+      return payload?.type === 'message' && payload.role === 'user' && Array.isArray(payload.content);
+    });
+    const content = firstUser?.payload?.content
+      ?.map(block => block?.text || block?.input_text || '')
+      .join('\n')
+      .trim() || null;
+    const nativeSessionId = typeof meta.sessionId === 'string' && meta.sessionId.trim()
+      ? meta.sessionId.trim()
+      : sessionId;
+    const projectName = extractCodexProjectName(meta);
+    return {
+      session: {
+        sessionId: nativeSessionId,
+        projectName,
+        projectDisplayName: projectName,
+        projectFullPath: typeof meta.cwd === 'string' && meta.cwd.trim() ? meta.cwd.trim() : null,
+        firstMessage: content,
+        gitBranch: meta.git?.branch || null,
+        provider: meta.provider || null,
+        model: null,
+        startedAt: meta.timestamp ? new Date(meta.timestamp).getTime() : null,
+        updatedAt: mtimeMs,
+        extraJson: JSON.stringify({ cwd: meta.cwd || null })
+      }
+    };
+  } catch (_) {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch (_) {}
+    }
+  }
+}
+
 module.exports = {
   readJSONL,
   extractSessionMeta,
   extractMessages,
   extractTokenUsage,
   parseSession,
-  parseSessionMeta
+  parseSessionMeta,
+  parseSessionSummary
 };

package/src/platforms/drivers/codex/session-history-adapter.js

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { getCodexDir } = require('./config');
-const { parseSession } = require('./parser');
+const { parseSession, parseSessionSummary } = require('./parser');
 
 function configure({ pathContext } = {}) {
   require('./config').configure?.({ pathContext });
@@ -90,6 +90,12 @@ async function inventory({ projectsDir } = {}) {
   }));
 }
 
+async function summarize(descriptor) {
+  const parsed = parseSessionSummary(descriptor.filePath, descriptor);
+  if (!parsed?.session) return { sessionId: descriptor.sessionId, projectName: descriptor.projectHint || 'unknown' };
+  return parsed;
+}
+
 /**
  * Parse a Codex session file.
  */
@@ -169,4 +175,4 @@ async function parse(descriptor) {
   return { session, messages: normalizedMessages };
 }
 
-module.exports = { configure, inventory, parse, extractCodexProjectName };
+module.exports = { configure, inventory, summarize, parse, extractCodexProjectName };

package/src/platforms/drivers/codex/sessions-implementation.js

@@ -250,7 +250,7 @@ function normalizeSession(codexSession) {
  */
 async function getProjects(options = {}) {
   if (!fs.existsSync(getSessionsDir())) return [];
-  const projects = await getSessionHistoryIndex({ ...options, projectsDir: getSessionsDir() }).listProjects('codex', options);
+  const projects = await getSessionHistoryIndex({ ...options, projectsDir: getSessionsDir() }).getAllProjects('codex', options);
   const savedOrder = getProjectOrder();
   if (savedOrder.length === 0) return projects;
 
@@ -260,6 +260,11 @@ async function getProjects(options = {}) {
   return [...ordered, ...byName.values()];
 }
 
+async function getProjectsPage(options = {}) {
+  return getSessionHistoryIndex({ ...options, projectsDir: getSessionsDir() })
+    .listProjectsPage('codex', options);
+}
+
 /**
  * 根据项目名获取会话列表（归一化格式）
  * @param {string} projectName - 项目名称
@@ -284,6 +289,21 @@ async function getSessionsByProject(projectName, options = {}) {
   return [...byId.values(), ...ordered];
 }
 
+async function getSessionsPage(projectName, options = {}) {
+  const payload = await getSessionHistoryIndex().listSessionsPage('codex', projectName, options);
+  const forkRelations = require('../claude/sessions-implementation').getForkRelations();
+  const aliases = require('../../../server/services/alias').loadAliases();
+  return {
+    ...payload,
+    sessions: payload.sessions.map(session => ({
+      ...session,
+      mtime: new Date(session.mtime).toISOString(),
+      forkedFrom: forkRelations[session.sessionId] || null,
+      alias: aliases[session.sessionId] || null
+    }))
+  };
+}
+
 /**
  * 根据 sessionId 获取会话（归一化格式）
  * @param {string} sessionId - 会话 ID
@@ -302,8 +322,8 @@ async function getSessionById(sessionId) {
  * @param {string} keyword - 搜索关键词
  * @returns {Array} 搜索结果
  */
-async function searchSessions(keyword) {
-  return getSessionHistoryIndex().searchSessions('codex', keyword);
+async function searchSessions(keyword, options = {}) {
+  return getSessionHistoryIndex().searchSessions('codex', keyword, options);
 }
 
 /**
@@ -825,7 +845,9 @@ module.exports = {
   scanSessionFiles,
   getAllSessions,
   getProjects,
+  getProjectsPage,
   getSessionsByProject,
+  getSessionsPage,
   getSessionById,
   searchSessions,
   normalizeSession,

package/src/platforms/drivers/codex/sessions.js

@@ -11,9 +11,10 @@ function createDriver(context = {}) {
     servicePath: './codex/sessions-implementation',
     localServicePath: '../platforms/drivers/codex/sessions-implementation',
     adapterLocalPath: '../platforms/drivers/codex/session-history-adapter',
-    adapterMethods: { inventory: 'inventory', parse: 'parse' },
+    adapterMethods: { inventory: 'inventory', summarize: 'summarize', parse: 'parse' },
     methods: {
       listSessions: 'getSessionsByProject',
+      listSessionsPage: 'getSessionsPage',
       recent: 'getRecentSessions',
       search: 'searchSessions',
       getSessionById: 'getSessionById',
@@ -25,6 +26,22 @@ function createDriver(context = {}) {
       status: 'getSessionStatus',
       messages: 'getSessionMessages'
     },
+    customMethods: {
+      searchAcrossProjects: (service, requestOrKeyword, limit, options = {}) => {
+        if (requestOrKeyword && typeof requestOrKeyword === 'object' && !Array.isArray(requestOrKeyword)) {
+          const request = requestOrKeyword;
+          const query = request.query || {};
+          return service.searchSessions(query.keyword || query.q || '', {
+            ...request,
+            ...options,
+            projectName: query.projectName || query.project || null,
+            limit: Number.parseInt(query.limit, 10) || 35,
+            contextLength: Number(query.context) || 35
+          });
+        }
+        return service.searchSessions(requestOrKeyword, { ...options, limit });
+      }
+    },
     onSuccess: operation => {
       if (['delete', 'fork', 'saveSessionOrder'].includes(operation)) {
         context.sessionHistoryIndex?.invalidateSource('codex');