@eximia-ventures/claude-code-toolkit 5.2.1 → 5.3.0

package/README.md

@@ -29,6 +29,7 @@ O `claude-code-toolkit` transforma sua experiência com o Claude Code instalando
 | **eximia-meter** | Monitor de consumo de tokens no menu bar do macOS |
 | **AIOS Framework** | 7 slash commands com wizards interativos: story, epic, QA, publish, bootstrap, help, integrate (opt-in) |
 | **Squad Forge** | Transforma squads e agents em plataformas visuais interativas (Chat, Canvas, Wizard, Dashboard) |
+| **Pacotes externos** | Instala pacotes complementares via `npm install` (ex: `@eximia-ventures/ds`) |
 
 ---
 
@@ -465,7 +466,7 @@ forge/{target}/
 
 ### Design System Manager (`@eximia-ventures/ds`) 📦
 
-Pacote npm complementar que gerencia design systems como artefatos instaláveis (formato `.dspack`).
+Pacote npm independente que gerencia design systems como artefatos instaláveis (formato `.dspack`). O toolkit oferece sua instalação via wizard — as skills são instaladas pelo próprio pacote.
 
 ```bash
 npm install @eximia-ventures/ds
@@ -487,15 +488,7 @@ meu-ds.dspack
     └── templates/
 ```
 
-**5 Skills instaladas com o AIOS:**
-
-| Skill | Descrição |
-|-------|-----------|
-| `/ds` | Wizard central interativo — menu de operações |
-| `/ds-pack` | Empacota um DS existente em `.dspack` |
-| `/ds-install` | Instala um `.dspack` no projeto (`design-systems/`) |
-| `/ds-list` | Lista DSs instalados e disponíveis |
-| `/ds-apply` | Registra DS como ativo e gera `.ds-context.md` para Brad Frost e `@dev` |
+**Skills instaladas pelo pacote:** `/ds`, `/ds-pack`, `/ds-install`, `/ds-list`, `/ds-apply`
 
 **Fluxo com Forge:**
 
@@ -589,12 +582,7 @@ claude-code-toolkit/
 │       ├── aios-qa.md                # QA toolkit
 │       ├── aios-publish.md           # Release management
 │       ├── aios-bootstrap.md         # Setup de projeto
-│       ├── aios-help.md              # Guia de comandos AIOS
-│       ├── ds.md                     # Design System Manager — wizard central
-│       ├── ds-pack.md                # Empacotar DS em .dspack
-│       ├── ds-install.md             # Instalar .dspack no projeto
-│       ├── ds-list.md                # Listar DSs instalados
-│       └── ds-apply.md               # Registrar DS ativo + gerar contexto
+│       └── aios-help.md              # Guia de comandos AIOS
 └── squads/
     └── forge/                        # Squad Forge (Platform Materializer)
         ├── squad.yaml                # Manifest AIOS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eximia-ventures/claude-code-toolkit",
-  "version": "5.2.1",
+  "version": "5.3.0",
   "description": "Setup completo para Claude Code: statusline, session handoff, AIOS integration",
   "main": "src/index.js",
   "bin": {

package/src/installer.js

@@ -6,6 +6,7 @@ const os = require('os');
 const fs = require('fs-extra');
 const logger = require('./utils/logger');
 const modules = require('./modules');
+const { EXTERNAL_PACKAGES, installPackages } = require('./modules/external-packages');
 
 const MANIFEST_PATH = path.join(os.homedir(), '.claude', '.toolkit-manifest.json');
 
@@ -82,7 +83,23 @@ async function runInstaller() {
     }
   }
 
-  // --- Step 3: AIOS (sempre wizard) ---
+  // --- Step 3: Pacotes externos ---
+  logger.section('Pacotes Externos');
+
+  const { selectedPackages } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedPackages',
+      message: 'Selecione pacotes externos para instalar:',
+      choices: EXTERNAL_PACKAGES.map(p => ({
+        name: `${p.package.padEnd(26)} — ${p.desc}`,
+        value: p.package,
+        checked: false
+      }))
+    }
+  ]);
+
+  // --- Step 4: AIOS (sempre wizard) ---
   logger.section('AIOS Framework');
 
   const { useAios } = await inquirer.prompt([
@@ -129,7 +146,7 @@ async function runInstaller() {
   }
 
   // --- Validate selection ---
-  if (selectedModules.length === 0) {
+  if (selectedModules.length === 0 && selectedPackages.length === 0) {
     logger.warn('Nenhum módulo selecionado. Saindo.');
     return;
   }
@@ -183,6 +200,13 @@ async function runInstaller() {
     }
   }
 
+  // Install external packages
+  if (selectedPackages.length > 0) {
+    logger.section('Pacotes Externos');
+    const pkgResults = await installPackages({ packages: selectedPackages });
+    manifest.externalPackages = pkgResults;
+  }
+
   // Save manifest
   await fs.ensureDir(path.dirname(MANIFEST_PATH));
   await fs.writeJson(MANIFEST_PATH, manifest, { spaces: 2 });
@@ -198,6 +222,9 @@ async function runInstaller() {
   if (selectedModules.includes('aios') && aiosOptions.installAiosSkills?.length > 0) {
     logger.info(`Skills AIOS instaladas: ${aiosOptions.installAiosSkills.join(', ')}`);
   }
+  if (selectedPackages.length > 0) {
+    logger.info(`Pacotes externos: ${selectedPackages.join(', ')}`);
+  }
   logger.blank();
 }
 

package/src/modules/aios.js

@@ -14,12 +14,6 @@ const SKILLS = [
   { src: 'aios-publish.md',   name: '/aios-publish',   desc: 'Release management (version, changelog, publish)' },
   { src: 'aios-bootstrap.md', name: '/aios-bootstrap', desc: 'Setup de projeto (greenfield, brownfield, team, GitHub)' },
   { src: 'aios-help.md',      name: '/aios-help',      desc: 'Guia de comandos AIOS (reference, busca, workflows)' },
-  // Design System Manager (@eximia-ventures/ds)
-  { src: 'ds.md',             name: '/ds',             desc: 'Design System Manager — wizard central interativo' },
-  { src: 'ds-pack.md',        name: '/ds-pack',        desc: 'Empacotar design system em .dspack' },
-  { src: 'ds-install.md',     name: '/ds-install',     desc: 'Instalar um .dspack no projeto' },
-  { src: 'ds-list.md',        name: '/ds-list',        desc: 'Listar design systems instalados' },
-  { src: 'ds-apply.md',       name: '/ds-apply',       desc: 'Registrar DS ativo e gerar contexto para Brad Frost/@dev' },
 ];
 
 async function installCore({ targetDir } = {}) {

package/src/modules/external-packages.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const logger = require('../utils/logger');
+
+/**
+ * Pacotes externos compatíveis com o toolkit.
+ * Cada pacote é instalado via npm e gerencia suas próprias skills.
+ */
+const EXTERNAL_PACKAGES = [
+  {
+    package: '@eximia-ventures/ds',
+    name: 'Design System Manager',
+    desc: 'Gerenciar design systems (.dspack) — skills /ds, /ds-pack, /ds-install, /ds-list, /ds-apply'
+  }
+];
+
+async function installPackages({ packages, targetDir } = {}) {
+  const cwd = targetDir || process.cwd();
+  const toInstall = packages
+    ? EXTERNAL_PACKAGES.filter(p => packages.includes(p.package))
+    : EXTERNAL_PACKAGES;
+
+  const results = [];
+
+  for (const pkg of toInstall) {
+    logger.dim(`Instalando ${pkg.package}...`);
+    try {
+      execSync(`npm install ${pkg.package}`, {
+        cwd,
+        stdio: 'inherit',
+        timeout: 120000
+      });
+      logger.success(`${pkg.package} instalado`);
+      results.push({ package: pkg.package, installed: true });
+    } catch (err) {
+      logger.warn(`Falha ao instalar ${pkg.package}: ${err.message}`);
+      results.push({ package: pkg.package, installed: false, error: err.message });
+    }
+  }
+
+  return results;
+}
+
+module.exports = { EXTERNAL_PACKAGES, installPackages };

package/assets/skill/ds-apply.md

@@ -1,118 +0,0 @@
-# ds-apply
-
-Integra o design system instalado ao projeto — registra como ativo e prepara o contexto para o Brad Frost e o @dev implementarem.
-
-**Este skill NÃO modifica código do projeto.**
-A aplicação real (tokens no tailwind, componentes no src/) é responsabilidade do Brad Frost (`design:design-system`) e do @dev.
-
-## Ativação
-
-Ativado via `/ds-apply` no Claude Code.
-
-## O que faz
-
-1. Define o DS como ativo em `design-systems/manifest.json`
-2. Valida a estrutura do DS (tokens, componentes, metodologia)
-3. Gera um resumo de contexto para o Brad Frost e o @dev
-4. Informa os próximos passos
-
-## Processo
-
-### 1. Identificar DS
-
-Se o usuário passou argumento (`/ds-apply eximia-default`), usar esse.
-Se não, ler `design-systems/manifest.json` e listar instalados:
-
-```
-🎨 ds:apply — Integrar Design System
-
-DSs instalados:
-  1. eximia-default  v1.0.0  (ativo)
-  2. meu-ds          v2.1.0
-
-Qual integrar? (Enter para usar o ativo)
-```
-
-### 2. Validar estrutura do DS
-
-Verificar em `design-systems/{nome}/`:
-- `manifest.json` existe e é válido
-- Pasta `tokens/` ou arquivos de token presentes
-- Estrutura Atomic Design presente (`atoms/`, `molecules/`, etc.) — se tiver componentes
-
-Reportar o que foi encontrado:
-```
-Validando eximia-default...
-  ✅ manifest.json  — v1.0.0, Atomic Design
-  ✅ tokens/        — 3 arquivo(s): tokens.json, tokens.css, tokens.tw.js
-  ✅ atoms/         — 12 componente(s)
-  ✅ molecules/     — 8 componente(s)
-  ✅ organisms/     — 4 componente(s)
-  ⚠️  templates/   — vazio
-```
-
-### 3. Definir como ativo
-
-Atualizar `design-systems/manifest.json`:
-```json
-{
-  "active": "eximia-default"
-}
-```
-
-### 4. Gerar contexto de handoff
-
-Criar `design-systems/.ds-context.md` com as informações que o Brad Frost e o @dev precisam:
-
-```markdown
-# DS Ativo: eximia-default v1.0.0
-
-## Localização
-design-systems/eximia-default/
-
-## Tokens disponíveis
-- tokens/tokens.json    — W3C DTCG format
-- tokens/tokens.css     — CSS custom properties
-- tokens/tokens.tw.js   — Tailwind config
-
-## Componentes disponíveis
-Atoms (12):     Button, Input, Label, Badge, Icon, ...
-Molecules (8):  FormField, SearchBar, Card, ...
-Organisms (4):  Header, Sidebar, AuthForm, ...
-Templates (0):  —
-
-## Metodologia
-Atomic Design (Brad Frost)
-
-## Para o Brad Frost (@design-system)
-Use `design-systems/eximia-default/` como fonte de tokens e componentes.
-Não gere tokens novos — reutilize os existentes.
-
-## Para o @dev
-Importe componentes de `design-systems/eximia-default/components/`.
-Tokens CSS disponíveis em `design-systems/eximia-default/tokens/tokens.css`.
-```
-
-### 5. Confirmar integração
-
-```
-✅ Design System integrado!
-
-  DS ativo: eximia-default v1.0.0
-  Local:    design-systems/eximia-default/
-  Contexto: design-systems/.ds-context.md
-
-  Próximos passos:
-    → Brad Frost aplicará os tokens e componentes no projeto
-    → @dev implementará os componentes conforme o DS
-
-  Para iniciar: @brad-frost *setup ou *build {componente}
-```
-
-## Regras
-
-- NÃO copiar arquivos para `src/` ou qualquer pasta do projeto
-- NÃO modificar `tailwind.config.*`, `package.json` ou qualquer arquivo de configuração do projeto
-- NÃO instalar dependências
-- Apenas registrar, validar e preparar contexto
-- O arquivo `.ds-context.md` é o único output gerado fora de `design-systems/`

package/assets/skill/ds-install.md

@@ -1,94 +0,0 @@
-# ds-install
-
-Instala um arquivo `.dspack` no projeto atual, extraindo seu conteúdo em `design-systems/`.
-
-## Ativação
-
-Ativado via `/ds-install {caminho}` no Claude Code.
-
-## Processo
-
-### 1. Identificar o arquivo
-
-- **Com argumento**: `ds:install ./caminho/arquivo.dspack` — usar o caminho informado
-- **Sem argumento**: listar arquivos `design-systems/*.dspack` e perguntar qual instalar
-
-Se nenhum `.dspack` for encontrado, orientar o usuário a usar `ds:pack` ou obter um arquivo `.dspack`.
-
-### 2. Validar o .dspack
-
-Antes de extrair, verifique:
-
-```bash
-# Verificar se é um zip válido
-unzip -t "{caminho-do-dspack}"
-```
-
-Verificações:
-- O arquivo existe no caminho informado
-- É um zip válido (unzip -t não retorna erro)
-- Contém `manifest.json` na raiz (`unzip -l` mostra o índice)
-- O `manifest.json` tem `name` e `version`
-
-Se qualquer verificação falhar, avise o usuário com a causa e interrompa.
-
-### 3. Verificar conflito
-
-Leia `design-systems/manifest.json`. Se o DS já estiver na lista `installed`:
-
-```
-⚠️  {nome} v{versão-atual} já está instalado.
-   Substituir pela versão {versão-nova}? (s/n)
-```
-
-Se não, prosseguir.
-
-### 4. Extrair
-
-```bash
-# Extrair para design-systems/{nome}/ a partir do caminho absoluto do .dspack
-unzip -o "{caminho-absoluto-do-dspack}" -d "design-systems/{nome}/"
-```
-
-### 5. Atualizar manifest.json do projeto
-
-Leia `design-systems/manifest.json`, faça merge no array `installed` (não substitua), e salve:
-
-```json
-{
-  "version": "1.0.0",
-  "installed": [
-    {
-      "name": "{nome}",
-      "version": "{versão}",
-      "path": "design-systems/{nome}/",
-      "installed_at": "{ISO date atual}"
-    }
-  ],
-  "active": "{nome}"
-}
-```
-
-> Se já havia outros DSs em `installed`, mantê-los. Apenas adicionar (ou atualizar) o novo.
-> Definir `active` como o DS recém-instalado.
-
-### 6. Confirmar
-
-```
-✅ Design System instalado!
-
-  Nome:    {nome}
-  Versão:  {versão}
-  Local:   design-systems/{nome}/
-  Status:  ativo
-
-  Próximo passo:
-    /ds-apply → aplicar tokens e componentes no projeto
-```
-
-## Regras
-
-- Sempre validar o zip antes de extrair
-- Nunca sobrescrever instalação existente sem confirmação
-- Fazer merge no array `installed`, nunca sobrescrever o manifest inteiro
-- Definir o DS recém-instalado como `active` automaticamente

package/assets/skill/ds-list.md

@@ -1,62 +0,0 @@
-# ds-list
-
-Lista os design systems instalados e disponíveis no projeto atual.
-
-## Ativação
-
-Ativado via `/ds-list` no Claude Code.
-
-## Processo
-
-### 1. Verificar design-systems/
-
-Se a pasta `design-systems/` não existir:
-```
-❌ design-systems/ não encontrado.
-   Execute: npm install @eximia-ventures/ds
-```
-Interromper.
-
-### 2. Ler manifest.json
-
-Leia `design-systems/manifest.json`.
-
-Se não existir ou `installed` estiver vazio, pular para o passo 3.
-
-### 3. Escanear .dspack disponíveis
-
-Listar arquivos `design-systems/*.dspack` — estes estão disponíveis mas não instalados.
-
-### 4. Exibir resultado
-
-```
-🎨 Design Systems — {nome-do-projeto}
-
-Instalados:
-  ✅ eximia-default  v1.0.0  (ativo)
-  ○  meu-ds          v2.1.0
-
-Disponíveis (não instalados):
-  📦 outro-ds.dspack
-
-─────────────────────────────────
-  /ds-install {nome}  → instalar
-  /ds-pack            → empacotar um DS existente
-  /ds-apply           → aplicar o DS ativo no projeto
-```
-
-Se não houver nada instalado nem disponível:
-```
-🎨 Design Systems — {nome-do-projeto}
-
-Nenhum DS encontrado.
-
-  /ds-pack    → empacotar um design system existente
-  /ds-install → instalar um arquivo .dspack
-```
-
-## Regras
-
-- Marcar o DS ativo com `(ativo)`
-- Mostrar `.dspack` disponíveis separadamente dos instalados
-- Nome do projeto vem do `package.json` (campo `name`) ou do nome do diretório atual

package/assets/skill/ds-pack.md

@@ -1,92 +0,0 @@
-# ds-pack
-
-Empacota um design system existente em um arquivo `.dspack` (zip renomeado).
-
-## Ativação
-
-Ativado via `/ds-pack` no Claude Code.
-
-## Processo
-
-### 1. Coletar caminho
-
-Pergunte ao usuário:
-```
-📦 ds:pack — Empacotar Design System
-
-Informe o caminho do design system a empacotar:
-(ex: ./src/design-system, ./tokens, ./ui)
-```
-
-Se o caminho não existir, avise e interrompa.
-
-### 2. Escanear o diretório
-
-Analise o diretório e identifique:
-- **Tokens**: `tokens.json`, `tokens.yaml`, `*.css` com variáveis CSS, `tailwind.config.*`
-- **Componentes**: `*.tsx`, `*.jsx`, `*.vue` dentro de `atoms/`, `molecules/`, `organisms/`, `templates/`
-- **Documentação**: `README.md`, `CHANGELOG.md`, configs do Storybook
-
-### 3. Gerar manifest.json
-
-Crie `{caminho}/manifest.json` com o inventário real do scan:
-
-```json
-{
-  "name": "{nome-inferido-do-diretório}",
-  "version": "1.0.0",
-  "description": "",
-  "author": "",
-  "methodology": "atomic-design",
-  "tokens": {
-    "files": ["tokens/tokens.json"],
-    "format": "dtcg | css-variables | tailwind"
-  },
-  "components": {
-    "atoms": ["Button", "Input", "Label"],
-    "molecules": [],
-    "organisms": [],
-    "templates": []
-  },
-  "created_at": "{ISO date atual}"
-}
-```
-
-### 4. Compactar
-
-Use caminhos absolutos para evitar ambiguidade:
-
-```bash
-zip -r "{caminho-absoluto-para-design-systems}/{nome}.dspack" "{caminho-absoluto-do-ds}/" \
-  -x "*/node_modules/*" \
-  -x "*/.git/*" \
-  -x "*/dist/*" \
-  -x "*/build/*" \
-  -x "*/.next/*"
-```
-
-> **Windows (sem zip nativo):** use PowerShell:
-> ```powershell
-> Compress-Archive -Path "{caminho}" -DestinationPath "design-systems/{nome}.dspack"
-> ```
-
-### 5. Confirmar
-
-```
-✅ Design system empacotado!
-
-  Arquivo: design-systems/{nome}.dspack
-  Tamanho: {tamanho}
-  Tokens:  {N} arquivo(s)
-  Atoms:   {N} | Molecules: {N} | Organisms: {N}
-
-  Para instalar em outro projeto:
-    /ds-install design-systems/{nome}.dspack
-```
-
-## Regras
-
-- Nunca incluir `node_modules/`, `.git/`, `dist/`, `build/` no pacote
-- Sempre gerar `manifest.json` antes de compactar
-- Salvar o `.dspack` em `design-systems/` da raiz do projeto atual
-- Se `design-systems/` não existir, criar antes de salvar

package/assets/skill/ds.md

@@ -1,248 +0,0 @@
-# ds
-
-Assistente central do Design System Manager. Apresenta um menu interativo e guia o usuário pela operação desejada.
-
-## Ativação
-
-Ativado via `/ds` no Claude Code.
-
-## Menu Principal
-
-Ao ser ativado, sempre apresente:
-
-```
-🎨 Design System Manager
-
-Projeto: {nome do package.json ou nome do diretório}
-DS ativo: {nome do DS ativo em design-systems/manifest.json, ou "nenhum"}
-
-O que deseja fazer?
-
-  1. 📦 Empacotar   — empacotar um DS existente em .dspack
-  2. 📥 Instalar    — instalar um .dspack neste projeto
-  3. 📋 Listar      — ver DSs instalados e disponíveis
-  4. 🎨 Aplicar     — aplicar o DS ativo no projeto
-  5. ❓ Ajuda       — ver dicas e comandos diretos
-
-  0. Sair
-
-Digite o número da opção:
-```
-
-## Opção 1 — Empacotar
-
-Execute o fluxo completo de `/ds-pack`:
-
-### Passo 1 — Caminho do DS
-```
-📦 Empacotar Design System
-
-Informe o caminho do design system:
-(ex: ./src/design-system, ./tokens, ./ui)
-```
-
-### Passo 2 — Confirmar inventário
-Escaneie o diretório e exiba o que foi encontrado:
-```
-Encontrado em {caminho}:
-
-  Tokens:      {N} arquivo(s) — {lista}
-  Atoms:       {N} componente(s)
-  Molecules:   {N} componente(s)
-  Organisms:   {N} componente(s)
-
-  Nome sugerido: {nome-inferido}
-  Versão:        1.0.0
-
-Confirmar e empacotar? (s/n)
-```
-
-### Passo 3 — Empacotar e salvar
-```bash
-zip -r "design-systems/{nome}.dspack" "{caminho-absoluto}/" \
-  -x "*/node_modules/*" -x "*/.git/*" -x "*/dist/*" -x "*/build/*"
-```
-
-### Resultado
-```
-✅ Empacotado!
-
-  design-systems/{nome}.dspack — {tamanho}
-
-  Próximo passo:
-    2 → Instalar em outro projeto
-    0 → Sair
-
-Digite:
-```
-
----
-
-## Opção 2 — Instalar
-
-Execute o fluxo completo de `/ds-install`:
-
-### Passo 1 — Selecionar arquivo
-Escaneie `design-systems/*.dspack` e liste:
-```
-📥 Instalar Design System
-
-Arquivos disponíveis:
-  1. eximia-default.dspack
-  2. meu-ds.dspack
-  3. Informar outro caminho...
-
-Selecione:
-```
-
-### Passo 2 — Validar
-```
-Validando {nome}.dspack...
-  ✅ Arquivo válido
-  ✅ manifest.json encontrado
-  Nome: {nome} | Versão: {versão}
-
-Instalar? (s/n)
-```
-
-### Passo 3 — Extrair e atualizar manifest
-```bash
-unzip -o "{caminho-absoluto}.dspack" -d "design-systems/{nome}/"
-```
-Atualizar `design-systems/manifest.json` fazendo merge no array `installed`.
-
-### Resultado
-```
-✅ Instalado!
-
-  {nome} v{versão} — ativo
-
-  Próximo passo:
-    4 → Aplicar no projeto
-    0 → Sair
-
-Digite:
-```
-
----
-
-## Opção 3 — Listar
-
-Execute o fluxo de `/ds-list` e exiba:
-
-```
-📋 Design Systems — {projeto}
-
-Instalados:
-  ✅ eximia-default  v1.0.0  (ativo)
-  ○  meu-ds          v2.1.0
-
-Disponíveis para instalar:
-  📦 outro-ds.dspack
-
-─────────────────────────
-  1 → Empacotar   2 → Instalar   4 → Aplicar   0 → Sair
-
-Digite:
-```
-
----
-
-## Opção 4 — Aplicar
-
-Execute o fluxo completo de `/ds-apply`:
-
-### Passo 1 — Verificar DS ativo
-Ler `design-systems/manifest.json → active`.
-Se nenhum ativo, mostrar opção 3 antes de continuar.
-
-### Passo 2 — Detectar stack (silencioso)
-Antes de perguntar qualquer coisa, leia `package.json` e a estrutura de diretórios.
-
-### Passo 3 — Wizard contextual
-```
-🎨 Aplicar DS — {nome} v{versão}
-
-Stack detectada: {framework} + {css-approach}
-Componentes:     {pasta-detectada}
-
-O que aplicar?
-  1. Apenas tokens  ({formato} → {arquivo-destino})
-  2. Apenas componentes ({N} atoms, {N} molecules, {N} organisms)
-  3. Tudo
-  4. Interativo (arquivo por arquivo)
-
-Selecione:
-```
-
-### Passo 4 — Preview antes de aplicar
-```
-Será aplicado:
-
-  Tokens:
-    → {arquivo-destino} {novo | mesclar com existente}
-
-  Componentes:
-    → {pasta}/atoms/     ({N} arquivos)
-    → {pasta}/molecules/ ({N} arquivos)
-
-Confirmar? (s/n)
-```
-
-### Passo 5 — Aplicar e confirmar
-Executar. Se conflito de arquivo:
-```
-⚠️  {arquivo} já existe.
-    Sobrescrever? (s = este | t = todos | n = pular)
-```
-
-### Resultado
-```
-✅ DS aplicado!
-
-  {N} token(s) → {destino}
-  {N} componente(s) → {pasta}
-
-  ⚠️  Revise os imports antes de commitar.
-
-  0 → Sair
-
-Digite:
-```
-
----
-
-## Opção 5 — Ajuda
-
-```
-❓ Design System Manager — Ajuda
-
-Comandos diretos (atalhos):
-  /ds-pack    → empacotar diretamente
-  /ds-install → instalar diretamente
-  /ds-list    → listar diretamente
-  /ds-apply   → aplicar diretamente
-
-Formato .dspack:
-  → Arquivo zip com manifest.json na raiz
-  → Estrutura Atomic Design (atoms/molecules/organisms/templates)
-  → Tokens em DTCG JSON, CSS vars ou Tailwind config
-
-Pasta design-systems/:
-  → Ignorada pelo git (cada dev instala localmente)
-  → manifest.json rastreia DSs instalados e DS ativo
-
-  0 → Voltar ao menu
-
-Digite:
-```
-
----
-
-## Regras Gerais
-
-- Sempre ler `design-systems/manifest.json` ao iniciar para exibir estado atual
-- Após cada operação, sempre oferecer próximo passo sugerido ou retorno ao menu
-- Nunca sobrescrever arquivos sem confirmação explícita
-- Detectar stack **antes** de exibir opções de aplicação
-- Se `design-systems/` não existir, orientar: `npm install @eximia-ventures/ds`