@fprad0/skill-master-mcp 0.0.10 → 0.0.11

package/CHANGELOG.md

@@ -4,7 +4,11 @@ All notable changes to `skill_master` will be tracked here.
 
 ## [Unreleased]
 
-- Await explicit authorization before the next npm publication.
+## [0.0.11] - 2026-06-28
+
+- Register MCP clients with an absolute Node.js executable plus the absolute `bin/skill-master.mjs` entrypoint, avoiding PATH-dependent startup failures in Windows, Linux, macOS, and desktop MCP clients.
+- Add shared client-config helpers, Codex/JSON config assessment, doctor reporting for robust vs legacy registration modes, and a menu action matrix verifier.
+- Add a second bundled global skill pack `v0.0.11` with more granular language, data, terminal, Git, OS, MCP client and UI/design skills for global installation.
 
 ## [0.0.10] - 2026-06-28
 

package/README.md

@@ -108,13 +108,12 @@ npm install -g @fprad0/skill-master-mcp
 npx -y @fprad0/skill-master-mcp@latest
 ```
 
-Estado atual preparado em `2026-06-28`:
+Fluxo atual:
 
-- release publica: `@fprad0/skill-master-mcp@0.0.9`
-- `latest` no npmjs aponta para `0.0.9`
-- validacao de pacote por tarball local confirmada
-- validacao de instalacao publica via `npm install @fprad0/skill-master-mcp@0.0.9` confirmada
-- preparacao local seguinte: `0.0.10`, focada em confiabilidade do menu, doctor, Antigravity e separacao entre acoes globais e acoes de desenvolvimento
+- instalacao publica simples por `npm install -g @fprad0/skill-master-mcp`
+- execucao sem install global por `npx -y @fprad0/skill-master-mcp@latest`
+- validacao rapida da versao publicada por `npm view @fprad0/skill-master-mcp version --registry=https://registry.npmjs.org`
+- esta linha de release amplia o bundle global para `v0.0.11` e endurece o registro MCP multi-cliente com Node absoluto
 
 Comandos globais principais:
 
@@ -157,7 +156,7 @@ skill-master-menu --run notion-summary
 
 O menu visual usa `prompts` para ficar mais legivel no terminal e manter compatibilidade com `Node 18+`.
 
-Quando o menu detectar que o MCP ainda nao esta globalmente pronto neste computador, ele mostra um alerta forte e um aviso sutil explicando que a instalacao global e o registro dos clientes sao necessarios para o `skill_master` parecer parte do sistema em Codex, Claude e Gemini.
+Quando o menu detectar que o MCP ainda nao esta globalmente pronto neste computador, ele mostra um alerta forte e um aviso sutil explicando que a instalacao global e o registro dos clientes sao necessarios para o `skill_master` parecer parte do sistema em Codex, Claude, Gemini e Antigravity.
 
 Em instalacoes globais via npm, o menu tambem separa acoes operacionais de acoes de desenvolvimento. Acoes como `check` e `build` dependem do clone completo do repositorio; quando o pacote estiver instalado globalmente, use:
 
@@ -173,7 +172,9 @@ Para instalar as skills globais embutidas de discernimento, conhecimento amplo,
 skill-master-install-global-skills
 ```
 
-No estado atual do pacote, esse bundle global tambem inclui cobertura para frontend, backend, CLI, terminal, GitHub, Windows/Linux, clientes MCP, design, Figma, Playwright, idiomas e raciocinio tecnico, usando uma combinacao de skills locais aprovadas e skills oficiais empacotadas em `docs/skill-candidates/v0.0.10`.
+No estado atual do pacote, esse bundle global tambem inclui cobertura para frontend, backend, CLI, terminal, GitHub, Windows/Linux, clientes MCP, design, Figma, Playwright, idiomas e raciocinio tecnico, usando uma combinacao de skills locais aprovadas e skills oficiais empacotadas em `docs/skill-candidates/v0.0.10` e `docs/skill-candidates/v0.0.11`.
+
+O pacote `v0.0.11` amplia a granularidade com skills dedicadas para TypeScript, Python, JavaScript, Java, Ruby, Go, SQL/PostgreSQL, contratos JSON, Git, shell/terminal, Windows/Linux, operacao multi-cliente MCP, componentes UI e sistemas web/mobile.
 
 Para fazer o bootstrap global completo em um passo:
 
@@ -181,7 +182,7 @@ Para fazer o bootstrap global completo em um passo:
 skill-master-bootstrap-global
 ```
 
-Para registrar o MCP nos clientes principais usando o binario global `skill-master-mcp`:
+Para registrar o MCP nos clientes principais, use o registrador. Ele grava `command` com o Node.js absoluto e `args` com o caminho absoluto de `bin/skill-master.mjs`, evitando falhas de `PATH` em Windows, Linux, macOS e apps desktop que nao herdam o terminal:
 
 ```bash
 skill-master-register-clients --apply-codex
@@ -198,6 +199,25 @@ skill-master-register-clients --apply-all
 
 Isso configura o servidor MCP `skill_master` em Codex, Claude Desktop, Gemini e Antigravity quando os arquivos de configuracao locais estiverem disponiveis. Reinicie o cliente depois do registro.
 
+Se um cliente ja tiver uma configuracao antiga por `skill-master-mcp`, `npx` ou launcher local e nao estiver iniciando, force a migracao para o modo robusto:
+
+```bash
+skill-master-register-clients --apply-all --force
+skill-master-menu --run doctor
+```
+
+No Codex, o bloco recomendado fica no formato:
+
+```toml
+[mcp_servers.skill_master]
+command = "/caminho/absoluto/para/node"
+args = ["/caminho/absoluto/para/bin/skill-master.mjs"]
+startup_timeout_sec = 120
+
+[mcp_servers.skill_master.env]
+SKILL_MASTER_UPDATE_CHANNEL = "stable"
+```
+
 O menu tambem mostra notificacoes de skills aprendidas pendentes e links externos para estudo. As acoes de ativacao sao:
 
 - `skill-master-menu --run activate-learned-local`: instala uma skill aprovada em `.codex/skills` do workspace atual.

package/VERSION.md

@@ -1,9 +1,9 @@
 # Versão
 
-Versão funcional planejada: `00.04`
+Versão funcional planejada: `00.05`
 
-Versão técnica para empacotamento semântico: `0.0.10`
+Versão técnica para empacotamento semântico: `0.0.11`
 
 ## Observação
 
-O nome `00.04` será usado na comunicação e nos documentos. Para ferramentas que exigem SemVer, como npm e alguns fluxos de release, usar `0.0.10`.
+O nome `00.05` será usado na comunicação e nos documentos. Para ferramentas que exigem SemVer, como npm e alguns fluxos de release, usar `0.0.11`.

package/bin/lib/client-config.mjs

@@ -0,0 +1,268 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+export const DEFAULT_SERVER_ENV = {
+  SKILL_MASTER_UPDATE_CHANNEL: 'stable',
+};
+
+export function defaultClaudeConfigPath(home = os.homedir(), platform = process.platform) {
+  if (platform === 'win32') {
+    return path.join(process.env.APPDATA ?? path.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+
+  if (platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+
+  return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+export function defaultClientConfigPaths({
+  home = os.homedir(),
+  env = process.env,
+  platform = process.platform,
+} = {}) {
+  return {
+    codex: path.join(env.CODEX_HOME ?? path.join(home, '.codex'), 'config.toml'),
+    claude: defaultClaudeConfigPath(home, platform),
+    gemini: path.join(home, '.gemini', 'settings.json'),
+    antigravity: path.join(home, '.gemini', 'config', 'mcp_config.json'),
+  };
+}
+
+export function buildSkillMasterServerConfig({
+  rootDir,
+  nodeExecPath = process.execPath,
+  env = DEFAULT_SERVER_ENV,
+} = {}) {
+  const packageRoot = rootDir ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+  const serverEntry = path.join(packageRoot, 'bin', 'skill-master.mjs');
+
+  return {
+    command: nodeExecPath,
+    args: [serverEntry],
+    env: { ...env },
+    metadata: {
+      mode: 'absolute-node',
+      packageRoot,
+      serverEntry,
+    },
+  };
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function tomlStringArray(values) {
+  return `[${values.map((value) => tomlString(value)).join(', ')}]`;
+}
+
+export function buildCodexBlock(serverConfig) {
+  const envEntries = Object.entries(serverConfig.env ?? {});
+  const envBlock = envEntries.length
+    ? `\n[mcp_servers.skill_master.env]\n${envEntries.map(([key, value]) => `${key} = ${tomlString(value)}`).join('\n')}\n`
+    : '';
+
+  return `
+[mcp_servers.skill_master]
+command = ${tomlString(serverConfig.command)}
+args = ${tomlStringArray(serverConfig.args ?? [])}
+startup_timeout_sec = 120
+${envBlock}`;
+}
+
+export function buildJsonMcpSnippet(serverConfig) {
+  return {
+    mcpServers: {
+      skill_master: {
+        command: serverConfig.command,
+        args: serverConfig.args ?? [],
+        env: serverConfig.env ?? {},
+      },
+    },
+  };
+}
+
+export function ensureParent(filePath) {
+  mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function backupPath(filePath) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return `${filePath}.invalid-${stamp}.bak`;
+}
+
+export function readJsonOrEmpty(filePath, { recoverInvalidJson = false } = {}) {
+  if (!existsSync(filePath)) return {};
+  const raw = readFileSync(filePath, 'utf8').trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    if (recoverInvalidJson) {
+      copyFileSync(filePath, backupPath(filePath));
+      return {};
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON at ${filePath}: ${message}`);
+  }
+}
+
+export function writeJson(filePath, value) {
+  ensureParent(filePath);
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+export function mergeMcpServer(filePath, serverConfig, options = {}) {
+  const current = readJsonOrEmpty(filePath, options);
+  const next = {
+    ...current,
+    mcpServers: {
+      ...(current.mcpServers ?? {}),
+      skill_master: buildJsonMcpSnippet(serverConfig).mcpServers.skill_master,
+    },
+  };
+  writeJson(filePath, next);
+}
+
+export function removeCodexSkillMasterBlock(content) {
+  const lines = String(content ?? '').split('\n');
+  const kept = [];
+  let skipping = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '[mcp_servers.skill_master]') {
+      skipping = true;
+      continue;
+    }
+    if (skipping && trimmed.startsWith('[') && !trimmed.startsWith('[mcp_servers.skill_master')) {
+      skipping = false;
+    }
+    if (!skipping) kept.push(line);
+  }
+  return kept.join('\n').trimEnd();
+}
+
+export function appendCodexServer(filePath, serverConfig, { force = false } = {}) {
+  ensureParent(filePath);
+  const current = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  if (current.includes('[mcp_servers.skill_master]') && !force) {
+    return false;
+  }
+  const base = force ? removeCodexSkillMasterBlock(current) : current.trimEnd();
+  writeFileSync(filePath, `${base}\n${buildCodexBlock(serverConfig)}`, 'utf8');
+  return true;
+}
+
+function normalizeSlashes(value) {
+  return String(value ?? '').replace(/\\/g, '/').toLowerCase();
+}
+
+function basename(value) {
+  const normalized = normalizeSlashes(value);
+  return normalized.split('/').pop() ?? '';
+}
+
+function isNodeCommand(command) {
+  const name = basename(command);
+  return name === 'node' || name === 'node.exe';
+}
+
+function hasSkillMasterEntryArg(args = []) {
+  return args.some((arg) => normalizeSlashes(arg).endsWith('/bin/skill-master.mjs'));
+}
+
+function hasLauncherArg(args = []) {
+  return args.some((arg) => {
+    const normalized = normalizeSlashes(arg);
+    return normalized.endsWith('/scripts/skill-master-launcher.ps1')
+      || normalized.endsWith('/scripts/skill-master-launcher.sh');
+  });
+}
+
+export function assessMcpServerConfig(server) {
+  if (!server?.command) {
+    return {
+      present: Boolean(server),
+      robust: false,
+      mode: server ? 'missing-command' : 'missing',
+      command: server?.command ?? null,
+    };
+  }
+
+  const command = String(server.command);
+  const args = Array.isArray(server.args) ? server.args : [];
+  const commandName = basename(command);
+  const normalizedCommand = normalizeSlashes(command);
+
+  if (isNodeCommand(command) && hasSkillMasterEntryArg(args)) {
+    return { present: true, robust: true, mode: 'absolute-node', command };
+  }
+
+  if (commandName === 'skill-master-mcp' || commandName === 'skill-master-mcp.cmd') {
+    return { present: true, robust: false, mode: 'path-bin', command };
+  }
+
+  if ((normalizedCommand.includes('powershell') || commandName === 'bash' || commandName === 'env') && hasLauncherArg(args)) {
+    return { present: true, robust: false, mode: 'launcher', command };
+  }
+
+  return { present: true, robust: false, mode: 'custom', command };
+}
+
+function parseTomlStringToken(token) {
+  const value = String(token ?? '').trim();
+  if (!value) return '';
+  if (value.startsWith('"')) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value.slice(1, -1);
+    }
+  }
+  if (value.startsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function parseTomlStringArray(value) {
+  const matches = [...String(value ?? '').matchAll(/"(?:\\.|[^"])*"|'[^']*'/g)];
+  return matches.map((match) => parseTomlStringToken(match[0]));
+}
+
+export function extractCodexSkillMasterServer(content) {
+  const lines = String(content ?? '').split('\n');
+  const block = [];
+  let collecting = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '[mcp_servers.skill_master]') {
+      collecting = true;
+      continue;
+    }
+    if (collecting && trimmed.startsWith('[')) {
+      break;
+    }
+    if (collecting) block.push(line);
+  }
+
+  if (!block.length) return null;
+
+  const commandLine = block.find((line) => line.trim().startsWith('command'));
+  const argsLine = block.find((line) => line.trim().startsWith('args'));
+  const commandToken = commandLine?.match(/=\s*("(?:\\.|[^"])*"|'[^']*')/)?.[1] ?? null;
+  const command = commandToken ? parseTomlStringToken(commandToken) : null;
+  const args = argsLine ? parseTomlStringArray(argsLine.split('=').slice(1).join('=')) : [];
+
+  return command ? { command, args } : null;
+}
+
+export function assessCodexConfigContent(content) {
+  return assessMcpServerConfig(extractCodexSkillMasterServer(content));
+}

package/bin/lib/menu-core.mjs

@@ -3,6 +3,11 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import os from 'node:os';
 import { join } from 'node:path';
 import process from 'node:process';
+import {
+  assessCodexConfigContent,
+  assessMcpServerConfig,
+  defaultClientConfigPaths,
+} from './client-config.mjs';
 
 const ANSI = {
   reset: '\x1b[0m',
@@ -63,11 +68,17 @@ const BUNDLED_SKILL_DOMAIN_GROUPS = [
       'figma-generate-library',
       'figma-implement-design',
       'figma-use',
+      'frontend-dev-guidelines',
       'frontend-design',
       'frontend-ui-ux-systems',
+      'nextjs',
       'playwright',
       'screenshot',
+      'senior-fullstack',
+      'shadcn',
+      'ui-component-primitives',
       'webapp-testing',
+      'web-mobile-design-systems',
       'winui-app',
     ],
   },
@@ -75,8 +86,16 @@ const BUNDLED_SKILL_DOMAIN_GROUPS = [
     key: 'backend',
     label: 'backend-data',
     skills: [
+      'go-engineering',
+      'java-engineering',
+      'javascript-engineering',
+      'json-contract-design',
       'mcp-builder',
       'polyglot-backend-engineering',
+      'python-engineering',
+      'ruby-engineering',
+      'sql-postgresql-engineering',
+      'typescript-expert',
     ],
   },
   {
@@ -85,12 +104,16 @@ const BUNDLED_SKILL_DOMAIN_GROUPS = [
     skills: [
       'cli-creator',
       'developer-workstation-ops',
+      'git-version-control-ops',
       'github',
       'mcp-client-readiness',
+      'multi-client-mcp-ops',
       'openai-docs',
       'skill-master-orchestrator',
+      'terminal-shell-ops',
       'terminal-menu-operations',
       'terminal-pixel-art-tui',
+      'windows-linux-platform-ops',
     ],
   },
   {
@@ -174,58 +197,45 @@ function readClientConfigState(filePath) {
   }
 
   const content = readFileSync(filePath, 'utf8');
-  const hasSkillMaster = content.includes('skill_master');
-  const hasGlobalCommand = content.includes('command = "skill-master-mcp"') || content.includes("command = 'skill-master-mcp'");
-  const hasLauncher = content.includes('skill-master-launcher');
+  const assessment = assessCodexConfigContent(content);
 
   return {
     present: true,
-    kind: hasGlobalCommand ? 'global' : hasLauncher ? 'launcher' : hasSkillMaster ? 'custom' : 'unknown',
-    globalCommand: hasGlobalCommand,
+    kind: assessment.mode,
+    globalCommand: assessment.robust,
+    command: assessment.command,
   };
 }
 
 function readJsonState(filePath) {
   if (!existsSync(filePath)) {
-    return { present: false, globalCommand: false };
+    return { present: false, kind: 'missing', globalCommand: false };
   }
 
   try {
     const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
     const server = parsed?.mcpServers?.skill_master;
+    const assessment = assessMcpServerConfig(server);
     return {
       present: true,
-      globalCommand: server?.command === 'skill-master-mcp',
+      kind: assessment.mode,
+      globalCommand: assessment.robust,
+      command: assessment.command,
     };
   } catch {
-    return { present: true, globalCommand: false };
-  }
-}
-
-function defaultClaudeConfigPath() {
-  if (process.platform === 'win32') {
-    return join(process.env.APPDATA ?? join(os.homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+    return { present: true, kind: 'invalid-json', globalCommand: false };
   }
-
-  if (process.platform === 'darwin') {
-    return join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
-  }
-
-  return join(os.homedir(), '.config', 'Claude', 'claude_desktop_config.json');
 }
 
 function inspectGlobalReadiness() {
   const root = globalSkillsRoot();
   const installed = REQUIRED_GLOBAL_SKILLS.filter((name) => existsSync(join(root, name, 'SKILL.md')));
   const missing = REQUIRED_GLOBAL_SKILLS.filter((name) => !installed.includes(name));
-  const codexConfigPath = join(process.env.CODEX_HOME ?? join(os.homedir(), '.codex'), 'config.toml');
-  const claudeConfigPath = defaultClaudeConfigPath();
-  const geminiConfigPath = join(os.homedir(), '.gemini', 'settings.json');
-  const antigravityConfigPath = join(os.homedir(), '.gemini', 'config', 'mcp_config.json');
-  const codex = readClientConfigState(codexConfigPath);
-  const claude = readJsonState(claudeConfigPath);
-  const gemini = readJsonState(geminiConfigPath);
-  const antigravity = readJsonState(antigravityConfigPath);
+  const clientPaths = defaultClientConfigPaths();
+  const codex = readClientConfigState(clientPaths.codex);
+  const claude = readJsonState(clientPaths.claude);
+  const gemini = readJsonState(clientPaths.gemini);
+  const antigravity = readJsonState(clientPaths.antigravity);
   const ready = missing.length === 0
     && codex.globalCommand
     && claude.globalCommand
@@ -233,7 +243,7 @@ function inspectGlobalReadiness() {
     && antigravity.globalCommand;
   const mode = ready
     ? 'ready'
-    : codex.kind === 'launcher' || claude.present || gemini.present || antigravity.present
+    : codex.present || claude.present || gemini.present || antigravity.present
       ? 'partial'
       : 'missing';
 
@@ -522,7 +532,7 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['register-clients', 'registrar-clientes', 'codex-claude-gemini', 'antigravity'],
       label: 'Registrar clientes MCP',
       description: 'Gera/aplica configuracoes MCP para Codex, Claude, Gemini e Antigravity reconhecerem skill_master.',
-      details: ['Usa o binario global skill-master-mcp.', 'Preserva outros servidores MCP ja existentes nos JSONs.'],
+      details: ['Usa Node absoluto + bin/skill-master.mjs absoluto.', 'Preserva outros servidores MCP ja existentes nos JSONs.'],
       success: 'Arquivos de configuracao mesclados com o servidor skill_master.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-register-clients.mjs'), '--apply-all'],
@@ -668,10 +678,10 @@ export function formatStatusReport(status) {
     `Global skills instaladas: ${readiness.installed.length}/${readiness.required}`,
     `Bundle de skills embutidas: ${bundledCatalog.total}`,
     `Dominios do bundle: ${formatBundledCategoryLine(bundledCatalog)}`,
-    `Codex global: ${readiness.codex.globalCommand ? 'sim' : readiness.codex.kind}`,
-    `Claude global: ${readiness.claude.globalCommand ? 'sim' : readiness.claude.present ? 'nao-global' : 'ausente'}`,
-    `Gemini global: ${readiness.gemini.globalCommand ? 'sim' : readiness.gemini.present ? 'nao-global' : 'ausente'}`,
-    `Antigravity global: ${readiness.antigravity.globalCommand ? 'sim' : readiness.antigravity.present ? 'nao-global' : 'ausente'}`,
+    `Codex MCP robusto: ${readiness.codex.globalCommand ? 'sim' : readiness.codex.kind}`,
+    `Claude MCP robusto: ${readiness.claude.globalCommand ? 'sim' : readiness.claude.kind}`,
+    `Gemini MCP robusto: ${readiness.gemini.globalCommand ? 'sim' : readiness.gemini.kind}`,
+    `Antigravity MCP robusto: ${readiness.antigravity.globalCommand ? 'sim' : readiness.antigravity.kind}`,
   ];
 
   if (status.versionText) {
@@ -688,8 +698,8 @@ function formatGlobalAlert(status, { useColor = false } = {}) {
     return renderPanelLines(
       [
         colorize('GLOBAL READY', ANSI.bold, useColor),
-        'O MCP esta reconhecido como comando global neste computador.',
-        'Codex, Claude, Gemini e Antigravity podem ser apontados para skill-master-mcp.',
+        'O MCP esta registrado de forma robusta neste computador.',
+        'Codex, Claude, Gemini e Antigravity podem iniciar com Node absoluto.',
         'A instalacao global e as skills embutidas ja estao prontas para uso.',
       ],
       { color: ANSI.green, useColor },
@@ -702,7 +712,7 @@ function formatGlobalAlert(status, { useColor = false } = {}) {
         colorize('ALERTA GLOBAL', ANSI.bold, useColor),
         'Este computador ainda nao esta pronto para uso global do Skill Master.',
         'Execute agora: skill-master-menu --run bootstrap-global --yes',
-        'Isso instala as skills globais e registra Codex, Claude, Gemini e Antigravity.',
+        'Isso instala as skills globais e registra Codex, Claude, Gemini e Antigravity com Node absoluto.',
       ],
       { color: ANSI.red, useColor },
     ),

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

@@ -15,7 +15,8 @@ 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.
+Claude Desktop, Gemini e Antigravity usando Node absoluto e o entrypoint
+absoluto do pacote, sem depender do PATH do app desktop.
 Reinicie os clientes depois da execucao.
 `);
   process.exit(0);