@fprad0/skill-master-mcp 0.0.8 → 0.0.10

package/bin/lib/menu-core.mjs

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import os from 'node:os';
 import { join } from 'node:path';
 import process from 'node:process';
 
@@ -11,12 +12,245 @@ const ANSI = {
   green: '\x1b[32m',
   yellow: '\x1b[33m',
   red: '\x1b[31m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  teal: '\x1b[38;5;80m',
+  amber: '\x1b[38;5;179m',
+  blue: '\x1b[38;5;75m',
+};
+
+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 BUNDLED_SKILL_DOMAIN_GROUPS = [
+  {
+    key: 'moral',
+    label: 'moral-core',
+    skills: [
+      'ai-ethics-human-dignity',
+      'broad-domain-router',
+      'catholic-moral-discernment',
+      'engineering-systems-master',
+      'language-quality-pt-en-fr',
+      'math-science-reasoning',
+      'philosophy-sociology-discernment',
+      'professional-boundary-triage',
+      'release-ethics-gate',
+      'source-authority-reviewer',
+    ],
+  },
+  {
+    key: 'frontend',
+    label: 'frontend-ui',
+    skills: [
+      'figma',
+      'figma-code-connect-components',
+      'figma-create-design-system-rules',
+      'figma-generate-design',
+      'figma-generate-library',
+      'figma-implement-design',
+      'figma-use',
+      'frontend-design',
+      'frontend-ui-ux-systems',
+      'playwright',
+      'screenshot',
+      'webapp-testing',
+      'winui-app',
+    ],
+  },
+  {
+    key: 'backend',
+    label: 'backend-data',
+    skills: [
+      'mcp-builder',
+      'polyglot-backend-engineering',
+    ],
+  },
+  {
+    key: 'ops',
+    label: 'ops-clients',
+    skills: [
+      'cli-creator',
+      'developer-workstation-ops',
+      'github',
+      'mcp-client-readiness',
+      'openai-docs',
+      'skill-master-orchestrator',
+      'terminal-menu-operations',
+      'terminal-pixel-art-tui',
+    ],
+  },
+  {
+    key: 'knowledge',
+    label: 'knowledge',
+    skills: [
+      'language-quality-pt-en-fr-it-ru',
+      'math-physics-reasoning',
+    ],
+  },
+];
+
+const COMMAND_AREA_LABELS = {
+  status: 'diagnostico',
+  doctor: 'diagnostico',
+  check: 'desenvolvimento',
+  build: 'desenvolvimento',
+  publicNpm: 'distribuicao',
+  updateGlobal: 'distribuicao',
+  privateRegistry: 'registry',
+  activationStatus: 'ativacao',
+  activationBalanced: 'ativacao',
+  activationAlwaysOn: 'ativacao',
+  installGlobalSkills: 'skills-globais',
+  bootstrapGlobal: 'bootstrap-global',
+  registerClients: 'clientes-mcp',
+  promptRecommendation: 'roteamento',
+  successNotifications: 'aprendizado',
+  studySkills: 'aprendizado',
+  approvalPackage: 'aprovacao',
+  markLearnedStudy: 'aprovacao',
+  rejectLearnedSkill: 'aprovacao',
+  activateLearnedLocal: 'ativacao-skill',
+  activateLearnedGlobal: 'ativacao-skill',
+  notionSummary: 'documentacao',
 };
 
 function colorize(text, color, enabled) {
   return enabled ? `${color}${text}${ANSI.reset}` : text;
 }
 
+function visibleLength(text) {
+  return String(text).replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
+function fitText(text, width) {
+  const value = String(text ?? '');
+  if (visibleLength(value) <= width) {
+    return `${value}${' '.repeat(width - visibleLength(value))}`;
+  }
+
+  return `${value.slice(0, Math.max(0, width - 1))}~`;
+}
+
+function splitText(text, width, maxLines = 3) {
+  const words = String(text ?? '').split(/\s+/).filter(Boolean);
+  const lines = [];
+  let current = '';
+
+  for (const word of words) {
+    const next = current ? `${current} ${word}` : word;
+    if (next.length <= width) {
+      current = next;
+      continue;
+    }
+    if (current) lines.push(current);
+    current = word.length > width ? word.slice(0, width - 1) + '~' : word;
+    if (lines.length >= maxLines) break;
+  }
+  if (current && lines.length < maxLines) lines.push(current);
+  return lines.length ? lines : [''];
+}
+
+function globalSkillsRoot() {
+  return join(process.env.CODEX_HOME ?? join(os.homedir(), '.codex'), 'skills');
+}
+
+function readClientConfigState(filePath) {
+  if (!existsSync(filePath)) {
+    return { present: false, kind: 'missing', globalCommand: false };
+  }
+
+  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');
+
+  return {
+    present: true,
+    kind: hasGlobalCommand ? 'global' : hasLauncher ? 'launcher' : hasSkillMaster ? 'custom' : 'unknown',
+    globalCommand: hasGlobalCommand,
+  };
+}
+
+function readJsonState(filePath) {
+  if (!existsSync(filePath)) {
+    return { present: false, globalCommand: false };
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    const server = parsed?.mcpServers?.skill_master;
+    return {
+      present: true,
+      globalCommand: server?.command === 'skill-master-mcp',
+    };
+  } 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');
+  }
+
+  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 ready = missing.length === 0
+    && codex.globalCommand
+    && claude.globalCommand
+    && gemini.globalCommand
+    && antigravity.globalCommand;
+  const mode = ready
+    ? 'ready'
+    : codex.kind === 'launcher' || claude.present || gemini.present || antigravity.present
+      ? 'partial'
+      : 'missing';
+
+  return {
+    root,
+    required: REQUIRED_GLOBAL_SKILLS.length,
+    installed,
+    missing,
+    ready,
+    mode,
+    codex,
+    claude,
+    gemini,
+    antigravity,
+  };
+}
+
 export function readJson(rootDir, relativePath) {
   const target = join(rootDir, relativePath);
   if (!existsSync(target)) {
@@ -42,6 +276,8 @@ export function getMenuStatus(rootDir) {
   const successLearningDir = process.env.SKILL_MASTER_SUCCESS_LEARNING_DIR
     ?? join(process.env.SKILL_MASTER_HOME ?? join(process.env.HOME ?? process.env.USERPROFILE ?? '', '.skill-master'), 'data', 'success-learning');
   const studyCandidates = readJson(rootDir, 'network/unapproved-skill-candidates.json');
+  const globalReadiness = inspectGlobalReadiness();
+  const bundledCatalog = inspectBundledSkillCatalog(rootDir);
 
   return {
     packageName: packageJson?.name ?? 'nao encontrado',
@@ -52,6 +288,8 @@ export function getMenuStatus(rootDir) {
     rootDir,
     pendingSuccessDrafts: countManifestFiles(successLearningDir),
     studyCandidates: Array.isArray(studyCandidates?.candidates) ? studyCandidates.candidates.length : 0,
+    globalReadiness,
+    bundledCatalog,
   };
 }
 
@@ -73,21 +311,108 @@ function countManifestFiles(directory) {
   return count;
 }
 
+function listBundledSkillNames(rootDir) {
+  const source = join(rootDir, 'docs', 'skill-candidates');
+  if (!existsSync(source)) {
+    return [];
+  }
+
+  const entries = readdirSync(source, { withFileTypes: true });
+  const directSkills = entries
+    .filter((entry) => entry.isDirectory() && existsSync(join(source, entry.name, 'SKILL.md')))
+    .map((entry) => entry.name);
+
+  if (directSkills.length) {
+    return Array.from(new Set(directSkills)).sort();
+  }
+
+  return Array.from(new Set(
+    entries
+      .filter((entry) => entry.isDirectory())
+      .flatMap((entry) => {
+        const versionPath = join(source, entry.name);
+        return readdirSync(versionPath, { withFileTypes: true })
+          .filter((skillEntry) => skillEntry.isDirectory() && existsSync(join(versionPath, skillEntry.name, 'SKILL.md')))
+          .map((skillEntry) => skillEntry.name);
+      }),
+  )).sort();
+}
+
+function inspectBundledSkillCatalog(rootDir) {
+  const names = listBundledSkillNames(rootDir);
+  const categories = BUNDLED_SKILL_DOMAIN_GROUPS.map((group) => ({
+    key: group.key,
+    label: group.label,
+    count: group.skills.filter((skill) => names.includes(skill)).length,
+  }));
+
+  return {
+    total: names.length,
+    names,
+    categories,
+  };
+}
+
+function formatBundledCategoryLine(catalog) {
+  if (!catalog?.categories?.length) {
+    return 'bundled skills: 0';
+  }
+
+  return catalog.categories
+    .filter((category) => category.count > 0)
+    .map((category) => `${category.label} ${category.count}`)
+    .join(' | ');
+}
+
+function resolveCommandArea(action) {
+  if (!action) {
+    return 'geral';
+  }
+
+  return COMMAND_AREA_LABELS[action.key] ?? 'geral';
+}
+
+function formatActionCommand(action) {
+  if (!action?.command) {
+    return '';
+  }
+
+  return [action.command, ...(action.args ?? [])].join(' ');
+}
+
 export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process.execPath }) {
+  const isDevCheckout = existsSync(join(rootDir, 'tsconfig.json')) && existsSync(join(rootDir, 'src'));
+  const repoOnlyReason = 'Disponivel apenas no clone de desenvolvimento; no pacote npm use Doctor ou Status.';
+
   return [
     {
       key: 'status',
       aliases: ['status'],
       label: 'Status local',
       description: 'Mostra versao local, manifesto e informacoes do pacote.',
+      details: ['Nao altera arquivos.', 'Use para confirmar se o menu esta lendo a instalacao correta.'],
+      success: 'Relatorio impresso com versao, canal, skills globais e clientes configurados.',
       command: nodeExecPath,
       args: [currentFile, '--status'],
     },
+    {
+      key: 'doctor',
+      aliases: ['doctor', 'diagnostico', 'verificar-menu', 'validar-menu'],
+      label: 'Doctor do menu e clientes MCP',
+      description: 'Valida pacote, binarios, skills globais e registros em Codex, Claude, Gemini e Antigravity.',
+      details: ['Seguro para outros notebooks.', 'Nao publica versao e nao mexe em configuracoes sem uma acao separada.'],
+      success: 'Mostra um relatorio GO/NO-GO com proximos comandos recomendados.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-doctor.mjs')],
+    },
     {
       key: 'check',
       aliases: ['check', 'gate'],
       label: 'Rodar gate completo',
       description: 'Executa build, testes e validacao de manifestos.',
+      details: ['Exige clone do repositorio com src, testes e tsconfig.', 'Nao e uma acao indicada para instalacao global via npm.'],
+      success: 'Build, testes e manifestos passam no checkout de desenvolvimento.',
+      disabledReason: isDevCheckout ? null : repoOnlyReason,
       command: 'npm',
       args: ['run', 'check'],
     },
@@ -96,6 +421,9 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['build'],
       label: 'Rodar build',
       description: 'Compila o projeto localmente.',
+      details: ['Exige clone do repositorio com tsconfig.', 'Pacotes npm publicados ja usam dist precompilado.'],
+      success: 'dist atualizado no checkout de desenvolvimento.',
+      disabledReason: isDevCheckout ? null : repoOnlyReason,
       command: 'npm',
       args: ['run', 'build'],
     },
@@ -104,6 +432,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['public-npm', 'npm', 'registry'],
       label: 'Validar pacote no npm publico',
       description: 'Consulta a versao publicada em registry.npmjs.org.',
+      details: ['Usa somente leitura no registry publico.', 'Bom para confirmar se outro notebook consegue instalar por npm.'],
+      success: 'Retorna a versao publicada atualmente no npmjs.',
       command: 'npm',
       args: [
         'view',
@@ -117,6 +447,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['update', 'update-global'],
       label: 'Atualizar pacote global via npm',
       description: 'Atualiza a instalacao global e exige reinicio do cliente MCP.',
+      details: ['Roda npm install -g fora do processo MCP stdio.', 'Use antes de abrir Codex, Claude, Gemini ou Antigravity.'],
+      success: 'Pacote global atualizado para a versao latest do npm publico.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-update.mjs')],
       confirmMessage: 'Atualizar o pacote global agora?',
@@ -126,6 +458,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['private-registry', 'private', 'github-packages'],
       label: 'Configurar registry privado GitHub Packages',
       description: 'Prepara o .npmrc e valida o acesso ao pacote privado.',
+      details: ['Uso avancado para ambientes privados.', 'Nao e necessario para o pacote publico do npmjs.'],
+      success: '.npmrc configurado e validacao npm view executada.',
       command: nodeExecPath,
       args: ['scripts/configure-private-registry.mjs', '--validate'],
       confirmMessage: 'Rodar a configuracao de registry privado agora?',
@@ -135,6 +469,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['activation-status', 'modo', 'modo-ativacao'],
       label: 'Modo de ativacao atual',
       description: 'Mostra o modo manual, balanced ou always-on-assisted configurado localmente.',
+      details: ['Nao altera configuracao.', 'Ajuda a entender quando o Skill Master deve sugerir skills.'],
+      success: 'Modo atual e caminho da configuracao impressos no terminal.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--status'],
     },
@@ -143,6 +479,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['set-balanced', 'balanced'],
       label: 'Usar modo balanced',
       description: 'Define balanced como modo padrao de ativacao do Skill Master.',
+      details: ['Recomendado para uso diario.', 'Ativa o MCP quando ha ganho claro para o prompt.'],
+      success: 'Modo balanced salvo localmente.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--set-mode', 'balanced'],
     },
@@ -151,15 +489,52 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['set-always-on', 'always-on-assisted'],
       label: 'Usar modo always-on-assisted',
       description: 'Define avaliacao assistida quase sempre ativa, mantendo no-op quando nao houver ganho.',
+      details: ['Mais agressivo que balanced.', 'Indicado para usuarios que querem o Skill Master avaliando quase todos os prompts.'],
+      success: 'Modo always-on-assisted salvo localmente.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--set-mode', 'always-on-assisted'],
       confirmMessage: 'Alterar o modo local para always-on-assisted?',
     },
+    {
+      key: 'installGlobalSkills',
+      aliases: ['install-global-skills', 'skills-globais', 'global-skills'],
+      label: 'Instalar skills globais do Skill Master',
+      description: 'Copia as skills amplas e morais embutidas para CODEX_HOME/skills ou ~/.codex/skills.',
+      details: ['Necessario para Codex descobrir as skills globais.', 'Pode ser reexecutado com seguranca pelo bootstrap.'],
+      success: 'Skills globais copiadas para a pasta global do usuario.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-install-global-skills.mjs')],
+      confirmMessage: 'Instalar as skills globais embutidas neste usuario?',
+    },
+    {
+      key: 'bootstrapGlobal',
+      aliases: ['bootstrap-global', 'global-bootstrap', 'ativar-global-completo'],
+      label: 'Ativar MCP global neste computador',
+      description: 'Instala skills globais e registra Codex, Claude, Gemini e Antigravity no mesmo passo.',
+      details: ['Acao principal para notebooks novos.', 'Depois reinicie os clientes para eles recarregarem MCP e skills.'],
+      success: 'Skills instaladas e configuracoes MCP aplicadas nos clientes encontrados.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-bootstrap-global.mjs')],
+      confirmMessage: 'Executar o bootstrap global do Skill Master neste computador?',
+    },
+    {
+      key: 'registerClients',
+      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.'],
+      success: 'Arquivos de configuracao mesclados com o servidor skill_master.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-register-clients.mjs'), '--apply-all'],
+      confirmMessage: 'Aplicar registro do skill_master em Codex, Claude, Gemini e Antigravity?',
+    },
     {
       key: 'promptRecommendation',
       aliases: ['recommend-prompt', 'recomendar-prompt', 'prompt-router'],
       label: 'Ver recomendacao para um prompt',
       description: 'Abre um fluxo interativo para avaliar um prompt pelo router local.',
+      details: ['Ajuda a decidir se skill-master, skill_master ou skill-master-mcp deve agir.', 'Nao publica nem altera skills.'],
+      success: 'Router imprime recomendacao, modo de ativacao e gates aplicaveis.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--route-prompt-interactive'],
     },
@@ -168,6 +543,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['notifications', 'notificacoes', 'success-notifications'],
       label: 'Notificacoes de skills aprendidas',
       description: 'Mostra drafts pendentes, aprovacoes e skills externas para estudar.',
+      details: ['Use para decidir o que aprovar, estudar ou rejeitar.', 'Nao ativa skill automaticamente.'],
+      success: 'Lista de pendencias e proximas acoes exibida.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--notify'],
     },
@@ -176,6 +553,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['study-skills', 'skills-estudo', 'estudar'],
       label: 'Skills para estudar',
       description: 'Lista skills externas e links de criadores ainda nao aprovados.',
+      details: ['Material de estudo, nao ativacao operacional.', 'Bom para revisao humana antes de virar skill local/global.'],
+      success: 'Links e motivos de estudo exibidos.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--study'],
     },
@@ -184,6 +563,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['approval-package', 'aprovar', 'pacote-aprovacao'],
       label: 'Gerar pacote de aprovacao humana',
       description: 'Cria um relatorio local para revisar e aprovar skills aprendidas.',
+      details: ['Exige decisao humana antes de ativacao.', 'Inclui riscos, evidencias e recomendacao.'],
+      success: 'Pacote local de aprovacao gerado.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--approval-package'],
     },
@@ -192,6 +573,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['mark-study', 'manter-estudo'],
       label: 'Manter skill candidata para estudo',
       description: 'Seleciona uma candidata e registra decisao de manter para estudo.',
+      details: ['Preserva historico sem ativar a skill.', 'Use quando a fonte ainda precisa revisao.'],
+      success: 'Decisao registrada no historico local.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--mark-study-interactive'],
     },
@@ -200,6 +583,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['reject-skill', 'rejeitar-skill'],
       label: 'Rejeitar skill candidata',
       description: 'Seleciona uma candidata, registra rejeicao e preserva historico.',
+      details: ['Nao apaga evidencias.', 'Use quando risco, fonte ou utilidade nao passam no gate.'],
+      success: 'Rejeicao registrada com motivo.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--reject-interactive'],
       confirmMessage: 'Abrir fluxo para rejeitar uma skill candidata?',
@@ -209,6 +594,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['activate-learned-local', 'ativar-local', 'skill-local'],
       label: 'Ativar skill aprendida no workspace',
       description: 'Instala uma skill aprendida em .codex/skills do projeto atual.',
+      details: ['Escopo limitado ao workspace.', 'Mais conservador que ativar globalmente.'],
+      success: 'Skill copiada para .codex/skills do projeto.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--activate-interactive', '--target', 'local'],
       confirmMessage: 'Selecionar e ativar uma skill aprendida no workspace atual?',
@@ -218,6 +605,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['activate-learned-global', 'ativar-global', 'skill-global'],
       label: 'Ativar skill aprendida global',
       description: 'Instala uma skill aprendida em CODEX_HOME/skills ou ~/.codex/skills.',
+      details: ['Afeta todos os projetos deste usuario.', 'Use apenas depois de aprovacao humana.'],
+      success: 'Skill instalada no diretorio global de skills.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--activate-interactive', '--target', 'global'],
       confirmMessage: 'Selecionar e ativar uma skill aprendida como skill global deste usuario?',
@@ -227,6 +616,8 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       aliases: ['notion-summary', 'resumo-notion'],
       label: 'Abrir resumo para Notion',
       description: 'Mostra um resumo copiavel do estado de ativacao para registrar no ledger Notion.',
+      details: ['Nao escreve no Notion sozinho.', 'Gera texto de continuidade para documentacao.'],
+      success: 'Resumo pronto para registro exibido.',
       command: nodeExecPath,
       args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--notion-summary'],
     },
@@ -236,8 +627,9 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
 export function buildMenuChoices(commands) {
   return commands.map((command) => ({
     title: command.label,
-    description: command.description,
+    description: [command.description, command.success ? `Resultado: ${command.success}` : null].filter(Boolean).join(' '),
     value: command.key,
+    disabled: command.disabledReason ?? false,
   })).concat({
     title: 'Sair',
     description: 'Fecha o menu operacional.',
@@ -261,6 +653,8 @@ export function isInteractiveTerminal() {
 }
 
 export function formatStatusReport(status) {
+  const readiness = status.globalReadiness;
+  const bundledCatalog = status.bundledCatalog ?? { total: 0, categories: [] };
   const lines = [
     'Skill Master MCP - status local',
     `Diretorio: ${status.rootDir}`,
@@ -270,6 +664,14 @@ export function formatStatusReport(status) {
     `Manifesto semver: ${status.manifestSemver}`,
     `Drafts de skills aprendidas: ${status.pendingSuccessDrafts}`,
     `Skills externas para estudar: ${status.studyCandidates}`,
+    `Global readiness: ${readiness.ready ? 'pronto' : readiness.mode}`,
+    `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'}`,
   ];
 
   if (status.versionText) {
@@ -280,6 +682,41 @@ export function formatStatusReport(status) {
   return lines.join('\n');
 }
 
+function formatGlobalAlert(status, { useColor = false } = {}) {
+  const readiness = status.globalReadiness;
+  if (readiness.ready) {
+    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.',
+        'A instalacao global e as skills embutidas ja estao prontas para uso.',
+      ],
+      { color: ANSI.green, useColor },
+    );
+  }
+
+  return [
+    renderPanelLines(
+      [
+        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.',
+      ],
+      { color: ANSI.red, useColor },
+    ),
+    renderPanelLines(
+      [
+        colorize('AVISO SUTIL', ANSI.dim, useColor),
+        'Sem instalacao global, o MCP continua util localmente, mas nao fica integrado como parte do sistema em todos os clientes.',
+        `Skills globais detectadas: ${readiness.installed.length}/${readiness.required}`,
+      ],
+      { color: ANSI.yellow, useColor },
+    ),
+  ].join('\n\n');
+}
+
 function renderPanelLines(lines, { color = ANSI.cyan, useColor = false } = {}) {
   const width = Math.max(...lines.map((line) => line.length), 24);
   const border = `+${'-'.repeat(width + 2)}+`;
@@ -289,22 +726,372 @@ function renderPanelLines(lines, { color = ANSI.cyan, useColor = false } = {}) {
 }
 
 export function formatMenuBanner(status, { useColor = false } = {}) {
+  const bundledCatalog = status.bundledCatalog ?? { total: 0, categories: [] };
   const lines = [
     colorize('Skill Master MCP', ANSI.bold, useColor),
     'Menu operacional para manutencao local',
     `Versao local ${status.semver}  |  canal ${status.manifestVersion}`,
     `Pendencias: ${status.pendingSuccessDrafts} drafts  |  estudo: ${status.studyCandidates} links`,
+    `Global: ${status.globalReadiness.ready ? 'pronto' : 'requer instalacao global'}`,
+    `Bundle: ${bundledCatalog.total} skills  |  ${formatBundledCategoryLine(bundledCatalog)}`,
     colorize('Setas + Enter para navegar', ANSI.dim, useColor),
   ];
-  return renderPanelLines(lines, { color: ANSI.cyan, useColor });
+  return [
+    renderPanelLines(lines, { color: ANSI.cyan, useColor }),
+    formatGlobalAlert(status, { useColor }),
+  ].join('\n\n');
+}
+
+function dnaPanelLines(tick, width, height, status, { useColor = false, compact = false } = {}) {
+  const lines = [];
+  const center = Math.floor(width / 2);
+  const graphLeft = 2;
+  const graphRight = Math.max(graphLeft + 8, width - 3);
+  const graphWidth = Math.max(10, graphRight - graphLeft + 1);
+  const radius = Math.max(3, Math.floor((graphWidth - 4) / 3.35));
+  const phase = tick / 6;
+  const bodyHeight = Math.max(compact ? 6 : 8, height - (compact ? 5 : 6));
+  const scanRow = bodyHeight > 0 ? tick % bodyHeight : 0;
+
+  lines.push(fitText(colorize('GENOME MATRIX', ANSI.bold, useColor), width));
+  lines.push(fitText(colorize(compact ? 'lab helix / scan stable' : 'procedural intelligence helix', ANSI.dim, useColor), width));
+  if (!compact) {
+    lines.push(fitText(colorize('signal map / sync locked / low flicker', ANSI.gray, useColor), width));
+  }
+
+  const place = (cells, col, char, color) => {
+    if (col >= 0 && col < width) cells[col] = colorize(char, color, useColor);
+  };
+
+  for (let row = 0; row < bodyHeight; row += 1) {
+    const angle = row * 0.49 + phase;
+    const left = Math.round(center + Math.sin(angle) * radius);
+    const right = Math.round(center + Math.sin(angle + Math.PI) * radius);
+    const min = Math.min(left, right);
+    const max = Math.max(left, right);
+    const chars = Array.from({ length: width }, () => ' ');
+    const front = Math.cos(angle) >= 0;
+    const leftColor = front ? ANSI.teal : ANSI.blue;
+    const rightColor = front ? ANSI.amber : ANSI.gray;
+    const bondColor = front ? ANSI.gray : ANSI.blue;
+    const scanActive = row === scanRow;
+
+    place(chars, graphLeft, row === 0 ? '┌' : row === bodyHeight - 1 ? '└' : '│', ANSI.gray);
+    place(chars, graphRight, row === 0 ? '┐' : row === bodyHeight - 1 ? '┘' : '│', ANSI.gray);
+
+    if (row === 0 || row === bodyHeight - 1) {
+      for (let col = graphLeft + 1; col < graphRight; col += 1) {
+        place(chars, col, '─', ANSI.gray);
+      }
+    }
+
+    for (let col = min + 2; col < max - 1; col += 1) {
+      const rungChar = row % 4 < 2 ? '═' : '─';
+      place(chars, col, scanActive ? '█' : rungChar, scanActive ? ANSI.white : bondColor);
+    }
+
+    place(chars, left - 1, '▓', leftColor);
+    place(chars, left, scanActive ? '█' : row % 2 === 0 ? '█' : '▓', scanActive ? ANSI.white : leftColor);
+    place(chars, left + 1, '▓', leftColor);
+    place(chars, right - 1, '▓', rightColor);
+    place(chars, right, scanActive ? '█' : row % 2 === 0 ? '█' : '▓', scanActive ? ANSI.white : rightColor);
+    place(chars, right + 1, '▓', rightColor);
+
+    if (row % 4 === 1 || row % 4 === 2) {
+      place(chars, center, scanActive ? '◆' : '◆', scanActive ? ANSI.white : ANSI.gray);
+    }
+
+    lines.push(chars.join(''));
+  }
+
+  lines.push(fitText('', width));
+  lines.push(fitText(colorize(compact ? 'helix stable' : 'helix stable   lattice aligned', ANSI.gray, useColor), width));
+  lines.push(fitText(colorize(compact ? `global ${status.globalReadiness.installed.length}/${status.globalReadiness.required}` : `global ${status.globalReadiness.installed.length}/${status.globalReadiness.required}   clients linked`, ANSI.amber, useColor), width));
+
+  return lines.slice(0, height).map((line) => fitText(line, width));
+}
+
+function renderMeterBar(value, total, width, { useColor = false, color = ANSI.teal } = {}) {
+  const safeTotal = Math.max(1, total);
+  const safeValue = Math.max(0, Math.min(value, safeTotal));
+  const fill = Math.round((safeValue / safeTotal) * width);
+  const filled = '█'.repeat(fill);
+  const empty = '░'.repeat(Math.max(0, width - fill));
+  return `${colorize(filled, color, useColor)}${colorize(empty, ANSI.gray, useColor)}`;
+}
+
+function renderSparkline(series, { useColor = false, color = ANSI.teal } = {}) {
+  const blocks = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+  return series.map((value) => colorize(blocks[Math.max(0, Math.min(blocks.length - 1, value))], color, useColor)).join('');
+}
+
+function buildTelemetrySeries(seed, length, tick) {
+  return Array.from({ length }, (_, index) => {
+    const raw = Math.sin((index + 1 + seed) * 0.72 + tick * 0.18) + Math.cos((index + seed) * 0.33 + tick * 0.11);
+    const normalized = Math.max(0, Math.min(1, (raw + 2) / 4));
+    return Math.round(normalized * 7);
+  });
+}
+
+function buildOverviewSignalLine(status, width, tick, { useColor = false, compact = false } = {}) {
+  const signalWidth = Math.max(6, Math.min(compact ? 8 : 12, Math.floor(width / (compact ? 10 : 8))));
+  const healthWidth = Math.max(6, Math.min(compact ? 8 : 12, Math.floor(width / (compact ? 10 : 8))));
+  const signal = renderSparkline(
+    buildTelemetrySeries(status.globalReadiness.installed.length + status.pendingSuccessDrafts, signalWidth, tick),
+    { useColor, color: ANSI.teal },
+  );
+  const health = renderSparkline(
+    buildTelemetrySeries(status.studyCandidates + (status.globalReadiness.ready ? 7 : 3), healthWidth, tick + 3),
+    { useColor, color: ANSI.amber },
+  );
+  return compact
+    ? `signal ${signal} health ${health}`
+    : `signal ${signal}   health ${health}`;
+}
+
+function telemetryPanelLines(status, selected, width, height, { useColor = false, tick = 0, compact = false } = {}) {
+  const commandArea = resolveCommandArea(selected);
+  const bundledCatalog = status.bundledCatalog ?? { total: 0, categories: [] };
+  const categoryLead = bundledCatalog.categories
+    ?.filter((category) => category.count > 0)
+    .sort((left, right) => right.count - left.count)[0];
+  const categoryName = categoryLead?.label ?? 'none';
+  const categoryCount = categoryLead?.count ?? 0;
+  const meterWidth = Math.max(8, Math.min(16, width - 14));
+  const sparkWidth = Math.max(8, Math.min(compact ? 8 : 12, width - 18));
+  const skillsSpark = renderSparkline(buildTelemetrySeries(status.globalReadiness.installed.length + categoryCount, sparkWidth, tick), { useColor, color: ANSI.amber });
+  const draftsSpark = renderSparkline(buildTelemetrySeries(status.pendingSuccessDrafts + 2, sparkWidth, tick + 2), { useColor, color: ANSI.teal });
+  const studySpark = renderSparkline(buildTelemetrySeries(status.studyCandidates + 4, sparkWidth, tick + 4), { useColor, color: ANSI.blue });
+  const lines = [
+    fitText(colorize('SYSTEM WINDOWS', ANSI.bold, useColor), width),
+    fitText(colorize(`selected area  ${commandArea}`, ANSI.gray, useColor), width),
+    fitText(colorize(`dominant skill  ${categoryName} ${categoryCount}`, ANSI.gray, useColor), width),
+    fitText(`bundle   ${String(bundledCatalog.total).padStart(2, '0')}  ${renderMeterBar(bundledCatalog.total, Math.max(36, bundledCatalog.total), meterWidth, { useColor, color: ANSI.white })}`, width),
+    fitText(`global   ${status.globalReadiness.installed.length}/${status.globalReadiness.required} ${renderMeterBar(status.globalReadiness.installed.length, status.globalReadiness.required, meterWidth, { useColor, color: ANSI.amber })}`, width),
+    fitText(`skills   ${skillsSpark}`, width),
+    fitText(`drafts   ${String(status.pendingSuccessDrafts).padStart(2, '0')}  ${renderMeterBar(status.pendingSuccessDrafts, Math.max(6, status.pendingSuccessDrafts || 1), meterWidth, { useColor, color: ANSI.teal })}`, width),
+    fitText(`queue    ${draftsSpark}`, width),
+    fitText(`study    ${String(status.studyCandidates).padStart(2, '0')}  ${renderMeterBar(status.studyCandidates, Math.max(8, status.studyCandidates || 1), meterWidth, { useColor, color: ANSI.blue })}`, width),
+    fitText(`links    ${studySpark}`, width),
+    fitText(colorize(compact ? 'codex / claude / gemini' : 'codex / claude / gemini / antigravity', ANSI.dim, useColor), width),
+  ];
+
+  return lines.slice(0, height).map((line) => fitText(line, width));
+}
+
+function renderBox(lines, width, title, { useColor = false, color = ANSI.cyan, style = 'normal' } = {}) {
+  const innerWidth = Math.max(10, width - 4);
+  const titleText = title ? ` ${title.toUpperCase()} ` : '';
+  const topLeft = style === 'focus' ? '╭' : style === 'hud' ? '┏' : '┌';
+  const topRight = style === 'focus' ? '╮' : style === 'hud' ? '┓' : '┐';
+  const bottomLeft = style === 'focus' ? '╰' : style === 'hud' ? '┗' : '└';
+  const bottomRight = style === 'focus' ? '╯' : style === 'hud' ? '┛' : '┘';
+  const topFill = style === 'focus' ? '═' : '─';
+  const bottomTail = style === 'focus' ? '══' : '┄┄';
+  const top = `${topLeft}${titleText}${topFill.repeat(Math.max(0, width - 2 - titleText.length))}${topRight}`;
+  const bottom = `${bottomLeft}${topFill.repeat(Math.max(0, width - 4))}${bottomTail}${bottomRight}`;
+  const body = lines.map((line, index) => {
+    const left = index === 0
+      ? (style === 'focus' ? '╞' : '├')
+      : index === lines.length - 1
+        ? (style === 'focus' ? '╘' : '╰')
+        : '│';
+    const right = index === 0
+      ? (style === 'focus' ? '╡' : '┤')
+      : index === lines.length - 1
+        ? (style === 'focus' ? '╛' : '╯')
+        : '│';
+    return `${colorize(left, color, useColor)} ${fitText(line, innerWidth)} ${colorize(right, color, useColor)}`;
+  });
+  return [
+    colorize(top, color, useColor),
+    ...body,
+    colorize(bottom, color, useColor),
+  ];
+}
+
+function joinHorizontalBoxes(boxes, gutter = 2) {
+  const height = Math.max(...boxes.map((box) => box.lines.length));
+  const gap = ' '.repeat(gutter);
+  const rows = [];
+
+  for (let index = 0; index < height; index += 1) {
+    rows.push(boxes.map((box) => box.lines[index] ?? ' '.repeat(box.width)).join(gap));
+  }
+
+  return rows;
+}
+
+export function formatCyberMenuFrame(status, commands, selectedIndex, tick = 0, {
+  columns = 120,
+  rows = 32,
+  useColor = false,
+} = {}) {
+  const width = Math.max(72, Math.min(columns, 150));
+  const height = Math.max(22, Math.min(rows - 1, 42));
+  const compactMode = width < 104 || height < 27;
+  const rightWidth = compactMode ? (width >= 92 ? 28 : 26) : width >= 132 ? 44 : width >= 108 ? 38 : 30;
+  const gutter = 2;
+  const leftWidth = width - rightWidth - gutter;
+  const selected = commands[selectedIndex] ?? commands[0];
+  const actionArea = resolveCommandArea(selected);
+  const bundledCatalog = status.bundledCatalog ?? { total: 0, categories: [] };
+  const summaryOuterHeight = compactMode ? 7 : 8;
+  const bodyOuterHeight = Math.max(12, height - summaryOuterHeight - 1);
+  const detailOuterHeight = compactMode
+    ? Math.min(8, Math.max(7, Math.floor(bodyOuterHeight * 0.46)))
+    : Math.min(10, Math.max(8, Math.floor(bodyOuterHeight * 0.42)));
+  const actionOuterHeight = compactMode
+    ? Math.max(8, bodyOuterHeight - detailOuterHeight)
+    : Math.max(8, bodyOuterHeight - detailOuterHeight);
+  const rightBottomOuterHeight = compactMode
+    ? Math.min(8, Math.max(7, Math.floor(bodyOuterHeight * 0.4)))
+    : Math.min(10, Math.max(8, Math.floor(bodyOuterHeight * 0.34)));
+  const rightTopOuterHeight = Math.max(8, bodyOuterHeight - rightBottomOuterHeight);
+  const summaryInnerWidth = width - 4;
+  const actionInnerWidth = leftWidth - 4;
+  const detailInnerWidth = leftWidth - 4;
+  const rightInnerWidth = rightWidth - 4;
+  const summaryInnerHeight = summaryOuterHeight - 2;
+  const actionInnerHeight = actionOuterHeight - 2;
+  const detailInnerHeight = detailOuterHeight - 2;
+  const rightTopInnerHeight = rightTopOuterHeight - 2;
+  const rightBottomInnerHeight = rightBottomOuterHeight - 2;
+  const visibleActionRows = Math.max(compactMode ? 2 : 3, actionInnerHeight - (compactMode ? 2 : 3));
+  const scrollStart = Math.min(
+    Math.max(0, selectedIndex - Math.floor(visibleActionRows / 2)),
+    Math.max(0, commands.length - visibleActionRows),
+  );
+  const visibleCommands = commands.slice(scrollStart, scrollStart + visibleActionRows);
+
+  const summaryLines = compactMode
+    ? [
+        colorize('SKILL MASTER MENU', ANSI.bold, useColor),
+      `version ${status.semver} | channel ${status.manifestVersion} | readiness ${status.globalReadiness.ready ? 'ready' : status.globalReadiness.mode}`,
+      colorize(`GLOBAL SKILLS ${status.globalReadiness.installed.length}/${status.globalReadiness.required}`, ANSI.amber, useColor),
+      `bundle ${bundledCatalog.total} | drafts ${status.pendingSuccessDrafts} | study ${status.studyCandidates}`,
+      buildOverviewSignalLine(status, summaryInnerWidth, tick, { useColor, compact: true }),
+      colorize('compact cyberpunk hud / operator safe', ANSI.dim, useColor),
+    ]
+    : [
+        colorize('SKILL MASTER MENU', ANSI.bold, useColor),
+        `version ${status.semver} | channel ${status.manifestVersion} | readiness ${status.globalReadiness.ready ? 'ready' : status.globalReadiness.mode}`,
+        colorize(`GLOBAL SKILLS ${status.globalReadiness.installed.length}/${status.globalReadiness.required}`, ANSI.amber, useColor),
+        `bundle ${bundledCatalog.total} | drafts ${status.pendingSuccessDrafts} | study ${status.studyCandidates}`,
+        buildOverviewSignalLine(status, summaryInnerWidth, tick, { useColor, compact: false }),
+        formatBundledCategoryLine(bundledCatalog),
+        colorize('workflow windows / cyberpunk terminal / operator safe', ANSI.dim, useColor),
+      ];
+
+  const actionLines = [
+    colorize('ACTION GRID', ANSI.gray, useColor),
+    colorize('up/down move  enter run  q exit', ANSI.dim, useColor),
+    ...visibleCommands.map((command, offset) => {
+    const index = scrollStart + offset;
+    const marker = index === selectedIndex ? '▸' : '·';
+    const disabled = command.disabledReason ? ' [off]' : '';
+    const label = `${marker} ${command.label}${disabled}`;
+    return index === selectedIndex
+      ? colorize(fitText(label, actionInnerWidth), ANSI.teal, useColor)
+      : fitText(label, actionInnerWidth);
+    }),
+  ];
+
+  while (actionLines.length < actionInnerHeight) {
+    actionLines.push(fitText('', actionInnerWidth));
+  }
+
+  const descriptionLines = [
+    colorize('DETAIL FOCUS', ANSI.amber, useColor),
+    colorize(selected?.label ?? 'Nenhuma acao', ANSI.bold, useColor),
+    fitText(colorize(`area ${actionArea} | action ${Math.min(selectedIndex + 1, commands.length)}/${commands.length}`, ANSI.gray, useColor), detailInnerWidth),
+    fitText(colorize('────────────────────────────────', ANSI.amber, useColor), detailInnerWidth),
+    ...splitText(selected?.description, detailInnerWidth, 1),
+    ...splitText(selected?.success ? `resultado: ${selected.success}` : '', detailInnerWidth, 1),
+    ...splitText(`exec: ${formatActionCommand(selected)}`, detailInnerWidth, 1),
+    ...(selected?.confirmMessage ? splitText(`confirmacao: ${selected.confirmMessage}`, detailInnerWidth, 2) : []),
+    ...(selected?.disabledReason ? splitText(`Indisponivel: ${selected.disabledReason}`, detailInnerWidth, 2) : []),
+  ];
+
+  while (descriptionLines.length < detailInnerHeight) {
+    descriptionLines.push(fitText('', detailInnerWidth));
+  }
+
+  const rightTopLines = dnaPanelLines(tick, rightInnerWidth, rightTopInnerHeight, status, { useColor, compact: compactMode });
+  const rightBottomLines = telemetryPanelLines(status, selected, rightInnerWidth, rightBottomInnerHeight, { useColor, tick, compact: compactMode });
+  const summaryBox = renderBox(
+    summaryLines.slice(0, summaryInnerHeight).map((line) => fitText(line, summaryInnerWidth)),
+    width,
+    'overview',
+    { useColor, color: ANSI.white, style: 'hud' },
+  );
+  const actionBox = renderBox(
+    actionLines.slice(0, actionInnerHeight).map((line) => fitText(line, actionInnerWidth)),
+    leftWidth,
+    'actions',
+    { useColor, color: ANSI.gray, style: 'normal' },
+  );
+  const detailBox = renderBox(
+    descriptionLines.slice(0, detailInnerHeight).map((line) => fitText(line, detailInnerWidth)),
+    leftWidth,
+    'details',
+    { useColor, color: ANSI.amber, style: 'focus' },
+  );
+  const dnaBox = renderBox(rightTopLines, rightWidth, 'dna-core', { useColor, color: ANSI.white, style: 'hud' });
+  const telemetryBox = renderBox(rightBottomLines, rightWidth, 'telemetry', { useColor, color: ANSI.blue, style: 'normal' });
+  const bodyRows = joinHorizontalBoxes([
+    { lines: [...actionBox, ...detailBox], width: leftWidth },
+    { lines: [...dnaBox, ...telemetryBox], width: rightWidth },
+  ], gutter);
+
+  return [...summaryBox, '', ...bodyRows].join('\n');
+}
+
+export function formatRunningActionFrame(status, action, tick = 0, {
+  columns = 120,
+  rows = 32,
+  useColor = false,
+} = {}) {
+  const width = Math.max(72, Math.min(columns, 150));
+  const height = Math.max(18, Math.min(rows - 1, 30));
+  const innerWidth = width - 4;
+  const commandArea = resolveCommandArea(action);
+  const pulse = renderSparkline(buildTelemetrySeries((status.globalReadiness.installed.length || 1) + tick, Math.max(8, Math.min(18, Math.floor(innerWidth / 5))), tick), { useColor, color: ANSI.teal });
+  const lines = [
+    colorize('EXECUTION TRANSFER', ANSI.bold, useColor),
+    fitText(colorize(`area ${commandArea} | launching ${action?.label ?? 'acao'}`, ANSI.amber, useColor), innerWidth),
+    fitText(colorize(`pulse ${pulse}`, ANSI.gray, useColor), innerWidth),
+    fitText('', innerWidth),
+    ...splitText(action?.description ?? '', innerWidth, 2),
+    ...splitText(action?.success ? `resultado esperado: ${action.success}` : '', innerWidth, 2),
+    ...splitText(`exec: ${formatActionCommand(action)}`, innerWidth, 2),
+    fitText('', innerWidth),
+    fitText(colorize('alternando do HUD para o stream real do comando...', ANSI.dim, useColor), innerWidth),
+  ];
+
+  while (lines.length < Math.max(8, height - 2)) {
+    lines.push(fitText('', innerWidth));
+  }
+
+  return renderBox(
+    lines.slice(0, Math.max(8, height - 2)).map((line) => fitText(line, innerWidth)),
+    width,
+    'running',
+    { useColor, color: ANSI.teal, style: 'focus' },
+  ).join('\n');
 }
 
 export function formatActionHeader(action, { useColor = false } = {}) {
+  const lines = [
+    colorize(action.label, ANSI.bold, useColor),
+    action.description,
+    ...(action.details ?? []),
+    action.success ? `Resultado esperado: ${action.success}` : null,
+    action.disabledReason ? `Indisponivel: ${action.disabledReason}` : null,
+  ].filter(Boolean);
+
   return renderPanelLines(
-    [
-      colorize(action.label, ANSI.bold, useColor),
-      action.description,
-    ],
+    lines,
     { color: ANSI.green, useColor },
   );
 }
@@ -318,7 +1105,11 @@ export function formatResultMessage(code, { useColor = false } = {}) {
 }
 
 export function formatHelp(commands) {
-  const actionList = commands.map((command) => `  - ${command.key}: ${command.label}`).join('\n');
+  const actionList = commands.map((command) => {
+    const aliases = command.aliases.length ? ` aliases: ${command.aliases.join(', ')}` : '';
+    const disabled = command.disabledReason ? ` indisponivel: ${command.disabledReason}` : '';
+    return `  - ${command.key}: ${command.label}\n    ${command.description}${aliases}${disabled}`;
+  }).join('\n');
 
   return `Skill Master Menu