aiox-core 5.0.2 → 5.0.3

package/pro/squads/squad-creator-pro/tasks/find-0.8.md

@@ -0,0 +1,222 @@
+# Task: find-0.8
+
+> **Pareto ao Cubo** | Identificar 0,8% genialidade, 4% excelência, 20% impacto, 80% merda
+
+## Objetivo
+
+Aplicar Pareto ao Cubo para mapear atividades/conhecimentos nas 4 zonas e priorizar o que realmente importa.
+
+## Contexto
+
+Pareto ao Cubo é a aplicação tripla da regra 80/20:
+- **1ª aplicação**: 20% geram 80% dos resultados
+- **2ª aplicação**: 4% (20% de 20%) geram 64% dos resultados
+- **3ª aplicação**: 0,8% (20% de 4%) geram ~51% dos resultados
+
+---
+
+## As 4 Zonas
+
+### 🔥 Zona de Genialidade (0,8%) → ~51% dos resultados
+
+O que é um Resultado Lendário:
+- Gera impacto exponencial (10x ou mais)
+- IA não consegue ou não deveria te substituir
+- Deixa um legado duradouro
+- Inspira outros a se superarem
+- Quebra padrões estabelecidos
+- É digno de virar história
+
+**Validação:**
+- [ ] É sua maior paixão em ação?
+- [ ] Transforma o "impossível" em realidade?
+- [ ] Ninguém mais consegue fazer igual?
+- [ ] Gera resultados exponenciais?
+- [ ] Pode ser multiplicado pela IA (não substituído)?
+
+### 💎 Zona de Excelência (4%) → ~64% dos resultados
+
+**Validação:**
+- [ ] Requer sua expertise única?
+- [ ] Gera resultados consistentes?
+- [ ] Pouquíssimas pessoas fazem tão bem?
+- [ ] Tem potencial de escala?
+
+### 🚀 Zona de Impacto (20%) → ~80% dos resultados
+
+**Validação:**
+- [ ] É estrategicamente importante?
+- [ ] Requer conhecimento específico?
+- [ ] Gera resultados significativos?
+- [ ] Pode ser sistematizado?
+
+### 💩 Zona de Merda (80%) → ~20% dos resultados ou menos
+
+**Validação:**
+- [ ] É repetitivo ou burocrático?
+- [ ] Pode ser feito pela IA?
+- [ ] Qualquer pessoa faria com treino básico?
+- [ ] Consome energia sem gerar impacto real?
+
+---
+
+## Checklist Lendário (Fluxo de Decisão)
+
+Aplique as perguntas EM ORDEM:
+
+### 1. Teste de Impacto
+> "Essa atividade gera resultados lendários?"
+
+- **NÃO** → É 80% (Zona de Merda)
+- **SIM** → Continue para próxima pergunta
+
+### 2. Teste de Singularidade
+> "Só eu consigo fazer isso com excelência?"
+
+- **NÃO** → Continue para pergunta 3
+- **SIM** → Continue para pergunta 4
+
+### 3. Teste de Valor
+> "Isso gera resultados importantes mesmo não sendo único?"
+
+- **NÃO** → É 80% (Zona de Merda)
+- **SIM** → É 20% (Zona de Impacto)
+
+### 4. Teste de Genialidade
+> "Isso me coloca em estado de flow e gera resultados lendários?"
+
+- **NÃO** → É 4% (Zona de Excelência)
+- **SIM** → É 0,8% (Zona de Genialidade)
+
+---
+
+## Perguntas Matadoras para 80%
+
+### Perguntas de Eliminação
+- "Se eu simplesmente parasse de fazer isso hoje, o que aconteceria de verdade?"
+- "Alguém importante realmente sentiria falta disso?"
+- "Isso existe só por hábito ou tem um propósito real?"
+
+### Perguntas de Automação
+- "Uma IA poderia fazer isso em segundos?"
+- "Existe um padrão repetitivo que poderia virar um processo automático?"
+- "Quanto tempo eu economizaria automatizando isso?"
+
+### Perguntas de Delegação
+- "Para quem isso seria um 4% ao invés de um 80%?"
+- "Quem cresceria profissionalmente fazendo isso?"
+- "Por que eu ainda não deleguei isso?"
+
+### Perguntas de Simplificação
+- "Como fazer isso em metade do tempo?"
+- "Quais partes desse processo são realmente necessárias?"
+- "Existe uma versão mais simples que gera 80% do resultado?"
+
+---
+
+## Regras de Ouro
+
+### Regra dos 2 Minutos
+- Se leva menos de 2 minutos → faça agora
+- Se leva mais → precisa de um sistema
+
+### Regra do "Hell Yeah!"
+- Se não for um "HELL YEAH!" → é um não
+- Aplique especialmente para reuniões e novos compromissos
+
+### Regra do Bloco Sagrado
+- Concentre toda a "merda" em blocos específicos do dia
+- Proteja ferozmente seu tempo de genialidade (0,8%)
+
+---
+
+## Ações Práticas por Zona
+
+### Para 80% (Eliminar/Automatizar/Delegar)
+
+| Ação | Como |
+|------|------|
+| **Eliminar** | Delete, cancele, diga não |
+| **Automatizar** | Use IA, crie templates, configure gatilhos |
+| **Delegar** | Documente uma vez, treine uma vez, solte de vez |
+
+### Para 20% (Sistematizar)
+- Criar SOPs
+- Documentar processos
+- Treinar equipe
+
+### Para 4% (Alavancar)
+- Manter alta qualidade
+- Escalar com cuidado
+- Não diluir expertise
+
+### Para 0,8% (Proteger)
+- Bloquear tempo sagrado
+- Eliminar distrações
+- Multiplicar via IA (não substituir)
+
+---
+
+## Template de Output
+
+```yaml
+# Pareto ao Cubo: {contexto}
+
+## 🔥 Zona de Genialidade (0,8%)
+- {atividade_1} → {justificativa}
+- {atividade_2} → {justificativa}
+
+## 💎 Zona de Excelência (4%)
+- {atividade_3} → {justificativa}
+- {atividade_4} → {justificativa}
+
+## 🚀 Zona de Impacto (20%)
+- {atividade_5} → {justificativa}
+- {atividade_6} → {justificativa}
+
+## 💩 Zona de Merda (80%)
+- {atividade_7} → {justificativa}
+- {atividade_8} → {justificativa}
+
+## ✅ Recomendações
+
+### Eliminar
+- {item}
+
+### Automatizar
+- {item}
+
+### Delegar
+- {item}
+
+### Proteger (0,8%)
+- {item}
+```
+
+---
+
+## Completion Criteria
+
+| Critério | Status |
+|----------|--------|
+| Todas atividades passaram pelo Checklist Lendário | [ ] |
+| Cada atividade classificada em uma zona | [ ] |
+| Justificativa para cada classificação | [ ] |
+| Recomendações de ação para cada zona | [ ] |
+| 0,8% claramente identificado e protegido | [ ] |
+
+---
+
+## Nota Importante
+
+> O que é "Zona de Merda" (80%) para uma pessoa pode ser "Zona de Genialidade" (0,8%) para outra.
+
+A classificação depende de:
+- Suas habilidades únicas
+- Sua paixão
+- Seu potencial de impacto
+- Sua capacidade de execução
+
+---
+
+*"0,8% produz 51% dos resultados. Proteja a genialidade, elimine a merda."*

package/pro/squads/squad-creator-pro/tasks/install-commands.md

@@ -0,0 +1,373 @@
+# /install-commands Task
+
+**Task ID:** install-commands
+**Version:** 1.1.0
+**Execution Type:** `Worker` (100% deterministic file operations)
+**Worker Script:** `scripts/sync-ide-command.py` (use: `python3 scripts/sync-ide-command.py squad {name}`)
+
+When this command is used, execute the following task:
+
+# Install Squad Commands
+
+## Purpose
+
+To convert squad agents into Claude Code commands and install them in the `.claude/commands/` directory, making the squad agents accessible via the `@{squad}:{agent}` syntax in all supported IDEs.
+
+## Inputs
+
+- Squad name (from user or discovery)
+- Squad path: `squads/{pack_name}/`
+- Existing squad structure:
+  - `config.yaml` - Pack metadata
+  - `agents/` - Agent definitions (markdown)
+  - `tasks/` - Task workflows (markdown)
+  - `templates/` - Output templates
+
+## Key Activities & Instructions
+
+### 1. Validate Squad Exists
+
+**Ask user for pack name if not provided:**
+```
+Which squad would you like to install?
+Available packs: [list directories in squads/]
+```
+
+**Check pack structure:**
+- Verify `squads/{pack_name}/config.yaml` exists
+- Verify `squads/{pack_name}/agents/` directory exists
+- Load `config.yaml` to get:
+  - `name` - Pack identifier
+  - `slashPrefix` - Command prefix (e.g., "legalAssistant")
+  - `version` - Pack version
+
+**Validation output:**
+```
+✅ Found squad: {name} v{version}
+   Slash prefix: @{slashPrefix}:
+   Agents found: {count}
+```
+
+**If validation fails:**
+- Report missing components
+- Ask user if they want to create the squad first using `*create-squad`
+- STOP execution
+
+### 2. Create Command Directory Structure
+
+**Create directories:**
+```
+.claude/commands/{slashPrefix}/
+├── agents/          # Converted agent commands
+└── tasks/           # Symlink or copy of tasks/
+```
+
+**Execution:**
+- Use mkdir to create `.claude/commands/{slashPrefix}/`
+- Use mkdir to create `.claude/commands/{slashPrefix}/agents/`
+- Use mkdir to create `.claude/commands/{slashPrefix}/tasks/`
+
+**Confirmation:**
+```
+✅ Created command structure: .claude/commands/{slashPrefix}/
+```
+
+### 3. Convert Each Agent to Claude Code Format
+
+**For each file in `squads/{pack_name}/agents/*.md`:**
+
+**Step 3.1: Read source agent file**
+- Parse agent metadata (lines 1-6):
+  - Extract: name (# header)
+  - Extract: role (from **Role**:)
+  - Extract: squad reference
+- Parse sections:
+  - ## Persona (extract all subsections)
+  - ## Commands (extract command list)
+  - ## Tasks (extract task references)
+  - ## Templates (extract template references)
+  - ## Activation (extract activation command)
+
+**Step 3.2: Generate Claude Code command file**
+
+**Template structure:**
+```markdown
+# /{slashPrefix}:{agent-id} Command
+
+When this command is used, adopt the following agent persona:
+
+# {agent-id}
+
+ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
+
+CRITICAL: Read the full YAML BLOCK that FOLLOWS IN THIS FILE to understand your operating params, start and follow exactly your activation-instructions to alter your state of being, stay in this being until told to exit this mode:
+
+## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED
+
+```yaml
+IDE-FILE-RESOLUTION:
+  - FOR LATER USE ONLY - NOT FOR ACTIVATION, when executing commands that reference dependencies
+  - Dependencies map to squads/{pack_name}/{type}/{name}
+  - type=folder (tasks|templates|checklists|data|utils|etc...), name=file-name
+  - Example: {task}.md → squads/{pack_name}/tasks/{task}.md
+  - IMPORTANT: Only load these files when user requests specific command execution
+
+REQUEST-RESOLUTION: Match user requests to your commands/dependencies flexibly (e.g., "install legal"→*install-commands→install-commands task), ALWAYS ask for clarification if no clear match.
+
+activation-instructions:
+  - STEP 1: Read THIS ENTIRE FILE - it contains your complete persona definition
+  - STEP 2: Adopt the persona defined in the 'agent' and 'persona' sections below
+  - STEP 3: Greet user with: "👋 I am {Agent Name}. {Role description}. Type `*help` to see what I can do."
+  - DO NOT: Load any other agent files during activation
+  - ONLY load dependency files when user selects them for execution via command
+  - The agent.customization field ALWAYS takes precedence over any conflicting instructions
+  - CRITICAL WORKFLOW RULE: When executing tasks from dependencies, follow task instructions exactly as written - they are executable workflows
+  - MANDATORY INTERACTION RULE: Tasks with elicit=true require user interaction using exact specified format
+  - When listing tasks/templates or presenting options during conversations, always show as numbered options list
+  - STAY IN CHARACTER!
+  - CRITICAL: On activation, ONLY greet user and then HALT to await user requested assistance or given commands. ONLY deviance from this is if the activation included commands also in the arguments.
+
+agent:
+  name: {Agent Name}
+  id: {agent-id}
+  title: {Agent Title/Role}
+  icon: {emoji} # Choose appropriate emoji based on role
+  squad: {pack_name}
+  whenToUse: {When to use this agent - extract from persona/focus}
+  customization: null
+
+persona:
+  role: {Extract from ## Persona > ### Role}
+  style: {Extract from ## Persona > ### Style - comma separated}
+  identity: {Extract from ## Persona - summarize}
+  focus: {Extract from ## Persona > ### Focus}
+
+core_principles:
+  {Extract from ## Persona > ### Expertise - convert to principles}
+  - {principle 1}
+  - {principle 2}
+  - {principle 3}
+
+commands:
+  {Extract from ## Commands - convert to numbered list}
+  - '*help' - Show numbered list of available commands
+  - '{command}' - {description} (→ tasks/{task-file}.md)
+  - '*exit' - Say goodbye and deactivate persona
+
+dependencies:
+  tasks:
+    {Extract from ## Tasks section}
+    - {task-file}.md: {purpose/description}
+  templates:
+    {Extract from ## Templates section}
+    - {template-file}.yaml: {purpose}
+  checklists: []
+  knowledge: []
+
+integration_points:
+  inputs:
+    {Extract from ## Integration Points > ### Inputs}
+    - {input description}
+  outputs:
+    {Extract from ## Integration Points > ### Outputs}
+    - {output description}
+  handoff_to:
+    {Extract from ## Integration Points > ### Handoff To}
+    - {next agent or process}
+```
+```
+
+**Key conversion rules:**
+1. **Agent ID**: Convert filename to kebab-case (e.g., `process-mapper.md` → `process-mapper`)
+2. **Emoji selection**: Based on role:
+   - Discovery/Mapping → 🗺️
+   - Architecture/Design → 🏗️
+   - Execution/Implementation → ⚙️
+   - Quality/Validation → ✅
+   - Documentation → 📝
+3. **Commands**: Extract all `*command-name` from ## Commands section
+4. **Task references**: Convert relative paths to absolute:
+   - `tasks/{task-name}.md` → `squads/{pack_name}/tasks/{task-name}.md`
+5. **Preserve**: All persona details, expertise, style, focus
+
+**Step 3.3: Write converted command**
+- Target path: `.claude/commands/{slashPrefix}/agents/{agent-id}.md`
+- Use Write tool to create file
+- Confirm creation: `✅ Converted: {agent-id}`
+
+### 4. Copy Task References
+
+**For each task in `squads/{pack_name}/tasks/*.md`:**
+
+**Option A: Symlink (Unix/Linux/Mac)**
+```bash
+ln -s "$(pwd)/squads/{pack_name}/tasks/{task}.md" ".claude/commands/{slashPrefix}/tasks/{task}.md"
+```
+
+**Option B: Copy (Windows/Universal)**
+```bash
+cp "squads/{pack_name}/tasks/{task}.md" ".claude/commands/{slashPrefix}/tasks/{task}.md"
+```
+
+**Execution:**
+- Detect OS (use `process.platform` or `uname`)
+- Use symlink on Unix-like systems
+- Use copy on Windows
+- Track copied/linked files
+
+**Confirmation:**
+```
+✅ Installed {count} task workflows
+```
+
+### 5. Generate Installation Summary
+
+**Create `.claude/commands/{slashPrefix}/README.md`:**
+```markdown
+# {Pack Name} - Installed Commands
+
+**Version**: {version}
+**Installed**: {timestamp}
+
+## Available Agents
+
+{For each agent:}
+- `@{slashPrefix}:{agent-id}` - {agent title/role}
+
+## Usage
+
+### Activate an agent:
+\```
+@{slashPrefix}:{agent-id}
+\```
+
+### Example workflows:
+{Extract example from pack README or provide generic}
+
+## Documentation
+
+- **Pack README**: `squads/{pack_name}/README.md`
+- **User Guide**: `squads/{pack_name}/GUIA-DO-USUARIO.md` (if exists)
+- **Agent Details**: `squads/{pack_name}/agents/`
+- **Task Workflows**: `squads/{pack_name}/tasks/`
+
+## Uninstall
+
+To remove this squad:
+\```bash
+rm -rf .claude/commands/{slashPrefix}
+\```
+```
+
+**Confirmation:**
+```
+📋 Installation summary: .claude/commands/{slashPrefix}/README.md
+```
+
+### 6. Final Validation
+
+**Run validation checks:**
+1. Verify all agents converted: `ls .claude/commands/{slashPrefix}/agents/*.md`
+2. Count files:
+   - Source agents: `ls squads/{pack_name}/agents/*.md | wc -l`
+   - Installed commands: `ls .claude/commands/{slashPrefix}/agents/*.md | wc -l`
+3. Validate YAML syntax in each converted file (basic check for ```yaml blocks)
+
+**If counts don't match:**
+- Report which agents failed to convert
+- Provide error details
+- Suggest manual review
+
+**Success output:**
+```
+✅ INSTALLATION COMPLETE
+
+Squad: {pack_name} v{version}
+Agents installed: {count}
+Commands available:
+
+{For each agent:}
+  @{slashPrefix}:{agent-id} - {description}
+
+🚀 You can now activate any agent using @{slashPrefix}:{agent-id}
+
+Try it:
+  @{slashPrefix}:{first-agent-id}
+  *help
+```
+
+## Outputs
+
+**Files created:**
+- `.claude/commands/{slashPrefix}/agents/*.md` - Converted agent commands (1 per agent)
+- `.claude/commands/{slashPrefix}/tasks/*.md` - Task workflows (copied/symlinked)
+- `.claude/commands/{slashPrefix}/README.md` - Installation summary
+
+**Terminal output:**
+- Installation progress log
+- Success confirmation with usage examples
+- List of all available commands
+
+**Error conditions:**
+- Squad not found → Suggest `*create-squad`
+- Invalid config.yaml → Report YAML errors
+- Agent conversion failure → Report which agent and why
+- Disk space issues → Report and suggest cleanup
+
+## Next Steps
+
+**Suggest to user:**
+1. **Test the installation:**
+   ```
+   Try activating: @{slashPrefix}:{first-agent}
+   ```
+
+2. **Read the documentation:**
+   ```
+   Check: squads/{pack_name}/README.md
+   ```
+
+3. **Start using:**
+   ```
+   {Provide example workflow from pack}
+   ```
+
+4. **Share with team:**
+   - Commit `.claude/commands/{slashPrefix}/` to git if team-shared
+   - Or keep in `.gitignore` if personal installation
+
+## Error Handling
+
+**Common errors and solutions:**
+
+### Error: "Squad not found"
+```
+Solution: Check pack name
+Command: ls squads/
+```
+
+### Error: "config.yaml missing"
+```
+Solution: Pack incomplete, create config.yaml
+Command: *create-squad
+```
+
+### Error: "Agent conversion failed"
+```
+Cause: Malformed agent markdown
+Solution: Review agent file structure, fix sections
+Reference: squad-chief/templates/agent-tmpl.md
+```
+
+### Error: "Permission denied"
+```
+Cause: Write permissions on .claude/commands/
+Solution: Check directory permissions
+Command: chmod +w .claude/commands/
+```
+
+---
+
+**Task Version**: 1.0.0
+**Last Updated**: 2025-10-06
+**Squad**: squad-chief

package/pro/squads/squad-creator-pro/tasks/lookup-model.md

@@ -0,0 +1,78 @@
+# Task: lookup-model
+
+**Command:** `*lookup-model <task-name>`
+**Execution Type:** Worker (deterministic, no LLM needed)
+
+## Purpose
+
+Look up the recommended model tier for a Squad Creator task before execution.
+Returns: `haiku`, `sonnet`, or `opus`.
+
+## Usage
+
+```bash
+# In Squad Chief or any workflow
+model=$(lookup-model "create-agent.md")
+# Returns: opus
+
+model=$(lookup-model "validate-squad.md")
+# Returns: haiku
+```
+
+## Workflow
+
+### Step 1: Load Config
+
+Read `config/model-routing.yaml`
+
+### Step 2: Lookup Task
+
+```yaml
+task_name: "{input}"
+config: model-routing.yaml
+
+lookup:
+  path: tasks.{task_name}.tier
+  default: opus  # Conservative default
+```
+
+### Step 3: Return Result
+
+```yaml
+output:
+  task: "{task_name}"
+  tier: "{haiku|sonnet|opus}"
+  confidence: "{high|medium|low}"
+  reason: "{why this tier}"
+```
+
+## Quick Reference
+
+| Tier | Tasks Count | Use For |
+|------|-------------|---------|
+| **haiku** | 13 | Validation, scoring, admin |
+| **sonnet** | 17 | Documentation, templates, moderate analysis |
+| **opus** | 12 | DNA extraction, agent creation, research |
+
+## Integration with Task Tool
+
+When spawning agents, use the tier as model parameter:
+
+```python
+# Pseudo-code for Squad Chief
+task = "validate-squad.md"
+tier = lookup_model(task)  # Returns "haiku"
+
+Task(
+  subagent_type="general-purpose",
+  model=tier,  # "haiku"
+  prompt="Execute validation..."
+)
+```
+
+## Completion Criteria
+
+- [ ] Task name provided
+- [ ] Config loaded
+- [ ] Tier returned
+- [ ] If task not found, return "opus" (safe default)