@fprad0/skill-master-mcp 0.0.9 → 0.0.10

package/bin/skill-master-bootstrap-global.mjs

@@ -6,6 +6,20 @@ import { fileURLToPath } from 'node:url';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const rootDir = dirname(here);
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`Skill Master global bootstrap
+
+Uso:
+  skill-master-bootstrap-global
+
+Instala as skills globais embutidas e registra o MCP skill_master em Codex,
+Claude Desktop, Gemini e Antigravity usando o binario global skill-master-mcp.
+Reinicie os clientes depois da execucao.
+`);
+  process.exit(0);
+}
 
 const steps = [
   {
@@ -32,4 +46,3 @@ for (const step of steps) {
 if ((process.exitCode ?? 0) === 0) {
   console.log('[skill_master] Global bootstrap complete.');
 }
-

package/bin/skill-master-doctor.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(here, '..');
+const args = process.argv.slice(2);
+const has = (flag) => args.includes(flag);
+
+if (has('--help') || has('-h')) {
+  console.log(`Skill Master Doctor
+
+Uso:
+  skill-master-doctor
+  skill-master-doctor --strict
+
+Valida pacote, binarios, skills globais e registro MCP em Codex, Claude,
+Gemini e Antigravity. Nao publica versoes e nao altera configuracoes.
+`);
+  process.exit(0);
+}
+
+const REQUIRED_GLOBAL_SKILLS = [
+  'catholic-moral-discernment',
+  'ai-ethics-human-dignity',
+  'professional-boundary-triage',
+  'broad-domain-router',
+  'language-quality-pt-en-fr',
+  'math-science-reasoning',
+  'philosophy-sociology-discernment',
+  'engineering-systems-master',
+  'source-authority-reviewer',
+  'release-ethics-gate',
+  'mcp-client-readiness',
+  'terminal-menu-operations',
+  'terminal-pixel-art-tui',
+];
+
+const REQUIRED_BINS = [
+  'skill-master-menu',
+  'skill-master-mcp',
+  'skill-master-update',
+  'skill-master-bootstrap-global',
+  'skill-master-install-global-skills',
+  'skill-master-register-clients',
+  'skill-master-doctor',
+];
+
+function defaultClaudeConfigPath() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+
+  return path.join(os.homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+function readJson(filePath) {
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, 'utf8').trim();
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return null;
+  }
+}
+
+function commandExists(command) {
+  const lookup = process.platform === 'win32' ? 'where' : 'command';
+  const lookupArgs = process.platform === 'win32' ? [command] : ['-v', command];
+  const result = spawnSync(lookup, lookupArgs, { shell: process.platform !== 'win32', stdio: 'ignore' });
+  return result.status === 0;
+}
+
+function jsonClientState(filePath) {
+  const parsed = readJson(filePath);
+  const server = parsed?.mcpServers?.skill_master;
+  return {
+    filePath,
+    present: Boolean(parsed),
+    configured: server?.command === 'skill-master-mcp',
+    command: server?.command ?? null,
+  };
+}
+
+function codexState(filePath) {
+  if (!existsSync(filePath)) {
+    return { filePath, present: false, configured: false, command: null };
+  }
+
+  const content = readFileSync(filePath, 'utf8');
+  return {
+    filePath,
+    present: true,
+    configured: content.includes('[mcp_servers.skill_master]') && content.includes('command = "skill-master-mcp"'),
+    command: content.includes('skill-master-mcp') ? 'skill-master-mcp' : null,
+  };
+}
+
+function resultLine(ok, label, detail) {
+  const marker = ok ? 'OK' : 'NO';
+  return `[${marker}] ${label}${detail ? ` - ${detail}` : ''}`;
+}
+
+const packageJson = readJson(path.join(rootDir, 'package.json'));
+const globalSkillsRoot = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'skills');
+const installedSkills = REQUIRED_GLOBAL_SKILLS.filter((skill) => existsSync(path.join(globalSkillsRoot, skill, 'SKILL.md')));
+const missingSkills = REQUIRED_GLOBAL_SKILLS.filter((skill) => !installedSkills.includes(skill));
+
+const clients = [
+  ['Codex', codexState(path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'config.toml'))],
+  ['Claude Desktop', jsonClientState(defaultClaudeConfigPath())],
+  ['Gemini CLI', jsonClientState(path.join(os.homedir(), '.gemini', 'settings.json'))],
+  ['Antigravity', jsonClientState(path.join(os.homedir(), '.gemini', 'config', 'mcp_config.json'))],
+];
+
+const binResults = REQUIRED_BINS.map((bin) => [bin, commandExists(bin)]);
+const allBinsOk = binResults.every(([, ok]) => ok);
+const allSkillsOk = missingSkills.length === 0;
+const allClientsOk = clients.every(([, state]) => state.configured);
+const packageOk = packageJson?.name === '@fprad0/skill-master-mcp';
+
+console.log('Skill Master Doctor');
+console.log(`- Root: ${rootDir}`);
+console.log(`- Package: ${packageJson?.name ?? 'unknown'}@${packageJson?.version ?? 'unknown'}`);
+console.log('');
+
+console.log(resultLine(packageOk, 'Pacote local reconhecido', packageOk ? packageJson.version : 'package.json inesperado'));
+console.log(resultLine(allBinsOk, 'Binarios globais no PATH', binResults.filter(([, ok]) => !ok).map(([bin]) => bin).join(', ') || 'todos encontrados'));
+for (const [bin, ok] of binResults) {
+  console.log(`  ${resultLine(ok, bin)}`);
+}
+
+console.log('');
+console.log(resultLine(allSkillsOk, `Skills globais ${installedSkills.length}/${REQUIRED_GLOBAL_SKILLS.length}`, missingSkills.join(', ') || 'todas instaladas'));
+console.log(`- Skills root: ${globalSkillsRoot}`);
+
+console.log('');
+for (const [name, state] of clients) {
+  const detail = state.configured
+    ? state.filePath
+    : state.present
+      ? `presente, mas command=${state.command ?? 'nao encontrado'} em ${state.filePath}`
+      : `ausente em ${state.filePath}`;
+  console.log(resultLine(state.configured, `${name} configurado`, detail));
+}
+
+const ready = packageOk && allBinsOk && allSkillsOk && allClientsOk;
+console.log('');
+console.log(resultLine(ready, 'Readiness global', ready ? 'pronto' : 'requer acao'));
+
+if (!ready) {
+  console.log('');
+  console.log('Proximo comando recomendado:');
+  console.log('  skill-master-menu --run bootstrap-global --yes');
+  console.log('');
+  console.log('Depois reinicie Codex, Claude, Gemini e Antigravity.');
+}
+
+if (has('--strict') && !ready) {
+  process.exitCode = 1;
+}

package/bin/skill-master-install-global-skills.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(here, '..');
-const defaultSource = path.join(rootDir, 'docs', 'skill-candidates', 'v0.0.9');
+const defaultSource = path.join(rootDir, 'docs', 'skill-candidates');
 const defaultTarget = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'skills');
 
 const args = process.argv.slice(2);
@@ -24,8 +24,11 @@ Uso:
   skill-master-install-global-skills --overwrite
   skill-master-install-global-skills --dry-run
   skill-master-install-global-skills --target ~/.codex/skills
+  skill-master-install-global-skills --source ./docs/skill-candidates/v0.0.10
 
 Instala as skills globais embutidas em CODEX_HOME/skills ou ~/.codex/skills.
+Quando --source aponta para docs/skill-candidates, todas as pastas versionadas v*
+sao lidas.
 `);
   process.exit(0);
 }
@@ -40,10 +43,28 @@ if (!existsSync(source)) {
   process.exit(1);
 }
 
-const skills = readdirSync(source, { withFileTypes: true })
-  .filter((entry) => entry.isDirectory())
-  .map((entry) => entry.name)
-  .sort();
+const listSkillSources = (sourcePath) => {
+  const entries = readdirSync(sourcePath, { withFileTypes: true });
+  const directSkills = entries
+    .filter((entry) => entry.isDirectory() && existsSync(path.join(sourcePath, entry.name, 'SKILL.md')))
+    .map((entry) => ({ name: entry.name, path: path.join(sourcePath, entry.name) }));
+
+  if (directSkills.length) {
+    return directSkills;
+  }
+
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .flatMap((entry) => {
+      const versionPath = path.join(sourcePath, entry.name);
+      return readdirSync(versionPath, { withFileTypes: true })
+        .filter((skillEntry) => skillEntry.isDirectory() && existsSync(path.join(versionPath, skillEntry.name, 'SKILL.md')))
+        .map((skillEntry) => ({ name: skillEntry.name, path: path.join(versionPath, skillEntry.name) }));
+    })
+    .sort((left, right) => left.name.localeCompare(right.name));
+};
+
+const skills = listSkillSources(source);
 
 if (!dryRun) {
   mkdirSync(target, { recursive: true });
@@ -53,16 +74,16 @@ const installed = [];
 const skipped = [];
 
 for (const skill of skills) {
-  const from = path.join(source, skill);
-  const to = path.join(target, skill);
+  const from = skill.path;
+  const to = path.join(target, skill.name);
   if (existsSync(to) && !overwrite) {
-    skipped.push(skill);
+    skipped.push(skill.name);
     continue;
   }
   if (!dryRun) {
     cpSync(from, to, { recursive: true, force: overwrite });
   }
-  installed.push(skill);
+  installed.push(skill.name);
 }
 
 console.log('[skill_master] Global skills installer');
@@ -74,4 +95,3 @@ if (dryRun) console.log('- Dry run: no files were written.');
 if (installed.length) console.log(`- Installed skills: ${installed.join(', ')}`);
 if (skipped.length) console.log(`- Skipped skills: ${skipped.join(', ')}`);
 console.log('[skill_master] Restart or rescan Codex to load new global skills.');
-

package/bin/skill-master-menu.mjs

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 
 import prompts from 'prompts';
+import readline from 'node:readline';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
-  buildMenuChoices,
   buildMenuCommands,
   formatActionHeader,
+  formatCyberMenuFrame,
   formatHelp,
-  formatMenuBanner,
+  formatRunningActionFrame,
   formatResultMessage,
   formatStatusReport,
   getMenuStatus,
@@ -20,6 +21,19 @@ import {
 const currentFile = fileURLToPath(import.meta.url);
 const rootDir = dirname(dirname(currentFile));
 const commands = buildMenuCommands({ rootDir, currentFile });
+readline.emitKeypressEvents(process.stdin);
+const CONTROL = {
+  alternateScreenIn: '\x1b[?1049h',
+  alternateScreenOut: '\x1b[?1049l',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+  cursorHome: '\x1b[H',
+  clearScreen: '\x1b[2J',
+  clearToEnd: '\x1b[0J',
+  reset: '\x1b[0m',
+  syncStart: '\x1b[?2026h',
+  syncEnd: '\x1b[?2026l',
+};
 
 function parseArgs(argv) {
   const parsed = {
@@ -62,6 +76,10 @@ function printStatus() {
 }
 
 async function runSelectedAction(action, { yes = false, useColor = false } = {}) {
+  if (action.disabledReason) {
+    throw new Error(`Action ${action.key} is unavailable here: ${action.disabledReason}`);
+  }
+
   if (action.confirmMessage && !yes) {
     if (!isInteractiveTerminal()) {
       throw new Error(`Action ${action.key} requires --yes outside an interactive terminal.`);
@@ -88,47 +106,177 @@ async function runSelectedAction(action, { yes = false, useColor = false } = {})
   return { cancelled: false, code };
 }
 
-async function runVisualMenu() {
-  while (true) {
-    console.clear();
-    const status = getMenuStatus(rootDir);
-    console.log(formatMenuBanner(status, { useColor: true }));
-    console.log('');
-
-    const selection = await prompts({
-      type: 'select',
-      name: 'action',
-      message: 'Escolha uma acao',
-      choices: buildMenuChoices(commands),
-      initial: 0,
-    });
+const readKey = () => new Promise((resolve) => {
+  process.stdin.once('keypress', (_str, key) => resolve(key));
+});
 
-    if (!selection.action || selection.action === '__exit__') {
-      return 0;
+function createKeyReader() {
+  const queue = [];
+  const waiters = [];
+  const onKeypress = (_str, key) => {
+    const waiter = waiters.shift();
+    if (waiter) {
+      clearTimeout(waiter.timer);
+      waiter.resolve(key);
+      return;
     }
+    queue.push(key);
+  };
 
-    const action = commands.find((entry) => entry.key === selection.action);
-    if (!action) {
-      return 1;
-    }
+  process.stdin.on('keypress', onKeypress);
 
-    const result = await runSelectedAction(action, { useColor: true });
-    if (result.cancelled) {
-      continue;
-    }
+  return {
+    read(timeoutMs) {
+      if (queue.length) return Promise.resolve(queue.shift());
+      return new Promise((resolve) => {
+        const waiter = {
+          resolve,
+          timer: setTimeout(() => {
+            const index = waiters.indexOf(waiter);
+            if (index >= 0) waiters.splice(index, 1);
+            resolve(null);
+          }, timeoutMs),
+        };
+        waiters.push(waiter);
+      });
+    },
+    close() {
+      for (const waiter of waiters.splice(0)) {
+        clearTimeout(waiter.timer);
+        waiter.resolve(null);
+      }
+      process.stdin.off('keypress', onKeypress);
+    },
+  };
+}
 
-    const nextStep = await prompts({
-      type: 'toggle',
-      name: 'keepGoing',
-      message: 'Voltar ao menu?',
-      initial: true,
-      active: 'sim',
-      inactive: 'nao',
-    });
+function setRawInput(enabled) {
+  if (typeof process.stdin.setRawMode === 'function') {
+    process.stdin.setRawMode(enabled);
+  }
+  if (enabled) process.stdin.resume();
+}
+
+function restoreMenuInput() {
+  setRawInput(true);
+  process.stdin.resume();
+}
+
+function enterVisualScreen() {
+  process.stdout.write(`${CONTROL.alternateScreenIn}${CONTROL.hideCursor}${CONTROL.clearScreen}${CONTROL.cursorHome}`);
+}
+
+function leaveVisualScreen() {
+  process.stdout.write(`${CONTROL.reset}${CONTROL.showCursor}${CONTROL.alternateScreenOut}`);
+}
+
+function writeStableFrame(frame, { clear = false } = {}) {
+  const prefix = clear ? CONTROL.clearScreen : '';
+  process.stdout.write([
+    CONTROL.syncStart,
+    CONTROL.cursorHome,
+    prefix,
+    frame,
+    '\n',
+    CONTROL.clearToEnd,
+    CONTROL.syncEnd,
+  ].join(''));
+}
+
+function renderCyberMenu(selectedIndex, tick, { clear = false } = {}) {
+  const status = getMenuStatus(rootDir);
+  const frame = formatCyberMenuFrame(status, commands, selectedIndex, tick, {
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 32,
+    useColor: true,
+  });
+  writeStableFrame(frame, { clear });
+}
+
+function renderRunningAction(action, tick) {
+  const status = getMenuStatus(rootDir);
+  const frame = formatRunningActionFrame(status, action, tick, {
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 32,
+    useColor: true,
+  });
+  writeStableFrame(frame, { clear: true });
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitForAnyKey(message = 'Pressione qualquer tecla para voltar ao menu...') {
+  process.stdout.write(`\n${message}`);
+  setRawInput(true);
+  await readKey();
+  setRawInput(false);
+}
+
+async function runVisualMenu() {
+  let selectedIndex = 0;
+  let tick = 0;
+  let lastCode = 0;
+  let keyReader = createKeyReader();
+  let previousColumns = process.stdout.columns ?? 120;
+  let previousRows = process.stdout.rows ?? 32;
+  let needsClear = true;
+
+  enterVisualScreen();
+  restoreMenuInput();
+
+  try {
+    while (true) {
+      const columns = process.stdout.columns ?? 120;
+      const rows = process.stdout.rows ?? 32;
+      const resized = columns !== previousColumns || rows !== previousRows;
+      previousColumns = columns;
+      previousRows = rows;
+      renderCyberMenu(selectedIndex, tick, { clear: needsClear || resized });
+      needsClear = false;
+      const key = await keyReader.read(240);
+
+      if (!key) {
+        tick += 1;
+        continue;
+      }
 
-    if (!nextStep.keepGoing) {
-      return result.code;
+      if (key.ctrl && key.name === 'c') return 130;
+      if (key.name === 'escape' || key.name === 'q') return lastCode;
+      if (key.name === 'up' || key.name === 'k') {
+        selectedIndex = selectedIndex === 0 ? commands.length - 1 : selectedIndex - 1;
+        continue;
+      }
+      if (key.name === 'down' || key.name === 'j') {
+        selectedIndex = selectedIndex === commands.length - 1 ? 0 : selectedIndex + 1;
+        continue;
+      }
+      if (key.name === 'return' || key.name === 'enter') {
+        const action = commands[selectedIndex];
+        keyReader.close();
+        renderRunningAction(action, tick);
+        await sleep(180);
+        setRawInput(false);
+        leaveVisualScreen();
+        try {
+          const result = await runSelectedAction(action, { useColor: true });
+          lastCode = result.code;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          process.stderr.write(`[skill_master] ${message}\n`);
+          lastCode = 1;
+        }
+        await waitForAnyKey();
+        keyReader = createKeyReader();
+        restoreMenuInput();
+        enterVisualScreen();
+        needsClear = true;
+      }
     }
+  } finally {
+    keyReader.close();
+    setRawInput(false);
+    process.stdin.pause();
+    leaveVisualScreen();
   }
 }
 

package/bin/skill-master-register-clients.mjs

@@ -18,6 +18,7 @@ Uso:
   skill-master-register-clients --apply-codex
   skill-master-register-clients --apply-claude
   skill-master-register-clients --apply-gemini
+  skill-master-register-clients --apply-antigravity
   skill-master-register-clients --apply-all
   skill-master-register-clients --apply-codex --force
 
@@ -30,14 +31,25 @@ Registra o servidor MCP skill_master como stdio usando o binario global:
 const home = os.homedir();
 const snippetsDir = readValue('--snippets-dir', path.join(home, '.skill-master', 'client-configs'));
 const codexConfig = readValue('--codex-config', path.join(process.env.CODEX_HOME ?? path.join(home, '.codex'), 'config.toml'));
-const claudeConfig = readValue('--claude-config', path.join(home, '.config', 'Claude', 'claude_desktop_config.json'));
+const defaultClaudeConfig = () => {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA ?? path.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+  return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+};
+const claudeConfig = readValue('--claude-config', defaultClaudeConfig());
 const geminiConfig = readValue('--gemini-config', path.join(home, '.gemini', 'settings.json'));
+const antigravityConfig = readValue('--antigravity-config', path.join(home, '.gemini', 'config', 'mcp_config.json'));
 
 const applyAll = has('--apply-all');
 const applyCodex = applyAll || has('--apply-codex');
 const applyClaude = applyAll || has('--apply-claude');
 const applyGemini = applyAll || has('--apply-gemini');
-const writeSnippets = applyAll || has('--write-snippets') || !(applyCodex || applyClaude || applyGemini);
+const applyAntigravity = applyAll || has('--apply-antigravity');
+const writeSnippets = applyAll || has('--write-snippets') || !(applyCodex || applyClaude || applyGemini || applyAntigravity);
 const force = has('--force');
 
 const mcpServer = {
@@ -69,6 +81,12 @@ const geminiSnippet = {
   },
 };
 
+const antigravitySnippet = {
+  mcpServers: {
+    skill_master: mcpServer,
+  },
+};
+
 const ensureParent = (filePath) => mkdirSync(path.dirname(filePath), { recursive: true });
 
 const readJsonOrEmpty = (filePath) => {
@@ -99,6 +117,7 @@ const writeSnippetsFiles = () => {
   writeFileSync(path.join(snippetsDir, 'codex.config.toml'), codexBlock.trimStart(), 'utf8');
   writeJson(path.join(snippetsDir, 'claude_desktop_config.skill_master.json'), claudeSnippet);
   writeJson(path.join(snippetsDir, 'gemini.settings.skill_master.json'), geminiSnippet);
+  writeJson(path.join(snippetsDir, 'antigravity.mcp_config.skill_master.json'), antigravitySnippet);
 };
 
 const removeCodexBlock = (content) => {
@@ -146,9 +165,13 @@ if (applyGemini) {
   mergeMcpServer(geminiConfig);
   actions.push(`Gemini config merged at ${geminiConfig}`);
 }
+if (applyAntigravity) {
+  mergeMcpServer(antigravityConfig);
+  actions.push(`Antigravity config merged at ${antigravityConfig}`);
+}
 
 console.log('[skill_master] Client registration');
 for (const action of actions) {
   console.log(`- ${action}`);
 }
-console.log('- Restart Codex, Claude or Gemini after registration.');
+console.log('- Restart Codex, Claude, Gemini or Antigravity after registration.');

package/dist/index.js

@@ -28,7 +28,7 @@ const contributionsDir = process.env.SKILL_MASTER_CONTRIBUTIONS_DIR
     ?? path.join(skillMasterHome, 'data', 'contributions');
 const successLearningDir = process.env.SKILL_MASTER_SUCCESS_LEARNING_DIR
     ?? path.join(skillMasterHome, 'data', 'success-learning');
-const bundledGlobalSkillsDir = path.join(projectRoot, 'docs', 'skill-candidates', 'v0.0.9');
+const bundledGlobalSkillsDir = path.join(projectRoot, 'docs', 'skill-candidates');
 const workspace = process.env.SKILL_MASTER_WORKSPACE ?? process.cwd();
 const userGlobalSkillsDir = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'), 'skills');
 const workspaceLocalSkillsDir = path.join(workspace, '.codex', 'skills');
@@ -58,6 +58,31 @@ const refresh = async (includeWeb) => {
     await saveSnapshot(updated);
     return updated;
 };
+const listBundledGlobalSkillSources = async (sourceRoot) => {
+    const entries = await fs.readdir(sourceRoot, { withFileTypes: true }).catch(() => []);
+    const directSkills = [];
+    for (const entry of entries.filter((item) => item.isDirectory())) {
+        const skillPath = path.join(sourceRoot, entry.name);
+        const hasSkill = await fs.access(path.join(skillPath, 'SKILL.md')).then(() => true).catch(() => false);
+        if (hasSkill)
+            directSkills.push({ name: entry.name, path: skillPath });
+    }
+    if (directSkills.length) {
+        return directSkills.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    const versionedSkills = [];
+    for (const versionEntry of entries.filter((item) => item.isDirectory())) {
+        const versionPath = path.join(sourceRoot, versionEntry.name);
+        const skillEntries = await fs.readdir(versionPath, { withFileTypes: true }).catch(() => []);
+        for (const skillEntry of skillEntries.filter((item) => item.isDirectory())) {
+            const skillPath = path.join(versionPath, skillEntry.name);
+            const hasSkill = await fs.access(path.join(skillPath, 'SKILL.md')).then(() => true).catch(() => false);
+            if (hasSkill)
+                versionedSkills.push({ name: skillEntry.name, path: skillPath });
+        }
+    }
+    return versionedSkills.sort((left, right) => left.name.localeCompare(right.name));
+};
 await refresh(false).catch(() => snapshot);
 const response = (data, markdown) => ({
     content: [{ type: 'text', text: markdown.slice(0, CHARACTER_LIMIT) }],
@@ -363,7 +388,7 @@ server.registerTool('skill_master_domain_router', {
 });
 server.registerTool('skill_master_install_global_skills', {
     title: 'Install bundled Skill Master global skills',
-    description: 'Install the bundled Skill Master v0.0.9 skills into the user-global Codex skills directory. This makes them available to Codex after restart/rescan.',
+    description: 'Install the bundled versioned Skill Master skills into the user-global Codex skills directory. This makes them available to Codex after restart/rescan.',
     inputSchema: {
         overwrite: z.boolean().default(false),
         confirm_install: z.boolean().default(false),
@@ -386,12 +411,12 @@ server.registerTool('skill_master_install_global_skills', {
             `Target: ${userGlobalSkillsDir}`,
         ].join('\n'));
     }
-    const entries = await fs.readdir(bundledGlobalSkillsDir, { withFileTypes: true }).catch(() => []);
+    const entries = await listBundledGlobalSkillSources(bundledGlobalSkillsDir);
     await fs.mkdir(userGlobalSkillsDir, { recursive: true });
     const installed = [];
     const skipped = [];
-    for (const entry of entries.filter((item) => item.isDirectory())) {
-        const source = path.join(bundledGlobalSkillsDir, entry.name);
+    for (const entry of entries) {
+        const source = entry.path;
         const target = path.join(userGlobalSkillsDir, entry.name);
         const targetExists = await fs.access(target).then(() => true).catch(() => false);
         if (targetExists && !overwrite) {