@eximia-ventures/claude-code-toolkit 5.1.1 → 5.2.0

package/README.md

@@ -9,7 +9,7 @@
 
 <p align="center">
   <strong>Setup completo para Claude Code em um comando.</strong><br/>
-  Statusline customizada, session continuity, usage monitor, AIOS integration e Squad Forge.
+  Statusline customizada, session continuity, usage monitor, AIOS integration e Squad Arsenal.
 </p>
 
 <p align="center">
@@ -28,7 +28,7 @@ O `claude-code-toolkit` transforma sua experiência com o Claude Code instalando
 | **Session Handoff** | Continuidade de sessão entre `/clear` (7 slash commands, 2 hooks) |
 | **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** | Arsenal de squads especializados — transforma agents em plataformas visuais interativas |
+| **Squad Arsenal** | Squads especializados — Forge (plataformas visuais), Design (Brad Frost, Atomic Design) |
 
 ---
 
@@ -465,6 +465,114 @@ forge/{target}/
 └── deployment.md            # Phase 8 — guia de deploy
 ```
 
+---
+
+### Squad Design 🎨
+
+> **Brad Frost** — Design System Architect & Pattern Consolidator
+
+Squad 100% independente (sem banco de dados, sem APIs externas) para criar, auditar e migrar design systems usando a metodologia Atomic Design.
+
+#### Agent
+
+| Agent | Persona | Papel |
+|-------|---------|-------|
+| `@design-system` 🎨 | Brad Frost (Atomic Design) | **Único executor** — audit, tokens, componentes, acessibilidade, migração |
+
+**Filosofia Brad Frost:** *"Show the horror, then fix it"* — relatórios com números que fazem stakeholders dizer "oh god, what have we done" (47 botões → 3 = 93.6% de redução).
+
+#### 3 Workflows
+
+| Workflow | Descrição | Quando usar |
+|----------|-----------|-------------|
+| `brownfield-complete` | Audita codebase existente, consolida padrões, extrai tokens, gera plano de migração | Projeto legado sem DS |
+| `greenfield-new` | Cria DS do zero com tokens, Shadcn/Tailwind, componentes atômicos | Projeto novo |
+| `audit-only` | Gera relatórios de auditoria para stakeholders sem tocar no código | Apresentação executiva |
+
+#### 33 Tasks especializadas
+
+Organizadas em categorias:
+
+| Categoria | Tasks |
+|-----------|-------|
+| **Brownfield** | ds-audit-codebase, ds-consolidate-patterns, ds-extract-tokens, ds-generate-shock-report, ds-calculate-roi |
+| **Greenfield** | ds-setup-design-system, ds-build-component, ds-compose-molecule, bootstrap-shadcn-library |
+| **Acessibilidade** | a11y-audit, aria-audit, contrast-matrix, focus-order-audit, audit-reading-experience |
+| **Refactoring** | atomic-refactor-plan, atomic-refactor-execute, dead-code-detection, tailwind-upgrade |
+| **Documentação** | ds-generate-documentation, create-doc, validate-design-fidelity |
+| **Análise** | token-usage-analytics, bundle-audit, ds-health-metrics, design-compare |
+
+#### Slash commands
+
+| Comando | Descrição |
+|---------|-----------|
+| `/design-brownfield` | Pipeline brownfield completo (audit → consolidar → tokens → migração) |
+| `/design-greenfield` | Criar design system do zero (tokens → Shadcn → componentes) |
+| `/design-audit` | Relatório de auditoria para stakeholders (sem modificar código) |
+| `/design-a11y` | Audit de acessibilidade (WCAG 2.1, Aria, contraste, foco) |
+
+#### Integração com Forge
+
+O `@design-system` é o executor da **Phase 3** do Squad Forge. Quando `/forge {squad}` roda, Brad Frost gera tokens, define o inventário de componentes e configura o tema Shadcn/Tailwind em `forge/{target}/design/`.
+
+Se o `@eximia-ventures/ds` estiver instalado e houver `design-systems/manifest.json`, a Phase 3 **reutiliza os tokens do DS instalado** em vez de gerar do zero.
+
+---
+
+### Design System Manager (`@eximia-ventures/ds`) 📦
+
+Pacote npm complementar que gerencia design systems como artefatos instaláveis (formato `.dspack`).
+
+```bash
+npm install @eximia-ventures/ds
+```
+
+**Formato `.dspack`** — zip padronizado compatível com W3C DTCG:
+
+```
+meu-ds.dspack
+├── manifest.json         # nome, versão, inventário, formato DTCG
+├── tokens/
+│   ├── tokens.json       # W3C DTCG format
+│   ├── tokens.css        # CSS custom properties
+│   └── tokens.tw.js      # Tailwind config
+└── components/
+    ├── atoms/
+    ├── molecules/
+    ├── organisms/
+    └── 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` |
+
+**Fluxo com Forge:**
+
+```mermaid
+flowchart LR
+    PACK["meu-ds.dspack"] --> INSTALL["/ds-install"]
+    INSTALL --> MANIFEST["design-systems/\nmanifest.json"]
+    MANIFEST --> FORGE["@bret-victor *forge {squad}\nPhase 0: detecta DS instalado"]
+    FORGE --> P3["Phase 3: Brad Frost\nreutiliza tokens do DS"]
+    P3 --> OUT["forge/{target}/design/\ntokens + components + tema"]
+
+    style PACK fill:#f59e0b,color:#000,stroke:none
+    style INSTALL fill:#5B4FE5,color:#fff,stroke:none
+    style MANIFEST fill:#1e293b,color:#fff,stroke:none
+    style FORGE fill:#F56000,color:#fff,stroke:none
+    style P3 fill:#8b5cf6,color:#fff,stroke:none
+    style OUT fill:#22c55e,color:#fff,stroke:none
+```
+
+---
+
 #### Integrar novos squads via inbox
 
 Squads externos podem ser integrados via `/aios-integrate` ou pelo sistema de inbox:
@@ -537,31 +645,41 @@ 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
+│       ├── 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
 └── squads/
-    └── forge/                        # Squad Forge (Platform Materializer)
+    ├── forge/                        # Squad Forge (Platform Materializer)
+    │   ├── squad.yaml                # Manifest AIOS
+    │   ├── agents/
+    │   │   ├── bret-victor.md        # Forge Orchestrator
+    │   │   ├── kinneret.md           # Platform Voice Architect
+    │   │   └── wes-bush.md           # Platform Growth Architect
+    │   ├── tasks/
+    │   │   ├── diagnose-squad.md     # Detecta padrão de UI
+    │   │   └── map-capabilities.md   # Capability → Feature mapping
+    │   ├── workflows/
+    │   │   └── wf-forge.yaml         # Pipeline completo (9 fases)
+    │   ├── checklists/
+    │   ├── templates/
+    │   └── data/
+    │       ├── pattern-signatures.yaml
+    │       └── stack-recommendations.yaml
+    └── design/                       # Squad Design (Brad Frost)
         ├── squad.yaml                # Manifest AIOS
         ├── agents/
-        │   ├── bret-victor.md        # Forge Orchestrator
-        │   ├── kinneret.md           # Platform Voice Architect
-        │   └── wes-bush.md           # Platform Growth Architect
-        ├── tasks/
-        │   ├── diagnose-squad.md     # Detecta padrão de UI
-        │   └── map-capabilities.md   # Capability → Feature mapping
+        │   └── design-system.md      # Brad Frost — único agente
+        ├── tasks/                    # 33 tasks (audit, tokens, a11y, refactor...)
         ├── workflows/
-        │   └── wf-forge.yaml         # Pipeline completo (9 fases)
-        ├── checklists/
-        │   ├── forge-readiness-checklist.md
-        │   └── productization-checklist.md
-        ├── templates/
-        │   ├── platform-chat-tmpl.yaml
-        │   ├── platform-canvas-tmpl.yaml
-        │   ├── platform-wizard-tmpl.yaml
-        │   ├── platform-dashboard-tmpl.yaml
-        │   └── wizard-config-tmpl.yaml
-        └── data/
-            ├── pattern-signatures.yaml   # Sinais de detecção de padrão
-            └── stack-recommendations.yaml
+        │   ├── brownfield-complete.yaml
+        │   ├── greenfield-new.yaml
+        │   └── audit-only.yaml
+        ├── checklists/               # 7 checklists
+        ├── templates/                # 10 templates
+        └── data/                     # 9 knowledge base files
 ```
 
 ---

package/assets/skill/ds-apply.md

@@ -0,0 +1,118 @@
+# 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

@@ -0,0 +1,94 @@
+# 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

@@ -0,0 +1,62 @@
+# 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

@@ -0,0 +1,92 @@
+# 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

@@ -0,0 +1,248 @@
+# 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`

package/package.json

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

package/src/modules/aios.js

@@ -14,6 +14,12 @@ 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 } = {}) {