bps-kit 1.0.7 → 1.0.9

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+Todas as mudanças notáveis ​​neste projeto serão documentadas neste arquivo.
+
+O formato é baseado no [Keep a Changelog](https://keepachangelog.com/pt-BR/1.0.0/), 
+e este projeto adere ao [Versionamento Semântico](https://semver.org/lang/pt-BR/).
+
+## [1.0.9] - 2026-03-08
+### Modificado
+- Refatoração visual completa do `README.md` com adição de emblemas (badges) e seções formatadas.
+- Remoção de menções à ferramentas de terceiros no README, com foco centralizado na engine do Antigravity e na integração oficial do VS Code.
+- Inclusão oficial garantida de `node_modules/` no `.gitignore` para limpezas.
+- Finalização da auditoria do artefato de checkup para a infraestrutura do Copilot.
+
+## [1.0.8] - 2026-03-08
+### Adicionado
+- **Flag `--basic`:** Incluída opção de economia extrema de tokens, importando apenas 11 skills do core cognitivo e analítico da IA, reduzindo o overflow da janela de contexto.
+- **Flag `--vscode`:** Grande atualização de arquitetura. O CLI agora suporta a conversão "on-the-fly" da arquitetura `.agents` tradicional para a arquitetura `.github` requerida nativamente pelo **GitHub Copilot** no VS Code.
+
+## [1.0.7] - 2026-03-08
+### Corrigido
+- Ajuste e inclusão das especificações de Licença (MIT) diretamente na documentação primária do repositório público.
+
+## [1.0.6] - 2026-03-08
+### Ajustado
+- Remoção pesada das referências "fantasmas" dos paths do Antigravity nos templates do `GEMINI.md` e do `VAULT_INDEX.md`, para garantir independência de sistema para os usuários finais.
+
+## [1.0.1] até [1.0.5] - 2026-03-08
+### Corrigido
+- Séries de patches resolutos para contornar o mecanismo de segurança rígido do NPM, que ignorava pastas `.agents` ocultas durante a montagem do pacote de publicação.
+- Solução implementada através de pastas "mock" renomeadas durante a etapa de `dest` do instalador em Node.js.
+
+## [1.0.0] - 2026-03-08
+### Lançamento Inicial
+- Projeto fundado.
+- Criação do instalador executável `npx bps-kit`.
+- Separação revolucionária de mais de 1.200 especialistas/skills em um `Vault` inabitado, resolvendo o problema de limite de context-window e "Attention Decay".
+- Perfis `normal` (39 skills web) e `extra` (65 skills gerais) estabelecidos.
+- Slash workflows, Rules customizadas e Scripts Python auditores importados com sucesso a partir do fork matriz.

package/README.md

@@ -1,25 +1,38 @@
-# 🚀 BPS Kit - The Ultimate Antigravity Brain
+# 🚀 BPS Kit — The Ultimate Antigravity Brain
 
-O **BPS Kit** é a evolução modular e em larga escala do ecossistema de inteligência artificial de desenvolvedor (Antigravity). Ele é projetado como um pacote `npx` que "injeta" as regras, habilidades (skills), personas (agents) e scripts de validação de código direto no seu repositório local (`.agents/`).
+O **BPS Kit** é a evolução modular e de larga escala do consagrado ecossistema de inteligência artificial de desenvolvedor (Antigravity). Ele é projetado como um pacote `npx` que "injeta" as regras milimétricas, habilidades (skills), personas (agents) e scripts de validação de código direto no seu repositório local.
 
-Seu principal diferencial é o **Skill Vault System**: o sistema resolve o limite de tokens das LLMs ao armazenar mais de +1.200 skills em um cofre (Vault) com um índice super comprimido, mantendo no seu "Core Ativo" apenas as Skills cruciais baseadas em qual perfil de desenvolvimento você precisa (Web/React ou Full/Python/Sec/Cloud).
+Seu principal diferencial é o brilhante **Skill Vault System**: o sistema resolve o temido limite de tokens (Context Window) das LLMs ao armazenar mais de +1.200 skills valiosas em um cofre fechado (Vault) munido de um índice super comprimido. Ele mantém no seu "Core Ativo" apenas as Skills cruciais baseadas no perfil de desenvolvimento escolhido (ex: Web, Sec, Cloud).
 
 ## 📦 Instalação (Via NPX)
 
-Você pode instanciar o "cérebro" da Inteligência Artificial em qualquer repositório executando o cli diretamente:
+Você não precisa e não deve instalar isso via `npm install` fixo. Você invoca a maleta de ferramentas instantaneamente na raiz do projeto sempre que quiser injetar o "cérebro":
 
 ```bash
-# Para a stack Web tradicional (39 Skills ultra eficientes)
-npx bps-kit --normal
+# 🟢 Modo Essencial (Antigravity Core - Web/React/Next - 39 Skills)
+npx bps-kit@latest --normal
 
-# Para a stack Completa Avançada (65 Skills: Python, Pentest, DevOps, Data)
-npx bps-kit --extra
+# 🔴 Modo Extra (Engenharia Pesada - Cloud/Sec/Python/QA - 65 Skills)
+npx bps-kit@latest --extra
+
+# 🟡 Modo Economia Extrema (Apenas Motor Analítico - 11 Skills Cognitivas)
+npx bps-kit@latest --basic
+
+# 💻 Integrar nativamente para VS Code (GitHub Copilot)
+# Adicione a flag --vscode combinada a qualquer um dos perfis acima:
+npx bps-kit@latest --basic --vscode
 ```
 
-### O que acontece após a instalação?
-- A pasta `.agents/` será criada na raiz do seu repositório.
-- Nela residirá o seu `GEMINI.md` master, as pastas de `agents`, `scripts`, `workflows`, `skills` (Ativas) e `vault` (Inativas + Index).
-- A IA que ler sua base de código (ex: Antigravity no editor Windsurf ou Cursor) passará instantaneamente a obedecer essas diretrizes, possuindo validação lint e audit out-of-the-box.
+### 🧠 O que acontece após a instalação? (Motor Antigravity Padrão)
+- A pasta oculta `.agents/` será criada na raiz do seu repositório.
+- A IA que ler sua base de código passará instantaneamente a obedecer ao manifesto militar contido lá (o arquivo `GEMINI.md`), possuindo validação lint e audição de arquivos *out-of-the-box*.
+
+### ⚡ O que acontece após a instalação? (VS Code / Copilot)
+Se você adicionou a flag `--vscode`, a arquitetura compilada será organicamente moldada para as regras da nuvem do GitHub (`.github/`):
+- O manifesto base e as Workflows irão habitar o `.github/copilot-instructions.md`.
+- As Skills ativas receberão glob patterns específicos (`applyTo: "**/*"`) protegendo seu ciclo de vida.
+- As famosas 20 Personas se fundirão em um único registro local `.github/AGENTS.md`.
+- A gigantesca Vault contendo +1000 skills inativas será armazenada inteligentemente em isolamento (`.copilot-vault/`), salvando permanentemente seu limite de Chat no VS Code de travar.
 
 ### 🪄 Autocalibragem de Base de Código (Workflow Analyzer)
 O BPS Kit inclui uma workflow customizada! Após rodar o npx no projeto, apenas diga para a IA no seu chat:
@@ -28,31 +41,27 @@ O BPS Kit inclui uma workflow customizada! Após rodar o npx no projeto, apenas
 
 A inteligência fará um _scan_ do seu `package.json`, `requirements.txt` ou `composer.json` e autoativará skills específicas alojadas na Vault de acordo com a sua stack real!
 
-### 🧠 Lidando com a Amnésia da IA (Attention Decay)
-
-Devido às limitações arquiteturais das LLMs modernas (como a enorme janela de contexto e o modelo de *Attention Decay*), assim como conflitos com o *System Prompt* nativo da IDE, a IA pode ocasionalmente "esquecer" ou atropelar o protocolo estrito do nosso `GEMINI.md` (deixando de anunciar a Persona e pulando o checklist) em conversas que fiquem muito extensas.
+### 🛠️ Lidando com a Amnésia da IA (Attention Decay)
 
-**Como Reverter:**
-O BPS Kit já embute `Anti-Amnesia Protocols` nas regras internas, mas a sua melhor defesa caso a máquina saia dos trilhos para lhe entregar o código "mais rápido" que a formatação é o **RLHF (Reinforcement Learning from Human Feedback)** direcional.
+Bugs de esquecimento ocorrem devido às limitações físicas das LLMs (enorme janela de contexto vs degradação de atenção ao longo da conversa). Com o tempo, a IA pode ocasionalmente "esquecer" ou atropelar o protocolo estrito do nosso manifesto.
 
-Caso não veja o anúncio obrigatório da IA (ex: `🤖 Applying knowledge...`), simplesmente dê o comando no chat:
+**A Cura imediata via RLHF:**  
+O BPS Kit já embute dezenas de mecanismos passivos de _Anti-Amnesia Protocols_. Contudo, a sua melhor e definitiva defesa contínua é aplicar o **RLHF (Reinforcement Learning from Human Feedback)** direcional no chat quando o bot errar:
 
-> *"Você quebrou as regras do BPS Kit. Volte a ler e aplicar estritamente o GEMINI.md."*
+> *"Você quebrou as regras do seu System Prompt e do Antigravity Kit. Volte a ler e aplicar estritamente as regras de Skills abordadas de novo."*
 
-Isso limpará as abstrações ruidosas e renovará os tensores de atenção instantaneamente, religando o protocolo militar exigido pelo pacote.
+Isso forçará a engine a jogar o lixo fora e focar nos blocos iniciais cruciais.
 
 ---
 
-## 🏗️ Slash Commands Integrados 
+## 🏗️ Slash Commands Nativos (Modo Standard)
 
-Acesse workflows robustos empacotados digitando barras (slash) no chat da IA:
+Se não estiver usando a flag `--vscode` (onde workflows são embutidas), você terá acesso à estrutura local com robustez. Digite no chat da sua IA:
 
-- `/brainstorm` - Explorar opções antes de implementar.
-- `/create` - Iniciar novos aplicativos Full-Stack.
-- `/plan` - Desdobramentos detalhados de planejamento técnico.
-- `/debug` - Debugger sistemático pesado baseado nos scripts Python.
-- `/deploy` - Validações hardcore antes de empurrar pra produção.
-- `/setup-brain` - Roda o Analyzer de calibração do BPS Kit.
+- `/brainstorm` - O mais importante. Obrigue-a explorar opções antes de disparar o teclado para programar.
+- `/plan` - Desdobramentos detalhados de planejamento arquitetural.
+- `/debug` - Roda o framework forense completo contra erros de teste (Systematic Debugging).
+- `/deploy` - Exige checagens manuais e de segurança pesadas antes de cometer um simples origin master push.
 
 ---
 
@@ -60,13 +69,13 @@ Acesse workflows robustos empacotados digitando barras (slash) no chat da IA:
 
 O **BPS Kit** deve sua fundação brilhante e seu mar enciclopédico de regras a bibliotecas open-source excepcionais de onde os templates originais foram bifurcados/incorporados. Deixamos nossos enormes agradecimentos às fontes originais:
 
-1. **[antigravity-awesome-skills (by sickn33)](https://github.com/sickn33/antigravity-awesome-skills)**
-   Essa é a mãe das +1.000 (mais de mil!) skills que formam a nossa pasta de *Vault* no BPS Kit, conferindo uma capabiliade gigantesca em Virtualmente quase qualquer cenário de tecnologia (Marketing, Cloud, Languages, DBs, Mobile e Copywriting).
+1. **[antigravity-awesome-skills (by sickn33)](https://github.com/sickn33/antigravity-awesome-skills)**  
+   A mãe de virtualmente todas as nossas mais de 1.100+ skills abrigadas no Vault. Essa bibilioteca lendária confere a capacidade enciclopédica esmagadora de cobrir quase que a íntegra dos casos de uso para software development do planeta (Mobile, Machine Learning, Copywriting, FinOps, Design, Data Engineering e DevOps).
 
-2. **[antigravity-kit (by vudovn)](https://github.com/vudovn/antigravity-kit)**
-   A origem estrutural (A pasta base, Referências do fluxo Central - `rules`, `agents`, os 18 scripts validadores Python hardcore e as personas/slash commands mestras como `/brainstorm` e `/test`). 
+2. **[antigravity-kit (by vudovn)](https://github.com/vudovn/antigravity-kit)**  
+   A forja estrutural primária. Responsável pela árvore original de Personas de Agentes, Workflows, Slash Commands, e os potentes 18 scripts de validação Python Hardcore na camada de código em si.
 
-O **BPS Kit** une esse conhecimento através de engenharias de "Auto Routing" contornando os limites de Tokens. Sem vudovn e sickn33, essa maravilha não funcionaria. 
+A engenharia inteira do **BPS Kit** serve massivamente para unificar essas duas titânicas inteligências em um fluxo só — através da magia do Auto-Routing isolacionista por Glob e do Vaulting Comprimido — ultrapassando enfim as limitações brutais da context-window. Sem a colaboração fundadora de vudovn e sickn33, essa maravilha não existiria.
 
 ---
 ## 📄 Licença

package/bin/cli.js

@@ -9,8 +9,10 @@ const { program } = require('commander');
 program
     .version('1.0.0')
     .description('BPS Kit Installer - The NextGen Modular AI Brain Setup')
-    .option('-n, --normal', 'Instala apenas as skills essenciais (39 skills, ideal para Web/React/Next)')
+    .option('-b, --basic', 'Modo economia extrema (11 skills apenas o core analítico, ideal para Copilot)')
+    .option('-n, --normal', 'Instala as skills essenciais (39 skills, ideal para Web/React/Next)')
     .option('-e, --extra', 'Instala as skills avançadas Premium (65 skills, inclui Python, QA, Cloud e Sec)')
+    .option('--vscode', 'Converte a estrutura final herdada do Cursor/Windsurf (.agents) para o formato do VS Code GitHub Copilot (.github)')
     .parse(process.argv);
 
 const options = program.opts();
@@ -27,10 +29,12 @@ async function runInstaller() {
 
     // Determinar o mode (default normal se nao passar args)
     let mode = 'normal';
-    if (options.extra) {
+    if (options.basic) {
+        mode = 'basic';
+    } else if (options.extra) {
         mode = 'extra';
-    } else if (!options.normal && !options.extra) {
-        console.log(chalk.yellow('⚠️  Nenhum perfil explicitado (--normal ou --extra). Utilizando default: --normal\\n'));
+    } else if (!options.normal && !options.extra && !options.basic) {
+        console.log(chalk.yellow('⚠️  Nenhum perfil explicitado (--basic, --normal ou --extra). Utilizando default: --normal\n'));
     }
 
     const spinner = ora('Montando diretórios base...').start();
@@ -78,25 +82,32 @@ async function runInstaller() {
 
         spinner.text = `Injetando pacotes de skills do perfil [${chalk.yellow(mode)}]...`;
 
-        // Primeiro copia normais
-        await fs.copy(
-            path.join(TEMPLATES_DIR, 'skills_normal'),
-            skillsDest
-        );
+        // Copiar pacote baseado no mode
+        if (mode === 'basic') {
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_basic'), skillsDest);
+        } else if (mode === 'normal') {
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_normal'), skillsDest);
+        } else if (mode === 'extra') {
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_normal'), skillsDest);
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_extra'), skillsDest);
+        }
 
-        // Se extra, copia as complementares
-        if (mode === 'extra') {
-            await fs.copy(
-                path.join(TEMPLATES_DIR, 'skills_extra'),
-                skillsDest
-            );
+        // 5. Conversor para VS Code se solicitado
+        if (options.vscode) {
+            spinner.text = `Transformando arquitetura para padrão GitHub Copilot (VS Code)...`;
+            const { convertToVsCode } = require('../src/scripts/convert_to_vscode');
+            await convertToVsCode(DEST_AGENTS, DEST_BASE);
         }
 
         spinner.succeed(chalk.green('Cérebro de IA instanciado com sucesso!'));
 
+        let finalCount = '39';
+        if (mode === 'basic') finalCount = '11';
+        if (mode === 'extra') finalCount = '65';
+
         console.log(chalk.cyan('\n============== [ RESUMO DA INSTALAÇÃO ] =============='));
         console.log(chalk.white(`Perfil Carregado : `) + chalk.greenBright(mode.toUpperCase()));
-        console.log(chalk.white(`Skills Ativas    : `) + chalk.greenBright(mode === 'extra' ? '65' : '39'));
+        console.log(chalk.white(`Skills Ativas    : `) + chalk.greenBright(finalCount));
         console.log(chalk.white(`Skills no Vault  : `) + chalk.greenBright('1197'));
         console.log(chalk.cyan('======================================================'));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bps-kit",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "BPS Kit - The Ultimate Antigravity Brain",
   "bin": {
     "bps-kit": "./bin/cli.js"

package/templates/VAULT_INDEX.md

@@ -1,7 +1,7 @@
 # 🗄️ Vault Index
 
-> 1197 skills in `./.agents/vault/`.
-> To use: `view_file ./.agents/vault/{skill-name}/SKILL.md`
+> 1197 skills in `./.agents/antigravity/vault/`.
+> To use: `view_file ./.agents/antigravity/vault/{skill-name}/SKILL.md`
 
 ## Web & Frontend (53)
 3d-web-experience angular angular-best-practices angular-migration angular-state-management angular-ui-patterns animejs-animation antigravity-design-expert antigravity-workflows baseline-ui chrome-extension-developer cloudflare-workers-expert design-md design-orchestration design-spells frontend-dev-guidelines frontend-mobile-development-component-scaffold frontend-mobile-security-xss-scan frontend-security-coder frontend-slides frontend-ui-dark-ts html-injection-testing nextjs-app-router-patterns radix-ui-design-system react-best-practices react-flow-architect react-flow-node-ts react-modernization react-native-architecture react-nextjs-development react-state-management react-ui-patterns spline-3d-integration tailwind-design-system threejs-animation threejs-fundamentals threejs-geometry threejs-interaction threejs-lighting threejs-loaders threejs-materials threejs-postprocessing threejs-shaders threejs-skills threejs-textures ui-skills ui-ux-pro-max ui-visual-validator web-artifacts-builder web-design-guidelines web-scraper web-security-testing webflow-automation

package/templates/agents-template/rules/GEMINI.md

@@ -67,16 +67,16 @@ Agent activated → Check frontmatter "skills:" → Read SKILL.md (INDEX) → Re
 ## 🧠 Skill Auto-Routing System (v8.0.0 — Vault Edition)
 
 ### Architecture
-- **Active skills** (~65): in `./.agents/skills/` — always in context
-- **Vault skills** (~1200+): in `./.agents/vault/` — discoverable via index
+- **Active skills** (~65): in `./.agents/antigravity/skills/` — always in context
+- **Vault skills** (~1200+): in `./.agents/antigravity/vault/` — discoverable via index
 
 ### Core Rule — Skills First
 After invoking any skill, explicitly say: '📖 Using skill: [skill-name]' before proceeding. If no skill was used, say: '⚠️ No skill used — responding from base knowledge.'
 
 ### Routing Flow
 1. Check if an **active skill** covers the request → use it directly
-2. If not → open `./.agents/skills/VAULT_INDEX.md` to find a vault skill
-3. If found → `view_file ./.agents/vault/{name}/SKILL.md`
+2. If not → open `./.agents/antigravity/skills/VAULT_INDEX.md` to find a vault skill
+3. If found → `view_file ./.agents/antigravity/vault/{name}/SKILL.md`
 4. If nothing found → respond from base knowledge
 
 ### Intent → Skill Routing Map (Active Skills)

package/templates/agents-template/scripts/convert_to_vscode.js

@@ -0,0 +1,87 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Converte toda a estrutura .agents importada para .github estrutural do Copilot
+ * @param {string} destAgents O diretorio destino onde a copy crua (.agents) aportou
+ * @param {string} destBase A raiz do repositorio final
+ */
+async function convertToVsCode(destAgents, destBase) {
+    const gitHubDir = path.join(destBase, '.github');
+    const copilotInstructionsDir = path.join(gitHubDir, 'instructions');
+
+    await fs.ensureDir(copilotInstructionsDir);
+
+    console.log(chalk.dim('   [VS Code] Convertendo arquivos para sintaxe do Copilot...'));
+
+    // 1. Converter a rule master GEMINI.md em copilot-instructions.md
+    const geminiPath = path.join(destAgents, 'rules', 'GEMINI.md');
+    if (await fs.pathExists(geminiPath)) {
+        let content = await fs.readFile(geminiPath, 'utf8');
+        // Adaptamos os caminhos na rule principal para o contexto do .github/ do VS Code
+        content = content.replace(/\.\/\.agents\/skills\//g, './.github/instructions/');
+        content = content.replace(/\.\/\.agents\/vault\//g, './.copilot-vault/');
+        content = content.replace(/\.\/\.agents\/rules\/GEMINI\.md/g, './.github/copilot-instructions.md');
+
+        // As workflows no VS Code estao desabrigadas da pasta nativa, sugerimos le-las do vault ou inline
+        content += `\n\n## 🔄 Workflows Base\nAs workflows antigas de Cursor (/brainstorm, etc) agora devem ser invocadas naturalmente no chat: "Rode o fluxo de brainstorm". Consulte o AGENTS.md para contexto.\n`;
+
+        await fs.writeFile(path.join(gitHubDir, 'copilot-instructions.md'), content);
+    }
+
+    // 2. Converter as skills nativas (ativas) em glob .instructions.md
+    const skillsDest = path.join(destAgents, 'skills');
+    if (await fs.pathExists(skillsDest)) {
+        const skillsDirs = await fs.readdir(skillsDest);
+        for (const skillName of skillsDirs) {
+            const skillFile = path.join(skillsDest, skillName, 'SKILL.md');
+            if (await fs.pathExists(skillFile)) {
+                let content = await fs.readFile(skillFile, 'utf8');
+
+                // Injetamos um frontmatter basico aceitavel pelo Copilot apontando para tudo (**/*) 
+                // para que a Skill ative independente do arquivo no Workspace se for convocada.
+                const vsCodeContent = `---
+description: ${skillName.replace(/-/g, ' ')}
+applyTo: "**/*"
+---
+${content}`;
+                await fs.writeFile(path.join(copilotInstructionsDir, `${skillName}.instructions.md`), vsCodeContent);
+            }
+        }
+    }
+
+    // 3. Converter o Vault Index (Tudo que esta no index vira uma mera instruction text base local)
+    const vaultIndexSrc = path.join(destAgents, 'VAULT_INDEX.md');
+    if (await fs.pathExists(vaultIndexSrc)) {
+        let content = await fs.readFile(vaultIndexSrc, 'utf8');
+        content = content.replace(/\.\/\.agents\/vault\//g, './.copilot-vault/');
+        await fs.writeFile(path.join(copilotInstructionsDir, 'VAULT_INDEX.instructions.md'), content);
+    }
+
+    // 4. Mover o Vault inteiro para uma pasta customizada oculta que nao polua a base restrita do Git / do Copilot local
+    const vaultSrc = path.join(destAgents, 'vault');
+    const copilotVaultDir = path.join(destBase, '.copilot-vault');
+    if (await fs.pathExists(vaultSrc)) {
+        await fs.move(vaultSrc, copilotVaultDir, { overwrite: true });
+    }
+
+    // 5. Consolidar as 20 personas (AGENTS) num unico arquivao master na root do github chamado AGENTS.md
+    const agentsSrc = path.join(destAgents, 'agents');
+    if (await fs.pathExists(agentsSrc)) {
+        const agentFiles = await fs.readdir(agentsSrc);
+        let consolidatedAgents = `# 🤖 Antigravity Copilot Agents Roster\n\n`;
+        for (const agent of agentFiles) {
+            if (agent.endsWith('.md')) {
+                const content = await fs.readFile(path.join(agentsSrc, agent), 'utf8');
+                consolidatedAgents += `\n## Agent: ${agent.replace('.md', '')}\n${content}\n---\n`;
+            }
+        }
+        await fs.writeFile(path.join(gitHubDir, 'AGENTS.md'), consolidatedAgents);
+    }
+
+    // Limpeza pesada! Como o ambiente ja foi migrado de .agents para .github e .copilot-vault, delete a origem da instalacao hibrida.
+    await fs.remove(destAgents);
+}
+
+module.exports = { convertToVsCode };

package/templates/skills_basic/behavioral-modes/SKILL.md

@@ -0,0 +1,247 @@
+---
+name: behavioral-modes
+description: "AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Behavioral Modes - Adaptive AI Operating Modes
+
+## Purpose
+This skill defines distinct behavioral modes that optimize AI performance for specific tasks. Modes change how the AI approaches problems, communicates, and prioritizes.
+
+---
+
+## Available Modes
+
+### 1. 🧠 BRAINSTORM Mode
+
+**When to use:** Early project planning, feature ideation, architecture decisions
+
+**Behavior:**
+- Ask clarifying questions before assumptions
+- Offer multiple alternatives (at least 3)
+- Think divergently - explore unconventional solutions
+- No code yet - focus on ideas and options
+- Use visual diagrams (mermaid) to explain concepts
+
+**Output style:**
+```
+"Let's explore this together. Here are some approaches:
+
+Option A: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+Option B: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+What resonates with you? Or should we explore a different direction?"
+```
+
+---
+
+### 2. ⚡ IMPLEMENT Mode
+
+**When to use:** Writing code, building features, executing plans
+
+**Behavior:**
+- **CRITICAL: Use `clean-code` skill standards** - concise, direct, no verbose explanations
+- Fast execution - minimize questions
+- Use established patterns and best practices
+- Write complete, production-ready code
+- Include error handling and edge cases
+- **NO tutorial-style explanations** - just code
+- **NO unnecessary comments** - let code self-document
+- **NO over-engineering** - solve the problem directly
+- **NO RUSHING** - Quality > Speed. Read ALL references before coding.
+
+**Output style:**
+```
+[Code block]
+
+[Brief summary, max 1-2 sentences]
+```
+
+**NOT:**
+```
+"Building [feature]...
+
+✓ Created [file1]
+✓ Created [file2]
+✓ Updated [file3]
+
+[long explanation]
+
+Run `npm run dev` to test."
+```
+
+---
+
+### 3. 🔍 DEBUG Mode
+
+**When to use:** Fixing bugs, troubleshooting errors, investigating issues
+
+**Behavior:**
+- Ask for error messages and reproduction steps
+- Think systematically - check logs, trace data flow
+- Form hypothesis → test → verify
+- Explain the root cause, not just the fix
+- Prevent future occurrences
+
+**Output style:**
+```
+"Investigating...
+
+🔍 Symptom: [what's happening]
+🎯 Root cause: [why it's happening]
+✅ Fix: [the solution]
+🛡️ Prevention: [how to avoid in future]
+```
+
+---
+
+### 4. 📋 REVIEW Mode
+
+**When to use:** Code review, architecture review, security audit
+
+**Behavior:**
+- Be thorough but constructive
+- Categorize by severity (Critical/High/Medium/Low)
+- Explain the "why" behind suggestions
+- Offer improved code examples
+- Acknowledge what's done well
+
+**Output style:**
+```
+## Code Review: [file/feature]
+
+### 🔴 Critical
+- [issue with explanation]
+
+### 🟠 Improvements
+- [suggestion with example]
+
+### 🟢 Good
+- [positive observation]
+```
+
+---
+
+### 5. 📚 TEACH Mode
+
+**When to use:** Explaining concepts, documentation, onboarding
+
+**Behavior:**
+- Explain from fundamentals
+- Use analogies and examples
+- Progress from simple to complex
+- Include practical exercises
+- Check understanding
+
+**Output style:**
+```
+## Understanding [Concept]
+
+### What is it?
+[Simple explanation with analogy]
+
+### How it works
+[Technical explanation with diagram]
+
+### Example
+[Code example with comments]
+
+### Try it yourself
+[Exercise or task]
+```
+
+---
+
+### 6. 🚀 SHIP Mode
+
+**When to use:** Production deployment, final polish, release preparation
+
+**Behavior:**
+- Focus on stability over features
+- Check for missing error handling
+- Verify environment configs
+- Run all tests
+- Create deployment checklist
+
+**Output style:**
+```
+## Pre-Ship Checklist
+
+### ✅ Code Quality
+- [ ] No TypeScript errors
+- [ ] ESLint passing
+- [ ] All tests passing
+
+### ✅ Security
+- [ ] No exposed secrets
+- [ ] Input validation complete
+
+### ✅ Performance
+- [ ] Bundle size acceptable
+- [ ] No console.logs
+
+### 🚀 Ready to deploy
+```
+
+---
+
+## Mode Detection
+
+The AI should automatically detect the appropriate mode based on:
+
+| Trigger | Mode |
+|---------|------|
+| "what if", "ideas", "options" | BRAINSTORM |
+| "build", "create", "add" | IMPLEMENT |
+| "not working", "error", "bug" | DEBUG |
+| "review", "check", "audit" | REVIEW |
+| "explain", "how does", "learn" | TEACH |
+| "deploy", "release", "production" | SHIP |
+
+---
+
+## Multi-Agent Collaboration Patterns (2025)
+
+Modern architectures optimized for agent-to-agent collaboration:
+
+### 1. 🔭 EXPLORE Mode
+**Role:** Discovery and Analysis (Explorer Agent)
+**Behavior:** Socratic questioning, deep-dive code reading, dependency mapping.
+**Output:** `discovery-report.json`, architectural visualization.
+
+### 2. 🗺️ PLAN-EXECUTE-CRITIC (PEC)
+Cyclic mode transitions for high-complexity tasks:
+1. **Planner:** Decomposes the task into atomic steps (`task.md`).
+2. **Executor:** Performs the actual coding (`IMPLEMENT`).
+3. **Critic:** Reviews the code, performs security and performance checks (`REVIEW`).
+
+### 3. 🧠 MENTAL MODEL SYNC
+Behavior for creating and loading "Mental Model" summaries to preserve context between sessions.
+
+---
+
+## Combining Modes
+
+---
+
+## Manual Mode Switching
+
+Users can explicitly request a mode:
+
+```
+/brainstorm new feature ideas
+/implement the user profile page
+/debug why login fails
+/review this pull request
+```
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.