@fprad0/skill-master-mcp 0.0.7 → 0.0.8

package/CHANGELOG.md

@@ -7,6 +7,15 @@ All notable changes to `skill_master` will be tracked here.
 - Prepare a public npm publication path with dedicated workflow and operator guide.
 - Upgrade release automation from Node `20` to Node `22`.
 
+## [0.0.8] - 2026-06-27
+
+- Add `skill_master_prompt_router` with `manual`, `balanced`, and `always-on-assisted` activation modes.
+- Add Dev Senior Master persona routing, safety gates, Notion/update detection, and learned-skill signals.
+- Add success-learning flows for human approval packages, local/global activation, study decisions, and rejection history.
+- Add `skill-master-activation`, `skill-master-success-skills`, and `skill-master-eval-activation` operator CLIs.
+- Expand the terminal menu with activation status, prompt recommendations, learned-skill notifications, study/reject actions, and Notion summaries.
+- Add activation evals with positive, negative, and risk cases plus `npm run eval:activation`.
+
 ## [0.0.7] - 2026-06-26
 
 - Add a visual terminal menu for `skill-master-menu` using `prompts`, with TTY detection and direct action mode.

package/README.md

@@ -108,18 +108,21 @@ npm install -g @fprad0/skill-master-mcp
 npx -y @fprad0/skill-master-mcp@latest
 ```
 
-Estado atual validado em `2026-06-26`:
+Estado atual preparado em `2026-06-27`:
 
-- pacote publico publicado: `@fprad0/skill-master-mcp@0.0.7`
-- dist-tag `latest` apontando para `0.0.7`
-- workflow `Publish Skill Master to npmjs` concluido com sucesso
-- `npm install` e `npx` confirmados
+- release local preparada: `@fprad0/skill-master-mcp@0.0.8`
+- validacao de pacote por tarball local confirmada
+- publicacao no npmjs aguardando autenticacao npmjs nesta maquina
+- apos publicar, validar `npm install`, `npx` e dist-tag `latest`
 
 Comandos globais principais:
 
 ```bash
+skill-master-activation
+skill-master-eval-activation
 skill-master-mcp
 skill-master-menu
+skill-master-success-skills
 skill-master-update
 skill-master-configure-private-registry
 ```
@@ -136,10 +139,38 @@ O menu agora possui modo visual interativo para terminal com TTY e tambem aceita
 skill-master-menu --run status
 skill-master-menu --run check
 skill-master-menu --run update --yes
+skill-master-menu --run notifications
+skill-master-menu --run study-skills
+skill-master-menu --run approval-package
+skill-master-menu --run activation-status
+skill-master-menu --run recommend-prompt
+skill-master-menu --run notion-summary
 ```
 
 O menu visual usa `prompts` para ficar mais legivel no terminal e manter compatibilidade com `Node 18+`.
 
+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.
+- `skill-master-menu --run activate-learned-global`: instala uma skill aprovada em `${CODEX_HOME:-~/.codex}/skills`.
+- `skill-master-menu --run mark-study`: registra uma skill candidata como material para estudo.
+- `skill-master-menu --run reject-skill`: rejeita uma skill candidata preservando historico.
+
+Para modo de ativacao e recomendacao local:
+
+```bash
+skill-master-activation --status
+skill-master-activation --set-mode balanced
+skill-master-activation --route-prompt "skill-master, recomende skills para este prompt"
+skill-master-activation --notion-summary
+```
+
+Para rodar as avaliacoes de ativacao antes de release:
+
+```bash
+npm run eval:activation
+```
+
 Para atualizar a instalacao global via npm sem iniciar o servidor MCP:
 
 ```bash
@@ -200,18 +231,62 @@ O `skill_master` pode aprender com as skills ja existentes em cada maquina insta
 Ferramentas MCP principais:
 
 - `skill_master_refresh_catalog`
+- `skill_master_prompt_router`
+- `skill_master_activation_check`
+- `skill_master_recommend`
 - `skill_master_prepare_skill_contribution`
 - `skill_master_review_skill_contribution`
+- `skill_master_prepare_success_skill`
+- `skill_master_review_success_skill`
+- `skill_master_list_unapproved_success_skills`
+- `skill_master_prepare_success_skill_approval_package`
+- `skill_master_activate_success_skill`
 
 O pacote de contribuicao nao envia arquivos automaticamente, nao executa skills desconhecidas e nao inclui caminhos completos ou corpo bruto por padrao.
 
+O fluxo de aprendizado por implementacoes bem-sucedidas cria rascunhos locais em staging, gera pacote de aprovacao humana e permite ativacao explicita em escopo local ou global. Ele exige evidencias, revisa risco/duplicidade e mantem candidatos externos como nao aprovados ate revisao humana. Nenhuma skill aprendida e publicada automaticamente.
+
 Leia:
 
 - [Rede segura de skills](docs/architecture/REDE_SEGURA_DE_SKILLS.md)
+- [Aprendizado de implementacoes bem-sucedidas](docs/architecture/APRENDIZADO_DE_IMPLEMENTACOES_BEM_SUCEDIDAS.md)
 
 ## Modos de ativacao em prompts
 
-A partir da versao `0.0.4`, clientes e agentes podem usar `skill_master_activation_check` antes de decidir se devem acionar recomendacoes de skills.
+Clientes e agentes podem usar `skill_master_prompt_router` como camada principal antes de decidir se devem acionar recomendacoes de skills, aplicar persona ou bloquear uma acao sensivel.
+
+Modos suportados:
+
+- `manual`: ativa apenas com mencao direta ao Skill Master ou gate bloqueante.
+- `balanced`: modo recomendado; ativa por mencao direta, tarefa tecnica com skill relevante, Notion, aprendizado, validacao, MCP ou publicacao.
+- `always-on-assisted`: avalia quase todo prompt, mas retorna `executionMode: no-op` quando nao houver ganho claro.
+
+Exemplo de chamada conceitual:
+
+```json
+{
+  "prompt": "skill-master, veja se existe uma skill para validar este deploy",
+  "activationMode": "balanced",
+  "riskTolerance": "normal"
+}
+```
+
+Saida esperada:
+
+```json
+{
+  "shouldActivate": true,
+  "personaOverlay": "Dev Senior Master",
+  "executionMode": "assist",
+  "safetyGates": [],
+  "learningOpportunity": false,
+  "notionUpdateNeeded": false
+}
+```
+
+Use `skill_master_activation_check` quando precisar apenas de uma decisao menor e retrocompativel de ativacao/recomendacao.
+
+Restricoes explicitas como `sem publicar`, `nao publicar` ou `nao publique` sao tratadas como execucao local. O router deve registrar `publication_explicitly_disabled` e nao pode transformar essa frase em autorizacao ou intencao de release.
 
 Ativacao explicita:
 
@@ -241,6 +316,11 @@ Cliente: chama skill_master_activation_check.
 Cliente: se ativar, chama skill_master_recommend ou segue as recomendacoes retornadas.
 ```
 
+Diagnostico importante:
+
+- `skill_master_list_sources` mostra `configPath`, `workspace` e se `workspaceRoots` esta configurado.
+- Se `workspaceRoots` estiver vazio, skills em `.codex/skills` do projeto nao serao catalogadas ate atualizar `sources.json` e reiniciar o processo MCP.
+
 ## Atualizacao automatica via npm
 
 Para instalacoes feitas por `npm install -g`, o caminho seguro de auto-update e executar `skill-master-update` fora do processo MCP.

package/VERSION.md

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

package/bin/lib/menu-core.mjs

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import process from 'node:process';
 
@@ -39,6 +39,9 @@ export function getMenuStatus(rootDir) {
   const packageJson = readJson(rootDir, 'package.json');
   const stableManifest = readJson(rootDir, 'manifests/channels/stable.json');
   const versionText = readText(rootDir, 'VERSION.md');
+  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');
 
   return {
     packageName: packageJson?.name ?? 'nao encontrado',
@@ -47,9 +50,29 @@ export function getMenuStatus(rootDir) {
     manifestSemver: stableManifest?.semver ?? 'nao encontrado',
     versionText,
     rootDir,
+    pendingSuccessDrafts: countManifestFiles(successLearningDir),
+    studyCandidates: Array.isArray(studyCandidates?.candidates) ? studyCandidates.candidates.length : 0,
   };
 }
 
+function countManifestFiles(directory) {
+  if (!directory || !existsSync(directory)) {
+    return 0;
+  }
+
+  let count = 0;
+  const visit = (current) => {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const fullPath = join(current, entry.name);
+      if (entry.isDirectory()) visit(fullPath);
+      else if (entry.isFile() && entry.name === 'manifest.json') count += 1;
+    }
+  };
+
+  visit(directory);
+  return count;
+}
+
 export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process.execPath }) {
   return [
     {
@@ -107,6 +130,106 @@ export function buildMenuCommands({ rootDir, currentFile, nodeExecPath = process
       args: ['scripts/configure-private-registry.mjs', '--validate'],
       confirmMessage: 'Rodar a configuracao de registry privado agora?',
     },
+    {
+      key: 'activationStatus',
+      aliases: ['activation-status', 'modo', 'modo-ativacao'],
+      label: 'Modo de ativacao atual',
+      description: 'Mostra o modo manual, balanced ou always-on-assisted configurado localmente.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--status'],
+    },
+    {
+      key: 'activationBalanced',
+      aliases: ['set-balanced', 'balanced'],
+      label: 'Usar modo balanced',
+      description: 'Define balanced como modo padrao de ativacao do Skill Master.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--set-mode', 'balanced'],
+    },
+    {
+      key: 'activationAlwaysOn',
+      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.',
+      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: '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.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--route-prompt-interactive'],
+    },
+    {
+      key: 'successNotifications',
+      aliases: ['notifications', 'notificacoes', 'success-notifications'],
+      label: 'Notificacoes de skills aprendidas',
+      description: 'Mostra drafts pendentes, aprovacoes e skills externas para estudar.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--notify'],
+    },
+    {
+      key: 'studySkills',
+      aliases: ['study-skills', 'skills-estudo', 'estudar'],
+      label: 'Skills para estudar',
+      description: 'Lista skills externas e links de criadores ainda nao aprovados.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--study'],
+    },
+    {
+      key: 'approvalPackage',
+      aliases: ['approval-package', 'aprovar', 'pacote-aprovacao'],
+      label: 'Gerar pacote de aprovacao humana',
+      description: 'Cria um relatorio local para revisar e aprovar skills aprendidas.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--approval-package'],
+    },
+    {
+      key: 'markLearnedStudy',
+      aliases: ['mark-study', 'manter-estudo'],
+      label: 'Manter skill candidata para estudo',
+      description: 'Seleciona uma candidata e registra decisao de manter para estudo.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--mark-study-interactive'],
+    },
+    {
+      key: 'rejectLearnedSkill',
+      aliases: ['reject-skill', 'rejeitar-skill'],
+      label: 'Rejeitar skill candidata',
+      description: 'Seleciona uma candidata, registra rejeicao e preserva historico.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-success-skills.mjs'), '--reject-interactive'],
+      confirmMessage: 'Abrir fluxo para rejeitar uma skill candidata?',
+    },
+    {
+      key: 'activateLearnedLocal',
+      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.',
+      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?',
+    },
+    {
+      key: 'activateLearnedGlobal',
+      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.',
+      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?',
+    },
+    {
+      key: 'notionSummary',
+      aliases: ['notion-summary', 'resumo-notion'],
+      label: 'Abrir resumo para Notion',
+      description: 'Mostra um resumo copiavel do estado de ativacao para registrar no ledger Notion.',
+      command: nodeExecPath,
+      args: [join(rootDir, 'bin', 'skill-master-activation.mjs'), '--notion-summary'],
+    },
   ];
 }
 
@@ -145,6 +268,8 @@ export function formatStatusReport(status) {
     `Semver local: ${status.semver}`,
     `Manifesto stable: ${status.manifestVersion}`,
     `Manifesto semver: ${status.manifestSemver}`,
+    `Drafts de skills aprendidas: ${status.pendingSuccessDrafts}`,
+    `Skills externas para estudar: ${status.studyCandidates}`,
   ];
 
   if (status.versionText) {
@@ -168,6 +293,7 @@ export function formatMenuBanner(status, { useColor = false } = {}) {
     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`,
     colorize('Setas + Enter para navegar', ANSI.dim, useColor),
   ];
   return renderPanelLines(lines, { color: ANSI.cyan, useColor });

package/bin/skill-master-activation.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import prompts from 'prompts';
+import { buildCatalog, loadConfig } from '../dist/catalog.js';
+import { routeSkillMasterPrompt } from '../dist/prompt-router.js';
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const skillMasterHome = process.env.SKILL_MASTER_HOME ?? path.join(os.homedir(), '.skill-master');
+const activationConfigPath = process.env.SKILL_MASTER_ACTIVATION_CONFIG
+  ?? path.join(skillMasterHome, 'activation.json');
+const sourcesConfigPath = process.env.SKILL_MASTER_CONFIG ?? path.join(rootDir, 'sources.json');
+const workspace = process.env.SKILL_MASTER_WORKSPACE ?? process.cwd();
+
+const defaultConfig = {
+  activationMode: 'balanced',
+  riskTolerance: 'normal',
+};
+
+const isTty = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+
+const readActivationConfig = () => {
+  if (!existsSync(activationConfigPath)) return defaultConfig;
+  return { ...defaultConfig, ...JSON.parse(readFileSync(activationConfigPath, 'utf8')) };
+};
+
+const writeActivationConfig = (config) => {
+  mkdirSync(path.dirname(activationConfigPath), { recursive: true });
+  writeFileSync(activationConfigPath, JSON.stringify(config, null, 2), 'utf8');
+};
+
+const parseArgs = (argv) => {
+  const parsed = {
+    command: 'status',
+    mode: null,
+    prompt: null,
+    format: 'markdown',
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--status') parsed.command = 'status';
+    else if (arg === '--set-mode') {
+      parsed.command = 'set-mode';
+      parsed.mode = argv[++index] ?? null;
+    } else if (arg === '--route-prompt') {
+      parsed.command = 'route-prompt';
+      parsed.prompt = argv[++index] ?? null;
+    } else if (arg === '--route-prompt-interactive') parsed.command = 'route-prompt-interactive';
+    else if (arg === '--notion-summary') parsed.command = 'notion-summary';
+    else if (arg === '--json') parsed.format = 'json';
+    else if (arg === '--help' || arg === '-h') parsed.command = 'help';
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return parsed;
+};
+
+const loadSkills = async () => {
+  const config = await loadConfig(sourcesConfigPath);
+  const catalog = await buildCatalog(config, { cwd: workspace, includeWeb: false });
+  return catalog.skills;
+};
+
+const routePrompt = async (prompt, { format }) => {
+  if (!prompt) throw new Error('Missing prompt.');
+  const config = readActivationConfig();
+  const skills = await loadSkills();
+  const decision = routeSkillMasterPrompt(skills, prompt, {
+    activationMode: config.activationMode,
+    riskTolerance: config.riskTolerance,
+    limit: 8,
+    sourceKinds: ['workspace', 'local', 'plugin'],
+  });
+
+  if (format === 'json') {
+    console.log(JSON.stringify(decision, null, 2));
+    return;
+  }
+
+  console.log('Skill Master - prompt router');
+  console.log(`- Ativar: ${decision.shouldActivate ? 'sim' : 'nao'}`);
+  console.log(`- Modo: ${decision.activationMode}`);
+  console.log(`- Execucao: ${decision.executionMode}`);
+  console.log(`- Persona: ${decision.personaOverlay}`);
+  console.log(`- Proxima acao: ${decision.nextAction}`);
+  if (decision.recommendedSkills.length > 0) {
+    console.log('- Skills:');
+    for (const skill of decision.recommendedSkills.slice(0, 5)) {
+      console.log(`  - ${skill.name} (${skill.source})`);
+    }
+  }
+};
+
+const printStatus = () => {
+  const config = readActivationConfig();
+  console.log('Skill Master - modo de ativacao');
+  console.log(`- Config: ${activationConfigPath}`);
+  console.log(`- Modo: ${config.activationMode}`);
+  console.log(`- Tolerancia de risco: ${config.riskTolerance}`);
+  console.log(`- Workspace: ${workspace}`);
+};
+
+const setMode = (mode) => {
+  if (!['manual', 'balanced', 'always-on-assisted'].includes(mode)) {
+    throw new Error('Mode must be manual, balanced, or always-on-assisted.');
+  }
+  const config = { ...readActivationConfig(), activationMode: mode };
+  writeActivationConfig(config);
+  console.log(`Modo de ativacao atualizado para: ${mode}`);
+};
+
+const routePromptInteractive = async (format) => {
+  if (!isTty()) throw new Error('Interactive prompt routing requires a TTY.');
+  const response = await prompts({
+    type: 'text',
+    name: 'prompt',
+    message: 'Qual prompt voce quer avaliar?',
+    validate: (value) => value.trim().length >= 3 || 'Informe ao menos 3 caracteres.',
+  });
+  await routePrompt(response.prompt, { format });
+};
+
+const printNotionSummary = () => {
+  const config = readActivationConfig();
+  console.log('## Resumo para Notion - Skill Master Activation');
+  console.log('');
+  console.log(`- Modo atual: ${config.activationMode}`);
+  console.log(`- Tolerancia de risco: ${config.riskTolerance}`);
+  console.log(`- Workspace: ${workspace}`);
+  console.log('- Politica: nenhuma publicacao sem autorizacao explicita.');
+  console.log('- Recomendacao: registrar mudancas de modo, decisoes de skills aprendidas e releases pendentes no ledger do Skill Master.');
+};
+
+const printHelp = () => {
+  console.log(`Skill Master Activation
+
+Usage:
+  skill-master-activation --status
+  skill-master-activation --set-mode manual|balanced|always-on-assisted
+  skill-master-activation --route-prompt "prompt" [--json]
+  skill-master-activation --route-prompt-interactive
+  skill-master-activation --notion-summary
+`);
+};
+
+try {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.command === 'help') printHelp();
+  else if (args.command === 'status') printStatus();
+  else if (args.command === 'set-mode') setMode(args.mode);
+  else if (args.command === 'route-prompt') await routePrompt(args.prompt, { format: args.format });
+  else if (args.command === 'route-prompt-interactive') await routePromptInteractive(args.format);
+  else if (args.command === 'notion-summary') printNotionSummary();
+  else throw new Error(`Unsupported command: ${args.command}`);
+} catch (error) {
+  process.stderr.write(`[skill_master] ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+}

package/bin/skill-master-eval-activation.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { runActivationEvals } from '../dist/activation-evals.js';
+
+const report = runActivationEvals();
+const asJson = process.argv.includes('--json');
+
+if (asJson) {
+  console.log(JSON.stringify(report, null, 2));
+} else {
+  console.log('Skill Master Activation Evals');
+  console.log(`- Generated at: ${report.generatedAt}`);
+  console.log(`- Total: ${report.total}`);
+  console.log(`- Passed: ${report.passed}`);
+  console.log(`- Failed: ${report.failed}`);
+  console.log(`- Accuracy: ${(report.accuracy * 100).toFixed(1)}%`);
+  console.log(`- False positives: ${report.falsePositives}`);
+  console.log(`- False negatives: ${report.falseNegatives}`);
+  console.log(`- Correct blocks: ${report.correctBlocks}`);
+  console.log(`- Recommendation: ${report.recommendation}`);
+
+  const failed = report.results.filter((result) => !result.passed);
+  if (failed.length > 0) {
+    console.log('');
+    console.log('Failed cases:');
+    for (const result of failed) {
+      console.log(`- ${result.case.id}: ${result.findings.join('; ')}`);
+    }
+  }
+}
+
+process.exitCode = report.recommendation === 'balanced-ready' ? 0 : 1;