coding-tool-x 3.8.4 → 3.8.6

package/src/{server/services/omp-sessions.js → platforms/drivers/omp/sessions-implementation.js}

@@ -1,14 +1,40 @@
 const fs = require('fs');
 const path = require('path');
-const { PATHS, HOME_DIR } = require('../../config/paths');
+const { PATHS, HOME_DIR } = require('../../../config/paths');
+const ompConfig = require('./config');
 const {
-  listProjects: idxListProjects,
-  listSessions: idxListSessions,
-  getRecentSessions: idxGetRecent,
-  searchSessions: idxSearch,
-  getSessionStatus: idxGetSessionStatus,
-} = require('./session-history-index');
-const { getOmpCommand, getOmpPaths, resolveOmpRuntime } = require('./omp-config');
+  normalizeUsage: normalizeNativeUsage,
+  readJsonLines: readNativeJsonLines,
+  usageFieldPaths,
+  createSelectiveJsonLineParser,
+  createIncrementalJsonlCursor
+} = require('../native-log-utils');
+let sessionHistoryIndex = null;
+let ompSessionPathsOverride = null;
+
+function configure({ sessionHistoryIndex: index, pathContext } = {}) {
+  sessionHistoryIndex = index || null;
+  ompConfig.configure?.({ pathContext });
+  const native = pathContext?.customized ? (pathContext.native || {}) : {};
+  ompSessionPathsOverride = native.sessions
+    ? { ...native, agentDir: native.dir || path.dirname(native.sessions) }
+    : null;
+}
+
+function getSessionHistoryIndex(options = {}) {
+  if (!sessionHistoryIndex) {
+    const { getDefaultDependencies } = require('../../../platforms/runtime');
+    sessionHistoryIndex = getDefaultDependencies().sessionHistoryIndex;
+    if (!sessionHistoryIndex) {
+      const indexModule = require('../../../server/services/session-history-index');
+      sessionHistoryIndex = Object.keys(options).length > 0
+        ? indexModule.createSessionHistoryIndex({ config: options })
+        : indexModule;
+    }
+  }
+  return sessionHistoryIndex;
+}
+const { getOmpCommand, getOmpPaths, resolveOmpRuntime } = require('./config');
 
 const PROJECT_ORDER_FILE = PATHS.ompProjectOrder;
 const SESSION_ORDER_FILE = PATHS.ompSessionOrder;
@@ -116,34 +142,24 @@ function extractMessageText(message = {}) {
 }
 
 function parseUsage(usage = {}) {
-  const input = Number(usage.input ?? usage.inputTokens ?? usage.input_tokens ?? usage.prompt_tokens ?? usage.promptTokens ?? 0) || 0;
-  const output = Number(usage.output ?? usage.outputTokens ?? usage.output_tokens ?? usage.completion_tokens ?? usage.completionTokens ?? 0) || 0;
-  const cacheRead = Number(usage.cacheRead ?? usage.cache_read ?? usage.cachedTokens ?? usage.cached_tokens ?? usage.cache_read_input_tokens ?? 0) || 0;
-  const cacheWrite = Number(usage.cacheWrite ?? usage.cache_write ?? usage.cacheCreation ?? usage.cache_creation ?? usage.cache_creation_input_tokens ?? 0) || 0;
-  const reasoning = Number(usage.reasoningTokens ?? usage.reasoning_tokens ?? 0) || 0;
-  const total = Number(usage.totalTokens ?? usage.total_tokens ?? (input + output + cacheRead + cacheWrite + reasoning)) || 0;
+  const normalized = normalizeNativeUsage(usage);
+  const input = normalized.input;
+  const output = normalized.output;
+  const cacheRead = normalized.cacheRead;
+  const cacheWrite = normalized.cacheCreation;
+  const reasoning = normalized.reasoning;
+  const total = normalized.total;
   const cost = typeof usage.cost === 'number'
     ? usage.cost
     : Number(usage.cost?.total ?? usage.cost?.usd ?? 0) || 0;
-  return { input, output, cached: cacheRead, cacheRead, cacheWrite, reasoning, total, cost };
+  return {
+    input, output, cached: normalized.cached, cacheRead, cacheWrite,
+    cacheCreation: normalized.cacheCreation, reasoning, total, cost
+  };
 }
 
 function readJsonLines(filePath) {
-  try {
-    const raw = fs.readFileSync(filePath, 'utf8');
-    return raw
-      .split(/\r?\n/)
-      .filter(line => line.trim())
-      .map((line) => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return { type: 'invalid', raw: line };
-        }
-      });
-  } catch {
-    return [];
-  }
+  return readNativeJsonLines(filePath, fs);
 }
 
 function convertOmpEntry(entry = {}, index = 0) {
@@ -219,43 +235,64 @@ function parseSessionFile(filePath) {
   };
 }
 
-function parseSessionUsageEvents(filePath) {
-  const entries = readJsonLines(filePath);
+function createSessionUsageParserState(filePath, entries = [], previousState = {}) {
   const header = entries.find(entry => entry?.type === 'session') || {};
-  const sessionId = header.id || parseOmpSessionId(filePath);
-  let activeProvider = '';
-  let activeModel = '';
-  const events = [];
+  return {
+    sessionId: previousState.sessionId || header.id || parseOmpSessionId(filePath),
+    sessionTimestamp: previousState.sessionTimestamp ?? header.timestamp ?? null,
+    activeProvider: previousState.activeProvider || '',
+    activeModel: previousState.activeModel || '',
+    entryIndex: Number.isInteger(previousState.entryIndex) ? previousState.entryIndex : 0
+  };
+}
 
-  entries.forEach((entry, index) => {
-    if (entry?.type === 'model_change') {
-      activeProvider = entry.provider || activeProvider;
-      activeModel = entry.modelId || entry.model || activeModel;
-      return;
-    }
-    if (entry?.type !== 'message') return;
+function parseSessionUsageEntry(filePath, entry, index, state) {
+  if (entry?.type === 'session') {
+    state.sessionId = entry.id || state.sessionId;
+    state.sessionTimestamp = entry.timestamp || state.sessionTimestamp;
+    return null;
+  }
+  if (entry?.type === 'model_change') {
+    state.activeProvider = entry.provider || state.activeProvider;
+    state.activeModel = entry.modelId || entry.model || state.activeModel;
+    return null;
+  }
+  if (entry?.type !== 'message') return null;
 
-    const message = entry.message || {};
-    const role = message.role || entry.role;
-    if (role !== 'assistant') return;
+  const message = entry.message || {};
+  const role = message.role || entry.role;
+  if (role !== 'assistant') return null;
 
-    const eventId = entry.id || message.id || `assistant-${index}`;
-    events.push({
-      key: `${filePath}:${eventId}`,
-      id: `${sessionId}:${eventId}`,
-      sessionId,
-      filePath,
-      provider: entry.provider || message.provider || activeProvider || '',
-      model: entry.model || message.model || activeModel || '',
-      timestamp: entry.timestamp || message.timestamp || header.timestamp || null,
-      usage: parseUsage(entry.usage || message.usage || {})
-    });
+  const eventId = entry.id || message.id || `assistant-${index}`;
+  return {
+    key: `${filePath}:${eventId}`,
+    id: `${state.sessionId}:${eventId}`,
+    sessionId: state.sessionId,
+    filePath,
+    provider: entry.provider || message.provider || state.activeProvider || '',
+    model: entry.model || message.model || state.activeModel || '',
+    timestamp: entry.timestamp || message.timestamp || state.sessionTimestamp || null,
+    usage: parseUsage(entry.usage || message.usage || {})
+  };
+}
+
+function parseSessionUsageEntries(filePath, entries, previousState = {}) {
+  const state = createSessionUsageParserState(filePath, entries, previousState);
+  const events = [];
+  entries.forEach((entry, index) => {
+    const event = parseSessionUsageEntry(filePath, entry, index, state);
+    if (event) events.push(event);
   });
+  return { events, state };
+}
 
-  return events;
+function parseSessionUsageEvents(filePath) {
+  const entries = readJsonLines(filePath);
+  return parseSessionUsageEntries(filePath, entries).events;
 }
 
 function getOmpSessionPaths() {
+  if (ompSessionPathsOverride?.sessions) return ompSessionPathsOverride;
   // Reading historical sessions normally only needs OMP's native directory
   // convention. Avoid starting the CLI here: project/count snapshot workers
   // invoke this path independently, which made Windows repeatedly open
@@ -294,8 +331,8 @@ function scanSessionFiles(rootDir = getOmpSessionPaths().sessions) {
 }
 
 async function getAllSessions(options = {}) {
-  const projects = await idxListProjects('omp', options);
-  const groups = await Promise.all(projects.map(project => idxListSessions('omp', project.name, options)));
+  const projects = await getSessionHistoryIndex().listProjects('omp', options);
+  const groups = await Promise.all(projects.map(project => getSessionHistoryIndex().listSessions('omp', project.name, options)));
   return groups.flat().map(session => normalizeSession({
     ...session,
     mtime: new Date(session.mtime).toISOString(),
@@ -316,34 +353,31 @@ function getOmpUsageEvents(rootDir = getOmpSessionPaths().sessions) {
   });
 }
 
-function createOmpUsageEventCursor(rootDir = null) {
-  let signatures = new Map();
+const OMP_SELECTED_FIELDS = [
+  'type', 'id', 'timestamp', 'provider', 'model', 'modelId', 'cwd',
+  'role', 'message.role', 'message.id', 'message.timestamp', 'message.provider',
+  'message.model', 'message.modelId',
+  ...usageFieldPaths('usage'),
+  ...usageFieldPaths('message.usage')
+];
 
-  return {
-    read() {
-      const files = scanSessionFiles(rootDir || getOmpSessionPaths().sessions);
-      const nextSignatures = new Map();
-      const events = [];
-
-      files.forEach((filePath) => {
-        try {
-          const stat = fs.statSync(filePath);
-          const signature = `${stat.size}:${stat.mtimeMs}`;
-          nextSignatures.set(filePath, signature);
-          if (signatures.get(filePath) === signature) return;
-          events.push(...parseSessionUsageEvents(filePath));
-        } catch (error) {
-          console.warn('[OMP Sessions] Failed to read changed usage events:', filePath, error.message);
-        }
-      });
-
-      signatures = nextSignatures;
-      return events;
-    },
-    reset() {
-      signatures = new Map();
+function createOmpUsageEventCursor(rootDir = null, { skipInitialParse = false, onDiagnostic } = {}) {
+  return createIncrementalJsonlCursor({
+    scanFiles: () => scanSessionFiles(rootDir || getOmpSessionPaths().sessions),
+    createFileState: (filePath, _stat, previousState) => createSessionUsageParserState(
+      filePath,
+      [],
+      previousState || {}
+    ),
+    parseLine: (filePath, record, state, index) => parseSessionUsageEntry(filePath, record, index, state),
+    fsImpl: fs,
+    skipInitialParse,
+    createLongLineParser: () => createSelectiveJsonLineParser(OMP_SELECTED_FIELDS),
+    onDiagnostic,
+    onError: (error, filePath) => {
+      console.warn('[OMP Sessions] Failed to read changed usage events:', filePath, error.message);
     }
-  };
+  });
 }
 
 function loadProjectOrder() {
@@ -355,8 +389,8 @@ function loadSessionOrder() {
   return safeReadJson(SESSION_ORDER_FILE, {});
 }
 
-async function getProjects(_options = {}) {
-  const idxProjects = await idxListProjects('omp');
+async function getProjects(options = {}) {
+  const idxProjects = await getSessionHistoryIndex().listProjects('omp', options);
   const projects = idxProjects.map(p => ({
     name: p.name,
     path: p.fullPath || p.path || '',
@@ -383,8 +417,8 @@ async function getProjects(_options = {}) {
   return projects;
 }
 
-async function getSessionsByProject(projectName, _options = {}) {
-  const idxSessions = await idxListSessions('omp', projectName);
+async function getSessionsByProject(projectName, options = {}) {
+  const idxSessions = await getSessionHistoryIndex().listSessions('omp', projectName, options);
   const sessions = idxSessions.map(s => ({
     sessionId: s.sessionId,
     filePath: s.filePath,
@@ -437,7 +471,7 @@ function normalizeSession(session) {
 }
 
 async function getSessionById(sessionId) {
-  const status = await idxGetSessionStatus('omp', sessionId);
+  const status = await getSessionHistoryIndex().getSessionStatus('omp', sessionId);
   if (!status) return null;
   return {
     sessionId: status.sessionId,
@@ -465,7 +499,7 @@ async function getSessionMessages(sessionId) {
 }
 
 async function getRecentSessions(limit = 5) {
-  const indexed = await idxGetRecent('omp', limit);
+  const indexed = await getSessionHistoryIndex().getRecentSessions('omp', limit);
   return indexed.map(session => normalizeSession({
     ...session,
     mtime: new Date(session.mtime).toISOString(),
@@ -476,7 +510,7 @@ async function getRecentSessions(limit = 5) {
 }
 
 async function searchSessions(keyword, contextLength = 35, projectName = null) {
-  return idxSearch('omp', keyword, { contextLength, projectName });
+  return getSessionHistoryIndex().searchSessions('omp', keyword, { contextLength, projectName });
 }
 
 async function deleteSession(sessionId) {
@@ -514,7 +548,7 @@ function saveSessionOrder(projectName, order) {
 }
 
 async function getProjectAndSessionCounts(options = {}) {
-  const projects = await idxListProjects('omp', options);
+  const projects = await getSessionHistoryIndex().listProjects('omp', options);
   return {
     projectCount: projects.length,
     sessionCount: projects.reduce((sum, project) => sum + (project.sessionCount || 0), 0)
@@ -564,6 +598,7 @@ function isOmpCliInstalled() {
 }
 
 module.exports = {
+  configure,
   buildLaunchCommand,
   createOmpUsageEventCursor,
   decodeProjectName,
@@ -573,6 +608,7 @@ module.exports = {
   forkSession,
   getAllSessions,
   getOmpUsageEvents,
+  getOmpSessionPaths,
   getProjectAndSessionCounts,
   getProjects,
   getRecentSessions,

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

@@ -0,0 +1,36 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'omp',
+    capability: 'sessions',
+    parserVersion: 2,
+    servicePath: './omp/sessions-implementation',
+    localServicePath: '../platforms/drivers/omp/sessions-implementation',
+    adapterLocalPath: '../platforms/drivers/omp/session-history-adapter',
+    adapterMethods: { inventory: 'inventory', parse: 'parse' },
+    methods: {
+      getProjects: 'getProjects',
+      listSessions: 'getSessionsByProject',
+      recent: 'getRecentSessions',
+      search: 'searchSessions',
+      getSessionById: 'getSessionById',
+      messages: 'getSessionMessages',
+      delete: 'deleteSession',
+      fork: 'forkSession',
+      saveSessionOrder: 'saveSessionOrder',
+      buildLaunchCommand: 'buildLaunchCommand',
+      status: 'getSessionStatus'
+    },
+    onSuccess: operation => {
+      if (['delete', 'fork', 'saveSessionOrder'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('omp');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/{server/services/omp-skill-discovery.js → platforms/drivers/omp/skill-discovery.js}

@@ -5,8 +5,9 @@ const {
   getOmpCommand,
   getOmpPaths,
   readOmpSettings
-} = require('./omp-config');
-const { HOME_DIR, NATIVE_PATHS } = require('../../config/paths');
+} = require('./config');
+const { HOME_DIR, NATIVE_PATHS } = require('../../../config/paths');
+const { assertNoSymlinkComponents } = require('../../../shared/project-config');
 
 const DEFAULT_SKILL_SETTINGS = Object.freeze({
   enabled: true,
@@ -23,6 +24,31 @@ const DEFAULT_SKILL_SETTINGS = Object.freeze({
   disabledExtensions: []
 });
 
+const DISCOVERY_CACHE_TTL_MS = 1000;
+const settingsCache = new Map();
+const pluginPathsCache = new Map();
+const discoveryCache = new Map();
+
+function canonicalCwd(cwd) {
+  if (!cwd) return '';
+  const resolved = path.resolve(cwd);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+function cacheKey(cwd, scope = 'user') {
+  return `${scope}:${canonicalCwd(cwd)}`;
+}
+
+function cloneSkills(skills) {
+  return Array.isArray(skills)
+    ? skills.map(skill => ({ ...skill, shadowedSources: Array.isArray(skill.shadowedSources) ? skill.shadowedSources.map(source => ({ ...source })) : [] }))
+    : [];
+}
+
 function expandHome(value) {
   const input = String(value || '').trim();
   if (input === '~') return HOME_DIR;
@@ -30,7 +56,7 @@ function expandHome(value) {
   return input;
 }
 
-function readEffectiveSettings(cwd) {
+function _readEffectiveSettings(cwd) {
   try {
     const output = execFileSync(getOmpCommand(), ['config', 'list', '--json'], {
       cwd: cwd || process.cwd(),
@@ -60,6 +86,18 @@ function readEffectiveSettings(cwd) {
   }
 }
 
+function readEffectiveSettings(cwd, { force = false, scope = 'user' } = {}) {
+  const key = cacheKey(cwd, scope);
+  const now = Date.now();
+  const cached = settingsCache.get(key);
+  if (!force && cached && now - cached.checkedAt < DISCOVERY_CACHE_TTL_MS) {
+    return { ...cached.value };
+  }
+  const value = _readEffectiveSettings(cwd);
+  settingsCache.set(key, { value, checkedAt: now });
+  return { ...value };
+}
+
 function globMatches(value, pattern) {
   const escaped = String(pattern || '')
     .replace(/[.+^${}()|[\]\\]/g, '\\$&')
@@ -84,6 +122,7 @@ function isIncluded(name, settings) {
 function parseSkill(service, skillFile, provider, scope, requireDescription) {
   let metadata;
   try {
+    if (fs.lstatSync(skillFile).isSymbolicLink()) return null;
     metadata = service.parseSkillMd(fs.readFileSync(skillFile, 'utf8'));
   } catch {
     return null;
@@ -104,6 +143,9 @@ function parseSkill(service, skillFile, provider, scope, requireDescription) {
   const native = provider === 'native';
   return {
     key: `omp:${provider}:${scope}:${realPath}`,
+    sourceKey: native
+      ? `native:omp:${directory}`
+      : `omp:${provider}:${directory}`,
     name,
     description,
     directory,
@@ -125,8 +167,29 @@ function parseSkill(service, skillFile, provider, scope, requireDescription) {
   };
 }
 
-function scanOneLevel(service, root, descriptor, settings) {
+function isSafeProjectScanRoot(root, projectRoot) {
+  if (!root || !projectRoot) return false;
+  const requestedRoot = path.resolve(root);
+  const requestedProjectRoot = path.resolve(projectRoot);
+  try {
+    const projectStat = fs.lstatSync(requestedProjectRoot);
+    const rootStat = fs.lstatSync(requestedRoot);
+    if (projectStat.isSymbolicLink() || rootStat.isSymbolicLink()) return false;
+    if (!projectStat.isDirectory() || !rootStat.isDirectory()) return false;
+    const resolvedProjectRoot = fs.realpathSync(requestedProjectRoot);
+    const resolvedRoot = fs.realpathSync(requestedRoot);
+    const relative = path.relative(resolvedProjectRoot, resolvedRoot);
+    if (relative.startsWith(`..${path.sep}`) || relative === '..' || path.isAbsolute(relative)) return false;
+    assertNoSymlinkComponents(resolvedProjectRoot, resolvedRoot, fs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function scanOneLevel(service, root, descriptor, settings, projectRoot = null) {
   if (!root || !fs.existsSync(root)) return [];
+  if (descriptor.scope === 'project' && !isSafeProjectScanRoot(root, projectRoot)) return [];
   const result = [];
   let entries = [];
   try {
@@ -136,15 +199,8 @@ function scanOneLevel(service, root, descriptor, settings) {
   }
 
   for (const entry of entries) {
+    if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
     const entryPath = path.join(root, entry.name);
-    if (!entry.isDirectory()) {
-      if (!entry.isSymbolicLink()) continue;
-      try {
-        if (!fs.statSync(entryPath).isDirectory()) continue;
-      } catch {
-        continue;
-      }
-    }
     const skillFile = path.join(entryPath, 'SKILL.md');
     if (!fs.existsSync(skillFile)) continue;
     const skill = parseSkill(
@@ -161,7 +217,7 @@ function scanOneLevel(service, root, descriptor, settings) {
   return result;
 }
 
-function getPluginInstallPaths(cwd) {
+function _getPluginInstallPaths(cwd) {
   try {
     const output = execFileSync(getOmpCommand(), ['plugin', 'list', '--json'], {
       cwd: cwd || process.cwd(),
@@ -196,6 +252,18 @@ function getPluginInstallPaths(cwd) {
   }
 }
 
+function getPluginInstallPaths(cwd, { force = false, scope = 'user' } = {}) {
+  const key = cacheKey(cwd, scope);
+  const now = Date.now();
+  const cached = pluginPathsCache.get(key);
+  if (!force && cached && now - cached.checkedAt < DISCOVERY_CACHE_TTL_MS) {
+    return cached.value.map(item => ({ ...item }));
+  }
+  const value = _getPluginInstallPaths(cwd);
+  pluginPathsCache.set(key, { value, checkedAt: now });
+  return value.map(item => ({ ...item }));
+}
+
 function getClaudePluginSkillRoots() {
   const pluginsDir = NATIVE_PATHS.claude.plugins
     || path.join(NATIVE_PATHS.claude.dir, 'plugins');
@@ -266,37 +334,63 @@ function compactShadow(skill) {
 }
 
 function deduplicateDiscoveredSkills(skills) {
-  const byName = new Map();
+  const byIdentity = new Map();
   const byRealPath = new Map();
   const result = [];
+  const priority = skill => skill.sourceScope === 'project' ? 2 : 1;
+  const identityFor = skill => String(
+    skill.sourceKey || `${skill.sourceProvider || 'unknown'}:${String(skill.name || '').toLowerCase()}`
+  );
 
   for (const skill of skills) {
-    const nameKey = skill.name.toLowerCase();
+    const identity = identityFor(skill);
     const pathKey = skill.realPath || skill.sourcePath;
-    const existing = byName.get(nameKey) || byRealPath.get(pathKey);
-    if (existing) {
-      existing.shadowedSources.push(compactShadow(skill));
+    const existing = byIdentity.get(identity) || byRealPath.get(pathKey);
+    if (!existing) {
+      byIdentity.set(identity, skill);
+      if (pathKey) byRealPath.set(pathKey, skill);
+      result.push(skill);
+      continue;
+    }
+
+    if (priority(skill) > priority(existing)) {
+      skill.shadowedSources.push(compactShadow(existing));
+      const index = result.indexOf(existing);
+      if (index >= 0) result[index] = skill;
+      for (const [key, value] of byIdentity) {
+        if (value === existing) byIdentity.delete(key);
+      }
+      for (const [key, value] of byRealPath) {
+        if (value === existing) byRealPath.delete(key);
+      }
+      byIdentity.set(identity, skill);
+      if (pathKey) byRealPath.set(pathKey, skill);
       continue;
     }
-    byName.set(nameKey, skill);
-    byRealPath.set(pathKey, skill);
-    result.push(skill);
+
+    existing.shadowedSources.push(compactShadow(skill));
   }
 
   return result;
 }
 
-function discoverOmpSkills(service, options = {}) {
-  const cwd = options.cwd ? path.resolve(options.cwd) : null;
-  const settings = readEffectiveSettings(cwd);
+function _discoverOmpSkills(service, options = {}, settings = readEffectiveSettings(options.cwd), pluginPaths = getPluginInstallPaths(options.cwd), claudePluginRoots = getClaudePluginSkillRoots()) {
+  const cwd = options.cwd ? canonicalCwd(options.cwd) : null;
   if (settings.enabled === false) return [];
 
-  const ompPaths = getOmpPaths();
-  const userHome = HOME_DIR;
+  const customNative = options.pathContext?.customized ? (options.pathContext.native || {}) : null;
+  const ompPaths = customNative
+    ? {
+      ...getOmpPaths(),
+      ...customNative,
+      agentDir: customNative.dir || options.pathContext.home
+    }
+    : getOmpPaths();
+  const userHome = options.pathContext?.customized ? options.pathContext.home : HOME_DIR;
   const descriptors = [
     { provider: 'native', scope: 'user', root: ompPaths.skills, requireDescription: true },
     ...(cwd ? [{ provider: 'native', scope: 'project', root: path.join(cwd, '.omp', 'skills'), requireDescription: true }] : []),
-    ...getPluginInstallPaths(cwd)
+    ...pluginPaths
       .filter(item => cwd || item.scope !== 'project')
       .map(item => ({
         provider: 'omp-plugins',
@@ -306,7 +400,7 @@ function discoverOmpSkills(service, options = {}) {
       })),
     { provider: 'claude', scope: 'user', root: NATIVE_PATHS.claude.skills, requireDescription: false },
     ...(cwd ? [{ provider: 'claude', scope: 'project', root: path.join(cwd, '.claude', 'skills'), requireDescription: false }] : []),
-    ...getClaudePluginSkillRoots()
+    ...claudePluginRoots
       .filter(item => cwd || item.scope !== 'project')
       .map(item => ({
         provider: 'claude-plugins',
@@ -329,7 +423,7 @@ function discoverOmpSkills(service, options = {}) {
   const discovered = [];
   for (const descriptor of descriptors) {
     if (!providerEnabled(settings, descriptor.provider, descriptor.scope)) continue;
-    discovered.push(...scanOneLevel(service, descriptor.root, descriptor, settings));
+    discovered.push(...scanOneLevel(service, descriptor.root, descriptor, settings, cwd));
   }
 
   const customDirectories = Array.isArray(settings.customDirectories)
@@ -338,18 +432,51 @@ function discoverOmpSkills(service, options = {}) {
   for (const customDirectory of customDirectories) {
     const expanded = expandHome(customDirectory);
     const root = path.isAbsolute(expanded)
-      ? expanded
+      ? path.resolve(expanded)
       : path.resolve(cwd || process.cwd(), expanded);
+    const relative = cwd ? path.relative(cwd, root) : '..';
+    const isProjectRoot = Boolean(
+      cwd
+      && relative !== '..'
+      && !relative.startsWith(`..${path.sep}`)
+      && !path.isAbsolute(relative)
+    );
     discovered.push(...scanOneLevel(service, root, {
       provider: 'custom',
-      scope: cwd && root.startsWith(`${cwd}${path.sep}`) ? 'project' : 'user',
+      scope: isProjectRoot ? 'project' : 'user',
       requireDescription: true
-    }, settings));
+    }, settings, isProjectRoot ? cwd : null));
   }
 
   return deduplicateDiscoveredSkills(discovered);
 }
 
+function discoverOmpSkills(service, options = {}) {
+  const scope = options.scope || 'user';
+  const cwd = options.cwd ? canonicalCwd(options.cwd) : null;
+  const settings = readEffectiveSettings(cwd, { force: options.force === true, scope });
+  if (settings.enabled === false) return [];
+  const pluginPaths = getPluginInstallPaths(cwd, { force: options.force === true, scope });
+  const claudePluginRoots = getClaudePluginSkillRoots();
+  const fingerprint = JSON.stringify({
+    settings,
+    pluginPaths,
+    claudePluginRoots,
+    pathContext: options.pathContext?.customized ? options.pathContext : null
+  });
+  const key = cacheKey(cwd, scope);
+  const now = Date.now();
+  const cached = discoveryCache.get(key);
+  if (!options.force && cached
+    && cached.fingerprint === fingerprint
+    && now - cached.checkedAt < DISCOVERY_CACHE_TTL_MS) {
+    return cloneSkills(cached.skills);
+  }
+  const discovered = _discoverOmpSkills(service, { ...options, cwd, scope }, settings, pluginPaths, claudePluginRoots);
+  discoveryCache.set(key, { fingerprint, checkedAt: now, skills: cloneSkills(discovered) });
+  return cloneSkills(discovered);
+}
+
 module.exports = {
   DEFAULT_SKILL_SETTINGS,
   discoverOmpSkills,