aiox-core 5.0.2 → 5.0.3

package/pro/squads/squad-creator-pro/tasks/an-compare-outputs.md

@@ -0,0 +1,354 @@
+# Task: Compare Model Outputs
+
+**Command:** `*compare-outputs`
+**Version:** 1.0.0
+**Execution Type:** Agent (Opus ONLY - evaluator must be most capable model)
+**Model:** `Opus` (REQUIRED - evaluator cannot be same tier as test subject)
+**Purpose:** Systematic comparison of Opus baseline vs Haiku test outputs for Model Tier Qualification
+
+---
+
+## CRITICAL: Evaluator Independence
+
+```yaml
+evaluator_rules:
+  model: "opus"  # NEVER use Haiku to evaluate Haiku
+  blind_mode: false  # We know which is which (baseline vs test)
+  bias_mitigation:
+    - "Score WHAT IS WRITTEN, not what you expect"
+    - "Do NOT assume Opus is better - measure objectively"
+    - "If outputs are equivalent, say so (don't force differences)"
+```
+
+---
+
+## Inputs
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `task_name` | string | Yes | Task being evaluated (e.g., "an-assess-sources") |
+| `opus_baseline` | file | Yes | Path to Opus output file |
+| `haiku_output` | file | Yes | Path to Haiku output file |
+| `task_file` | file | Yes | Original task definition (for reference) |
+
+---
+
+## Evaluation Rubric (100 points)
+
+### Dimension 1: TIER MATCH (40 points)
+
+```yaml
+tier_match:
+  weight: 40
+  description: "Do both outputs classify items into the same tiers?"
+
+  scoring:
+    perfect_match: 40    # 100% of items have same tier
+    high_match: 32       # 90-99% same tier
+    moderate_match: 24   # 75-89% same tier
+    low_match: 16        # 50-74% same tier
+    poor_match: 0        # <50% same tier
+
+  calculation: |
+    match_rate = count(opus_tier == haiku_tier) / total_items
+
+    IF match_rate == 1.0 → 40 points
+    IF match_rate >= 0.9 → 32 points
+    IF match_rate >= 0.75 → 24 points
+    IF match_rate >= 0.5 → 16 points
+    ELSE → 0 points
+
+  veto_condition: |
+    IF match_rate < 0.75 → VETO (different tier = different user action)
+    Rationale: User decides based on tier, not score details
+```
+
+### Dimension 2: SCORE VARIANCE (30 points)
+
+```yaml
+score_variance:
+  weight: 30
+  description: "Are numerical scores within acceptable variance?"
+
+  thresholds:
+    excellent: 5%     # Scores within 5%
+    good: 10%         # Scores within 10%
+    acceptable: 15%   # Scores within 15%
+    poor: 20%         # Scores within 20%
+    unacceptable: ">20%"
+
+  scoring:
+    within_5pct: 30
+    within_10pct: 24
+    within_15pct: 18
+    within_20pct: 12
+    beyond_20pct: 0
+
+  calculation: |
+    FOR each scored item:
+      variance = abs(opus_score - haiku_score) / opus_score * 100
+
+    avg_variance = mean(all variances)
+    max_variance = max(all variances)
+
+    # Use WORST case (max) for scoring, not average
+    IF max_variance <= 5% → 30 points
+    IF max_variance <= 10% → 24 points
+    IF max_variance <= 15% → 18 points
+    IF max_variance <= 20% → 12 points
+    ELSE → 0 points
+
+  veto_condition: |
+    IF max_variance > 15% → REVIEW (significant scoring difference)
+    IF max_variance > 25% → VETO (unreliable scoring)
+```
+
+### Dimension 3: CHECKPOINT MATCH (20 points)
+
+```yaml
+checkpoint_match:
+  weight: 20
+  description: "Do binary checkpoints (true/false) match?"
+
+  applies_to: "Tasks with binary checkpoint scoring"
+
+  scoring:
+    perfect_match: 20    # 100% checkpoints match
+    high_match: 16       # 95-99% match
+    moderate_match: 12   # 90-94% match
+    low_match: 8         # 80-89% match
+    poor_match: 0        # <80% match
+
+  calculation: |
+    FOR each item with checkpoints:
+      FOR each checkpoint:
+        match = (opus_checkpoint == haiku_checkpoint)
+
+    match_rate = count(matches) / total_checkpoints
+
+    IF match_rate == 1.0 → 20 points
+    IF match_rate >= 0.95 → 16 points
+    IF match_rate >= 0.90 → 12 points
+    IF match_rate >= 0.80 → 8 points
+    ELSE → 0 points
+
+  note: |
+    If task doesn't use binary checkpoints, award 20 points
+    (dimension not applicable)
+```
+
+### Dimension 4: RECOMMENDATION QUALITY (10 points)
+
+```yaml
+recommendation_quality:
+  weight: 10
+  description: "Do recommendations lead to same user actions?"
+
+  scoring:
+    same_actions: 10       # Same recommended actions
+    similar_actions: 7     # Same direction, different specifics
+    different_actions: 3   # Different recommendations
+    contradictory: 0       # Opposite recommendations
+
+  evaluation_criteria:
+    - "Would user take same action based on each output?"
+    - "Are priorities the same (what to do first)?"
+    - "Are gaps/issues identified the same?"
+
+  note: |
+    This is the most subjective dimension.
+    Focus on ACTIONABLE outcomes, not wording.
+```
+
+---
+
+## Qualification Thresholds
+
+```yaml
+qualification_decision:
+  thresholds:
+    QUALIFIED: ">= 85 points AND no veto triggered"
+    CONDITIONAL: "70-84 points OR veto with mitigation possible"
+    NOT_QUALIFIED: "< 70 points OR hard veto"
+
+  veto_conditions:
+    - id: "MTQ_VC_001"
+      name: "Score Variance >15%"
+      severity: "review"
+
+    - id: "MTQ_VC_002"
+      name: "Score Variance >25%"
+      severity: "veto"
+
+    - id: "MTQ_VC_003"
+      name: "Tier Match <90%"
+      severity: "review"
+
+    - id: "MTQ_VC_004"
+      name: "Tier Match <75%"
+      severity: "veto"
+
+    - id: "MTQ_VC_005"
+      name: "Contradictory Recommendations"
+      severity: "veto"
+```
+
+---
+
+## Workflow
+
+### Step 1: Load Inputs
+
+```yaml
+step_1:
+  action: "Read both output files and task definition"
+  inputs:
+    - opus_baseline
+    - haiku_output
+    - task_file
+  validation:
+    - "Both files exist and are valid YAML"
+    - "Both files have same structure"
+    - "Task file provides context for evaluation"
+```
+
+### Step 2: Extract Comparable Items
+
+```yaml
+step_2:
+  action: "Identify all items to compare"
+  extract:
+    - items: "List of scored items (sources, dimensions, etc.)"
+    - scores: "Numerical scores per item"
+    - tiers: "Classification tiers per item"
+    - checkpoints: "Binary checkpoints if applicable"
+    - recommendations: "Action items and priorities"
+```
+
+### Step 3: Calculate Dimension Scores
+
+```yaml
+step_3:
+  action: "Score each dimension using rubric"
+
+  tier_match:
+    calculate: "match_rate = matching_tiers / total_items"
+    score: "Apply scoring table"
+    check_veto: "match_rate < 0.75?"
+
+  score_variance:
+    calculate: "variance per item, take max"
+    score: "Apply scoring table"
+    check_veto: "max_variance > 25%?"
+
+  checkpoint_match:
+    calculate: "matching_checkpoints / total_checkpoints"
+    score: "Apply scoring table"
+
+  recommendation_quality:
+    evaluate: "Would user take same action?"
+    score: "Apply scoring table"
+    check_veto: "Contradictory?"
+```
+
+### Step 4: Generate Report
+
+```yaml
+step_4:
+  action: "Generate qualification report"
+
+  output_format: |
+    qualification_report:
+      task: "{task_name}"
+      evaluation_date: "{ISO date}"
+      evaluator: "opus"
+
+      inputs:
+        opus_baseline: "{path}"
+        haiku_output: "{path}"
+
+      dimension_scores:
+        tier_match:
+          score: X/40
+          match_rate: X%
+          details: [...]
+
+        score_variance:
+          score: X/30
+          avg_variance: X%
+          max_variance: X%
+          details: [...]
+
+        checkpoint_match:
+          score: X/20
+          match_rate: X%
+          details: [...]
+
+        recommendation_quality:
+          score: X/10
+          assessment: "same|similar|different|contradictory"
+          details: [...]
+
+      total_score: X/100
+
+      veto_conditions:
+        triggered: [...]
+        not_triggered: [...]
+
+      decision: "QUALIFIED | CONDITIONAL | NOT_QUALIFIED"
+
+      rationale: |
+        {Explanation of decision}
+
+      recommendations:
+        if_qualified: |
+          - Update model-routing.yaml: tier = haiku
+          - Add validated: true with test_date
+        if_conditional: |
+          - {Specific fixes needed}
+          - Re-test after fixes
+        if_not_qualified: |
+          - Keep tier = opus
+          - Document root cause
+```
+
+---
+
+## Output
+
+Save qualification report to:
+```
+squads/squad-creator-pro/test-cases/{task_name}/qualification-report.yaml
+```
+
+---
+
+## Usage Example
+
+```bash
+*compare-outputs \
+  --task an-assess-sources \
+  --opus squads/squad-creator-pro/test-cases/an-assess-sources/opus-baseline.yaml \
+  --haiku squads/squad-creator-pro/test-cases/an-assess-sources/haiku-v2.2.1-output.yaml \
+  --task-file squads/squad-creator-pro/tasks/an-assess-sources.md
+```
+
+---
+
+## Completion Criteria
+
+- [ ] Both output files loaded and parsed
+- [ ] All 4 dimensions scored using rubric
+- [ ] Veto conditions checked
+- [ ] Total score calculated
+- [ ] Decision determined (QUALIFIED/CONDITIONAL/NOT_QUALIFIED)
+- [ ] Qualification report generated with full details
+- [ ] Report saved to test-cases/{task}/qualification-report.yaml
+
+---
+
+## Changelog
+
+| Version | Date | Changes |
+|---------|------|---------|
+| 1.0.0 | 2026-02-11 | Initial version with 4-dimension rubric |

package/pro/squads/squad-creator-pro/tasks/an-design-clone.md

@@ -0,0 +1,79 @@
+# Task: Design Clone Architecture
+
+**Command:** `*design-clone`
+**Load:** — (uses core knowledge)
+
+## Purpose
+
+Arquitetar um clone completo: contextos de uso, estagios, memoria, trindade por estagio.
+
+## Workflow
+
+### Step 1: Define Contexts
+
+Perguntar ao usuario:
+- "Em que situacoes esse clone vai ser usado?"
+- "Ele precisa se comportar diferente dependendo do contexto?"
+
+Mapear contextos:
+- Vendas, suporte, educacao, consultoria, etc.
+- Tipos de interlocutor (iniciante, avancado, hater, fa)
+
+### Step 2: Decide Stages
+
+**Regra AN004**: SE comportamento muda por contexto → criar estagios.
+
+Avaliar necessidade:
+- Single-mode: Comportamento uniforme → prompt unico
+- Multi-stage: Comportamento varia → estagios separados
+
+Exemplos de estagios:
+- Funil: boas-vindas → qualificacao → oferta
+- Atendimento: triagem → suporte → escalacao
+- Educacional: avaliacao → ensino → pratica
+- Anti-hater: normal → modo pistola (ex: Hormozi)
+
+### Step 3: Map Trinity per Stage
+
+Para cada estagio, definir:
+
+| Estagio | Playbook | Framework | Swipe File |
+|---------|----------|-----------|------------|
+| {nome} | Passo a passo | Regras SE/ENTAO | Exemplos reais |
+
+### Step 4: Define Memory & Context
+
+- Que informacoes o clone precisa lembrar entre interacoes?
+- Que contexto precisa receber a cada conversa?
+- Limites de memoria (curta vs longa)
+
+### Step 5: Generate Blueprint
+
+```yaml
+clone_blueprint:
+  mind: "{nome}"
+  mode: "single|multi-stage"
+  stages:
+    - name: "{estagio}"
+      trigger: "Quando ativa este estagio"
+      playbook: "{resumo}"
+      framework: "{regras SE/ENTAO}"
+      swipe_file: "{exemplos}"
+      tone: "{tom especifico}"
+  memory:
+    short_term: "{o que lembra na conversa}"
+    long_term: "{o que persiste entre conversas}"
+    context_required: "{info necessaria}"
+  integration:
+    platform: "{WhatsApp, web, etc}"
+    handoff: "{quando escala para humano}"
+  estimated_fidelity: "{%}"
+```
+
+## Completion Criteria
+
+- [ ] Contextos de uso mapeados
+- [ ] Decisao single vs multi-stage tomada
+- [ ] Trindade mapeada por estagio
+- [ ] Memoria/contexto definido
+- [ ] Blueprint YAML gerado

package/pro/squads/squad-creator-pro/tasks/an-diagnose-clone.md

@@ -0,0 +1,87 @@
+# Task: Diagnose Clone
+
+**Command:** `*diagnose-clone`
+**Load:** `data/an-clone-anti-patterns.yaml`
+
+## Purpose
+
+Diagnosticar por que um clone esta fraco, mapeando sintomas para causas raiz e prescrevendo tratamento.
+
+## Workflow
+
+### Step 1: Identify Symptoms
+
+Perguntar ao usuario: "O que esta errado com o clone?"
+
+Sintomas comuns:
+- "Responde generico" → provavelmente falta Framework
+- "Nao parece a pessoa" → fontes bronze ou sem Voice DNA
+- "Se perde em conversas longas" → prompt monolitico, precisa estagios
+- "Quebra facil" → sem veto conditions, immune system fraco
+- "Inventa coisas" → sem Swipe File, sem limites
+- "Muito robótico" → sem contradicoes produtivas, sem storytelling
+
+### Step 2: Map to Root Cause
+
+Usar `an-clone-anti-patterns.yaml` para diagnosticar:
+
+| Sintoma | Causa Raiz Provavel | Anti-pattern |
+|---------|---------------------|-------------|
+| Generico | Falta Framework | So Playbook, sem SE/ENTAO |
+| Nao parece pessoa | Fontes bronze | Volume sem curadoria |
+| Se perde | Prompt monolitico | Sem estagios |
+| Quebra facil | Sem immune system | Sem veto conditions |
+| Inventa | Sem Swipe File | Sem exemplos reais |
+| Robótico | Sem paradoxos | Contradictions resolvidas |
+
+### Step 3: Verify Trinity
+
+Checklist rapido:
+- [ ] Tem Playbook? (passo a passo)
+- [ ] Tem Framework? (SE/ENTAO)
+- [ ] Tem Swipe File? (exemplos reais)
+- [ ] Fontes sao ouro ou bronze?
+- [ ] Quanto % do tempo foi curadoria?
+
+### Step 4: Prescribe Treatment
+
+Para cada causa raiz, prescrever acao especifica:
+
+| Causa | Tratamento | Prioridade |
+|-------|------------|------------|
+| Falta Framework | Extrair regras SE/ENTAO de entrevistas | URGENTE |
+| Fontes bronze | Reclassificar, buscar ouro | URGENTE |
+| Sem estagios | Mapear contextos, criar stages | ALTA |
+| Sem Swipe | Coletar exemplos reais | ALTA |
+| Sem immune | Definir veto conditions | MEDIA |
+| Sem paradoxos | Mapear contradictions produtivas | MEDIA |
+
+### Step 5: Generate Report
+
+```yaml
+diagnosis_report:
+  clone: "{nome}"
+  symptoms: [{lista}]
+  root_causes:
+    - cause: "{causa}"
+      evidence: "{evidencia}"
+      severity: "critico|alto|medio"
+  trinity_status:
+    playbook: "presente|ausente|parcial"
+    framework: "presente|ausente|parcial"
+    swipe_file: "presente|ausente|parcial"
+  source_quality: "ouro|mixed|bronze"
+  treatment:
+    - action: "{o que fazer}"
+      priority: "urgente|alta|media"
+      effort: "{estimativa}"
+  prognosis: "Com essas acoes, fidelidade deve subir de {X}% para {Y}%"
+```
+
+## Completion Criteria
+
+- [ ] Sintomas identificados
+- [ ] Causas raiz mapeadas
+- [ ] Trindade verificada
+- [ ] Tratamento prescrito com prioridades
+- [ ] Report de diagnostico gerado

package/pro/squads/squad-creator-pro/tasks/an-extract-dna.md

@@ -0,0 +1,90 @@
+# Task: Extract DNA Mental
+
+**Command:** `*extract-dna {mind}`
+**Load:** `data/an-source-tiers.yaml`
+
+## Purpose
+
+Extrair o DNA Mental completo (8 camadas) de uma mente especifica, documentando Voice DNA e Thinking DNA.
+
+## Workflow
+
+### Phase 1: Source Assessment (40% do tempo)
+
+1. Perguntar ao usuario: "Que material voce tem dessa pessoa?"
+2. Listar TODAS as fontes fornecidas
+3. Classificar cada fonte usando `an-source-tiers.yaml`:
+   - **OURO**: Comentarios, entrevistas longas, stories, livros, cases
+   - **BRONZE**: Palestras decoradas, conteudo antigo, generico, terceiros
+4. Gerar Source Map com score de curadoria
+
+### Phase 2: Layer Extraction
+
+Para cada camada do DNA Mental, extrair patterns das fontes OURO:
+
+| Layer | Nome | O que extrair |
+|-------|------|---------------|
+| 1 | Behavioral Patterns | Como age, reage, aborda problemas |
+| 2 | Communication Style | Vocabulario, ritmo, estrutura de frase |
+| 3 | Routines & Habits | Padroes repetitivos, rituais |
+| 4 | Recognition Patterns | O que detecta rapido, red/green flags |
+| 5 | Mental Models | Frameworks de decisao, heuristicas |
+| 6 | Values Hierarchy | O que prioriza, o que rejeita |
+| 7 | Core Obsessions | Temas que volta sempre, batalhas |
+| 8 | Productive Paradoxes | Contradicoes que sao features |
+
+### Phase 3: Document Voice DNA
+
+Extrair e documentar:
+- Identity statement (1 frase que captura essencia)
+- Power words (5-10 com contexto)
+- Signature phrases (5-7 com quando usar)
+- Metaphors (3+)
+- Vocabulary rules (always/never/transforms)
+- Tone dimensions (7 eixos, 1-10)
+- Storytelling patterns (historias recorrentes + estrutura)
+
+### Phase 4: Document Thinking DNA
+
+Extrair e documentar:
+- Primary framework (o framework MESTRE da pessoa)
+- Secondary frameworks (3-6 complementares)
+- Diagnostic framework (perguntas + red/green flags)
+- Heuristics (5+ regras SE/ENTAO com ID)
+- Veto conditions (o que NUNCA aceita)
+- Decision architecture (pipeline + weights)
+
+### Phase 5: Generate Report
+
+Gerar report YAML com:
+
+```yaml
+dna_extraction_report:
+  mind: "{nome}"
+  date: "{data}"
+  sources:
+    ouro: [{lista}]
+    bronze: [{lista}]
+    curadoria_score: "{media}"
+  voice_dna:
+    identity: "{statement}"
+    power_words: [{lista}]
+    signature_phrases: [{lista}]
+    tone: {dimensions}
+  thinking_dna:
+    primary_framework: "{nome + descricao}"
+    secondary_frameworks: [{lista}]
+    heuristics: [{lista com IDs}]
+    veto_conditions: [{lista}]
+  fidelity_estimate: "{%}"
+  next_steps: [{recomendacoes}]
+```
+
+## Completion Criteria
+
+- [ ] 8 camadas mapeadas
+- [ ] Fontes classificadas (ouro vs bronze)
+- [ ] Trindade identificada (Playbook + Framework + Swipe)
+- [ ] Voice DNA documentado
+- [ ] Thinking DNA documentado
+- [ ] Report YAML gerado com fidelity estimate

package/pro/squads/squad-creator-pro/tasks/an-extract-framework.md

@@ -0,0 +1,100 @@
+# Task: Extract Framework (Trinity)
+
+**Command:** `*extract-framework {source}`
+**Load:** — (uses core knowledge)
+
+## Purpose
+
+Extrair a Trindade completa (Playbook + Framework + Swipe File) de uma fonte especifica.
+
+## Workflow
+
+### Step 1: Identify Source Type
+
+Perguntar: "Qual a fonte? (entrevista, livro, curso, post, video)"
+
+Avaliar qualidade:
+- OURO → proceder com extracao completa
+- BRONZE → avisar que resultado sera limitado, sugerir buscar ouro
+
+### Step 2: Extract Playbook
+
+O Playbook e a RECEITA — passo a passo da metodologia.
+
+Buscar na fonte:
+- "Como ele faz X?" → sequencia de passos
+- "Qual o processo dele?" → workflow
+- "O que faz primeiro, segundo, terceiro?" → ordem
+
+Template:
+```yaml
+playbook:
+  name: "{nome da metodologia}"
+  steps:
+    - step: 1
+      action: "{o que fazer}"
+      details: "{como fazer}"
+    - step: 2
+      action: "{proximo passo}"
+```
+
+### Step 3: Extract Framework
+
+O Framework e a FORMA — regras de decisao SE/ENTAO.
+
+Buscar na fonte:
+- "Quando ele ve X, o que faz?" → regra condicional
+- "Como decide entre A e B?" → criterio
+- "O que NUNCA faria?" → veto condition
+
+Template:
+```yaml
+framework:
+  rules:
+    - condition: "SE {situacao}"
+      action: "ENTAO {decisao}"
+      rationale: "{por que}"
+  veto:
+    - condition: "SE {situacao}"
+      action: "NUNCA {acao proibida}"
+```
+
+### Step 4: Extract Swipe File
+
+O Swipe File sao EXEMPLOS — provas que funcionam.
+
+Buscar na fonte:
+- Casos reais com numeros
+- Exemplos especificos citados
+- Analogias e metaforas usadas
+- Historias contadas repetidamente
+
+Template:
+```yaml
+swipe_file:
+  cases:
+    - title: "{caso}"
+      context: "{situacao}"
+      result: "{resultado}"
+      lesson: "{licao}"
+  analogies:
+    - concept: "{conceito}"
+      analogy: "{analogia usada}"
+```
+
+### Step 5: Validate Completeness
+
+Checklist da Trindade:
+- [ ] Playbook tem passos claros e sequenciais
+- [ ] Framework tem regras SE/ENTAO (nao so teoria)
+- [ ] Swipe File tem exemplos REAIS (nao inventados)
+- [ ] Os tres se complementam (playbook diz O QUE, framework diz QUANDO, swipe mostra COMO)
+
+Se falta alguma perna: avisar qual e sugerir onde buscar.
+
+## Completion Criteria
+
+- [ ] Playbook extraido (passo a passo)
+- [ ] Framework extraido (regras SE/ENTAO)
+- [ ] Swipe File extraido (exemplos validados)
+- [ ] Completude validada (3 pernas presentes)