iron-edge 1.2.0 → 2.0.1

package/squads/squad-courses/tasks/sequence-difficulty-progression.md

@@ -17,30 +17,44 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Cada lição do módulo tem um nível de Bloom-alvo atribuído, não só um tipo"
+  - "[ ] Nenhuma lição pula mais de um nível de Bloom em relação à anterior"
+  - "[ ] Nível mínimo do domínio respeitado a partir do módulo em que ele se aplica"
+  - "[ ] Interleaving marcado só em revisões, pré-avaliação ou projeto final — nunca antes do módulo 3"
+  - "[ ] Nenhuma lição do módulo 4+ ainda presa em Remember/Understand sem justificativa"
 ---
 
 # Task: sequence-difficulty-progression
 
-## Metadata
-- **Agent:** lesson-architect (Blueprint)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
-
 ## Objetivo
-Sequenciar progressao de dificuldade
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Atribuir, a cada lição já definida em `design-module-structure`, o nível de Bloom que ela precisa alcançar — a escada de dificuldade que atravessa o módulo e o curso.
+
+## A regra que governa
+**A dificuldade sobe em degraus de Bloom, nunca em patamares.** Módulos 1-2 ficam em Remember/Understand, módulo 3 em diante empurra pra Apply/Analyze, o projeto final exige Evaluate ou Create. Nenhuma lição pula mais de um degrau em relação à anterior — isso não é progressão, é vertigem.
+
+## Passos
+1. **Puxe a tabela de posição → nível de Bloom.** `instructional-design-frameworks.md` (seção "Rule for course design", dentro de Bloom's Taxonomy Revised) define o piso esperado por posição no curso. Use-a como ponto de partida, não como forma fixa.
+
+2. **Atribua o nível de Bloom-alvo a cada lição da saída de `design-module-structure`.** Cada lição já tem tipo e scaffolding; agora ganha também o verbo que o objetivo (de `define-lesson-objectives`) precisa cumprir.
+   ⚠️ Sinal de progressão travada: módulo 4 com uma lição ainda pedindo "listar" ou "identificar" (Remember) sem que isso sirva de recall pontual pra algo mais avançado na mesma lição.
+
+3. **Respeite o piso por domínio em cursos profissionais/certificação.** A tabela por domínio em `instructional-design-frameworks.md` fixa mínimos: contabilidade não fecha abaixo de Apply, direito não fecha abaixo de Analyze, consultoria estratégica exige Evaluate. Isso vale a partir do momento em que o curso se declara profissional — não precisa valer desde a lição 1.1.
+
+4. **Decida onde entra o interleaving.** Misturar tópicos antigos com o novo (`instructional-design-frameworks.md`, Interleaving) serve para revisões antes de avaliação e para o projeto final — nunca antes do módulo 3, quando as bases ainda não existem pra misturar.
+
+5. **Confira o salto entre lições vizinhas.** Nenhuma lição avança mais de um nível de Bloom em relação à anterior dela; se o outcome do módulo exige um salto maior, é sinal de que falta uma lição intermediária — volte pra `design-module-structure`.
+
+## O que não vale
+- Subir um nível de Bloom por lição só "porque fica bonito" — a progressão segue a competência real, não uma escada decorativa.
+- Todas as lições do curso presas no mesmo nível.
+- Interleaving desde a lição 1.1, antes de haver conteúdo antigo pra misturar.
+- Confundir com `design-module-structure`: lá se decide scaffolding e tipo de lição; aqui se decide o nível cognitivo (Bloom) que ela precisa alcançar.
+
+## Formato da saída
+Lição → nível de Bloom-alvo → verbo esperado → interleaving (sim/não):
+> 3.1 — Apply — "calcular" — não
+> 3.4 — Apply — "resolver" — não
+> 5.3 (revisão) — Analyze — "comparar" — sim, mistura módulos 2-4
+
+## Fontes no squad
+`knowledge-base/instructional-design-frameworks.md` (Bloom's Taxonomy Revised, tabela por domínio, Interleaving), `knowledge-base/adult-learning-principles.md` (Scaffolding, Interleaving).

package/squads/squad-courses/tasks/structure-module-sequence.md

@@ -17,30 +17,47 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] 3 a 8 modulos, cada um mapeado a 1 outcome ou cluster de outcomes"
+  - "[ ] Modulos ordenados de fundamental para aplicado (Bloom crescente)"
+  - "[ ] Cada modulo com 3 a 7 licoes, tipo de licao marcado"
+  - "[ ] Duracao por licao/modulo dentro da faixa do formato escolhido"
+  - "[ ] Nota de 'por que esta ordem' escrita em cada modulo"
 ---
 
-# Task: structure-module-sequence
-
-## Metadata
-- **Agent:** curriculum-designer (Compass)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
+# Task: Estruturar a sequência de módulos
 
 ## Objetivo
-Estruturar sequencia de modulos
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Transformar os outcomes e a jornada já decidida em uma lista concreta e ordenada de módulos e lições, com tipo e duração — a espinha dorsal do curso.
+
+## A regra que governa
+**Cada módulo mapeia a um outcome (ou cluster de outcomes), e a ordem vai do fundamental para o aplicado.** `curriculum-mapping-guide.md` é explícito: "sequência importa: fundamental antes de aplicado." Módulo sem outcome por trás é conteúdo solto; módulo fora de ordem de dificuldade quebra o scaffolding decidido em `design-learning-path`.
+
+## Passos
+
+1. **Agrupe outcomes em 3 a 8 módulos.** Um outcome — ou um cluster de outcomes relacionados — por módulo, seguindo o Passo 2 de `curriculum-mapping-guide.md`. Não crie módulo que não aponta para nenhum outcome de `define-learning-outcomes`.
+
+2. **Ordene por nível de Bloom crescente.** `instructional-design-frameworks.md` dá a régua: módulos 1-2 seguram em Remember/Understand, módulos 3-5 empurram para Apply/Analyze, o projeto final tem que alcançar Evaluate ou Create. Se a trilha estendida de `design-learning-path` existe, ela entra depois da trilha core.
+
+3. **Quebre cada módulo em 3 a 7 lições**, seguindo o Passo 3 de `curriculum-mapping-guide.md`. Marque o tipo de cada uma: Concept / Demo / Practice / Case Study / Review / Assessment. Use a estrutura de lição do formato escolhido em `course-format-patterns.md` — por exemplo, lição de vídeo segue hook (30s) → conteúdo → resumo (30s) → ação; lição escrita segue objetivo → conceito → exemplo → exercício → conclusão.
+
+4. **Calibre a duração pela faixa do formato.** `course-format-patterns.md` dá os números: curso em vídeo, 2-10h no total, lição de 5-15 min; workshop, blocos de conteúdo de no máximo 30 min sem interação; mini-curso, 3-7 lições de 5-10 min.
+   ⚠️ **Duração "chutada" sem lastro no formato é o erro mais comum aqui.** Se o formato é mini-curso e o módulo 1 sozinho já passa de 90 minutos, ou o formato mudou ou o módulo precisa ser cortado.
+
+5. **Escreva a nota "por que esta ordem" em cada módulo.** `curriculum-mapping-guide.md` lista "sem lógica de sequência visível" como erro comum — a correção é uma frase curta por módulo explicando a dependência ou a progressão que justifica a posição dele.
+
+## Formato da saída
+Segue a estrutura de `templates/course-outline-template.md`: tabela de Module Overview (módulo, título, outcome, nº de lições, duração) e, por módulo, a tabela Detailed Lesson List (lição, título, tipo, objetivo, duração).
+
+| Módulo | Título | Outcome | Lições | Duração |
+|---|---|---|---|---|
+| 1 | Fundamentos do DRE | Outcome 1 (Apply) | 4 | 45 min |
+| 2 | Comparando regimes tributários | Outcome 2 (Evaluate) | 5 | 60 min |
+
+## O que não vale
+- Módulo órfão, sem outcome por trás — corta ou reatribui.
+- Todas as lições em Remember/Understand: pelo menos metade tem que chegar em Apply ou acima.
+- Lista de módulos copiada de um curso parecido sem recalibrar Bloom, duração e ordem para este outcome específico.
+- Duração fora da faixa do formato escolhido sem justificativa registrada.
+
+## Fontes no squad
+`knowledge-base/curriculum-mapping-guide.md` (Passo 2 e Passo 3, Common Curriculum Mistakes), `knowledge-base/instructional-design-frameworks.md` (regra de progressão Bloom por módulo), `knowledge-base/course-format-patterns.md` (estrutura de lição e faixas de duração por formato), `templates/course-outline-template.md` (Module Overview, Detailed Lesson List).

package/squads/squad-courses/tasks/validate-pedagogical-coherence.md

@@ -17,30 +17,50 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Alignment Validation Checklist rodado linha por linha, nao por impressao geral"
+  - "[ ] Nenhuma licao orfa (sem outcome/avaliacao) nem outcome orfo (sem licao)"
+  - "[ ] Pelo menos metade das licoes em Apply ou acima"
+  - "[ ] Duracao total bate com a faixa do formato escolhido"
+  - "[ ] Itens de Curriculum and Structure do checklist de completude verificados"
 ---
 
-# Task: validate-pedagogical-coherence
-
-## Metadata
-- **Agent:** curriculum-designer (Compass)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
+# Task: Validar coerência pedagógica
 
 ## Objetivo
-Validar coerencia pedagogica
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Auditar o currículo inteiro contra o alinhamento vertical — outcome de curso → outcome de módulo → objetivo de lição → item de avaliação — antes de liberar para `lesson-architect`, e declarar aprovado ou a lista exata de furos.
+
+## A regra que governa
+**A casa mede o alinhamento, não sente que "faz sentido".** `curriculum-mapping-guide.md` define a hierarquia — Course Outcome → Module Outcome → Lesson Objective → Assessment Item — e a regra de corte: se um item não amarra para cima, ele sai. Esta task existe para rodar essa verificação item por item, não para dar uma passada de olho no documento e aprovar por impressão.
+
+## Passos
+
+1. **Rode o Alignment Validation Checklist de `curriculum-mapping-guide.md` linha por linha.** Toda lição tem objetivo escrito? Todo objetivo conecta a um outcome de módulo? Todo outcome de módulo conecta a um outcome de curso? Toda avaliação mapeia a um objetivo específico?
+
+2. **Caçe órfãos nos dois sentidos.** Lição ensinada sem outcome nem avaliação por trás (órfã "pra baixo") e outcome declarado que nenhuma lição endereça (órfão "pra cima") — os dois são listados explicitamente como erro comum em `curriculum-mapping-guide.md`, e os dois quebram o contrato do syllabus.
+
+3. **Confira a distribuição de Bloom.** `instructional-design-frameworks.md` manda pelo menos metade das lições em Apply ou acima, e o projeto final tem que alcançar Evaluate ou Create. Currículo todo travado em Remember/Understand reprova aqui, mesmo que o resto esteja alinhado.
+
+4. **Confira a cadeia de pré-requisitos e a duração.** Cruze com o que `map-prerequisite-chain` documentou — sequência sem lacuna? E confira se a duração total soma dentro da faixa do formato escolhido em `course-format-patterns.md` (ex.: curso em vídeo, 2-10h; mini-curso, 30-90 min).
+
+5. **Rode os itens de "Curriculum and Structure" de `checklists/course-completeness-checklist.md`.** 3 a 8 módulos, outcome escrito por módulo, 3 a 6 lições por módulo, objetivo com verbo de Bloom em cada lição, pré-requisitos documentados, duração total como anunciada.
+
+6. **Declare o veredito, apontando a task de origem de cada furo.** Não basta dizer "tem um problema" — aponte se o furo nasceu em `define-learning-outcomes`, `structure-module-sequence` ou `map-prerequisite-chain`, para quem for corrigir saber exatamente onde voltar.
+   ⚠️ **Aprovar "vou ajustar depois" não é aprovar.** Furo não corrigido aqui vira dívida que `lesson-architect` e `assessment-creator` herdam sem saber que existe.
+
+## Formato da saída
+Relatório curto: veredito (aprovado / reprovado) e, se reprovado, lista de furos — cada um com o item do checklist que falhou e a task de origem a revisitar.
+
+```
+Veredito: REPROVADO
+- Módulo 4 sem outcome de módulo escrito (Curriculum and Structure, item 2) → volta a structure-module-sequence
+- Outcome 3 do curso sem nenhuma lição que o endereça (órfão) → volta a define-learning-outcomes ou structure-module-sequence
+```
+
+## O que não vale
+- Aprovar por "parece coerente" sem rodar a checklist linha por linha.
+- Aprovar currículo com módulo sem outcome escrito, mesmo que pareça pequeno.
+- Aprovar quando a duração total não bate com o formato prometido no syllabus.
+- Devolver "está bom" ou "tem uns furos" sem apontar qual item específico falhou e onde corrigir.
+
+## Fontes no squad
+`knowledge-base/curriculum-mapping-guide.md` (Mapping Hierarchy, Alignment Validation Checklist, Common Curriculum Mistakes), `knowledge-base/instructional-design-frameworks.md` (regra de distribuição Bloom por módulo), `knowledge-base/course-format-patterns.md` (faixas de duração por formato), `checklists/course-completeness-checklist.md` (seção Curriculum and Structure).

package/squads/squad-courses/tasks/write-case-studies.md

@@ -17,30 +17,38 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Situação, ponto de decisão, dados disponíveis e perguntas de discussão presentes"
+  - "[ ] Caso baseado em dado real do domínio, não em empresa genérica"
+  - "[ ] Nenhuma resposta certa entregue no texto do caso"
+  - "[ ] Perguntas de discussão mapeadas a um nível de Bloom (Analyze ou acima)"
+  - "[ ] Caso resolvível só com o conteúdo já ensinado até este ponto do curso"
 ---
 
 # Task: write-case-studies
 
-## Metadata
-- **Agent:** content-writer (Scribe)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
-
 ## Objetivo
-Escrever estudos de caso
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Escrever um estudo de caso que obriga o aluno a decidir, não a reconhecer a resposta certa — o material que transforma a lição em julgamento aplicado.
+
+## A regra que governa
+**O caso não entrega a resposta certa — a decisão do aluno é o aprendizado.** Vem do Case Method em `instructional-design-frameworks.md`: a discussão É o aprendizado, não uma checagem depois dele. Se o texto do caso já aponta o que fazer, não é um caso — é um exemplo com fantasia de caso.
+
+## Passos
+1. **Monte a situação com dado real do domínio**, não uma "Empresa X" genérica. Use números, prazos e restrições plausíveis (um regime tributário real, uma cláusula contratual real). `assessment-design-guide.md` chama isso de avaliação autêntica: "um profissional conseguiria usar esse output no trabalho dele?" — se sim, o caso está no nível certo.
+   ⚠️ Realista não é o mesmo que complexo demais. O caso precisa ser resolvível só com o que já foi ensinado até este ponto do curso, não com conteúdo de módulos futuros.
+2. **Escreva o ponto de decisão.** O que exatamente precisa ser decidido, e até quando — uma frase sem ambiguidade sobre o que está sendo pedido, mesmo que a resposta certa seja ambígua de propósito.
+3. **Liste os dados disponíveis** — financeiros, legais, operacionais, conforme o domínio. Inclua ruído real (um dado irrelevante, uma informação incompleta) quando o nível-alvo é Analyze ou acima; corte o ruído em casos de nível Apply.
+4. **Escreva as perguntas de discussão**, mapeadas ao nível de Bloom do módulo: "compare/diferencie" para Analyze, "justifique/defenda" para Evaluate, "construa um plano" para Create (`instructional-design-frameworks.md`).
+5. **Não feche o caso com o veredito.** Termine nas perguntas de discussão. Um gabarito, se existir, é documento separado para o instrutor — nunca a última seção do caso entregue ao aluno.
+
+## Formato da saída
+Documento com quatro blocos fixos: **Situação** (quem, o quê, quando) · **Ponto de decisão** (o que precisa ser decidido) · **Dados disponíveis** (financeiro/legal/operacional conforme o domínio) · **Perguntas de discussão** (3–5, cada uma mapeada a um verbo de Bloom).
+
+## O que não vale
+- Caso com "a resposta certa é..." escrito no próprio texto — isso vira exemplo, não caso.
+- Empresa e nomes fictícios genéricos demais pra soarem reais no domínio do curso.
+- Caso que exige conceito de um módulo futuro que o aluno ainda não viu.
+- Perguntas de discussão todas em nível Remember ("o que a empresa fez?") — isso é teste de leitura, não estudo de caso.
+
+## Fontes no squad
+- `knowledge-base/instructional-design-frameworks.md` — Case Method (Harvard Case), seção Active Learning Strategies
+- `knowledge-base/assessment-design-guide.md` — Authentic Assessment, tabela por domínio

package/squads/squad-courses/tasks/write-ebook-chapter.md

@@ -17,30 +17,38 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Capítulo abre com provocação, não com definição"
+  - "[ ] Uma frase declarando o que muda pro leitor, antes do primeiro parágrafo de conteúdo"
+  - "[ ] Todo conceito abstrato é seguido de exemplo concreto — nunca dois abstratos em sequência"
+  - "[ ] Fecha com pergunta de transferência (aplicação nos próximos 7 dias), não resumo genérico"
+  - "[ ] Extensão entre 1.500 e 3.000 palavras; acima disso, dividido em mais de um capítulo"
 ---
 
 # Task: write-ebook-chapter
 
-## Metadata
-- **Agent:** content-writer (Scribe)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
-
 ## Objetivo
-Escrever capitulo de ebook
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Escrever um capítulo autocontido de material de leitura (apostila/ebook) que ensina um bloco de conteúdo do início ao fim, sem depender de vídeo ou aula ao vivo pra fazer sentido.
+
+## A regra que governa
+**O capítulo prova por que importa antes de explicar o que é.** Vem do princípio "need to know" do `adult-learning-principles.md`: adulto precisa saber POR QUE antes de aprender — diferente de criança, que aceita "porque eu disse". Um capítulo que abre com definição, sem contexto de uso, perde o leitor adulto na primeira página.
+
+## Passos
+1. **Abra com a provocação, não com a definição.** Uma pergunta, uma estatística que contraria o que o leitor assume saber, ou um cenário que ele reconhece. `adult-learning-principles.md` (Mezirow, Transformative Learning) dá o padrão: "a maioria dos donos de empresa acredita estar no melhor regime tributário — ao final deste capítulo, você vai saber verificar isso, e pode descobrir que pagou a mais por anos."
+2. **Declare o que muda pro leitor**, uma frase antes do primeiro parágrafo de conteúdo: "ao final deste capítulo, você será capaz de [verbo de Bloom] [objeto]."
+3. **Ensine um bloco de ideia por vez**, com exemplo concreto logo depois de cada conceito abstrato — nunca dois ou três conceitos abstratos em sequência sem aterrissar nenhum. É a mesma regra de "uma seção, um ponto" do `lesson-quality-checklist.md`, aplicada a texto corrido.
+   ⚠️ Capítulo de ebook tolera mais profundidade que uma lição em vídeo, mas não tolera menos estrutura — sem cabeçalhos e sem parágrafos curtos, o leitor perde o fio.
+4. **Feche com transferência**, não com resumo genérico: "como você vai usar isso nos próximos 7 dias?" (Transfer of Learning, `adult-learning-principles.md`).
+5. **Confira a extensão contra o propósito.** Capítulo de leitura de apoio: 1.500–3.000 palavras. Acima disso, é dois capítulos — divida antes de entregar.
+
+## Formato da saída
+Texto corrido com cabeçalhos por seção: **Abertura** (provocação + o que muda) → **Desenvolvimento** (conceito + exemplo, repetido por bloco) → **Fechamento** (transferência: aplicação nos próximos 7 dias). Sem placeholders — texto final, pronto pra diagramação.
+
+## O que não vale
+- Abrir com definição de dicionário do termo do capítulo.
+- Empilhar três conceitos abstratos antes do primeiro exemplo.
+- Fechar com "neste capítulo você aprendeu X, Y e Z" sem pedir nenhuma aplicação.
+- Capítulo de 6.000 palavras entregue como peça única — isso é vários capítulos com o mesmo título.
+
+## Fontes no squad
+- `knowledge-base/adult-learning-principles.md` — Need to know, Transformative Learning (Mezirow), Transfer of Learning
+- `checklists/lesson-quality-checklist.md` — estrutura em seções, um ponto por seção

package/squads/squad-courses/tasks/write-handout-material.md

@@ -17,30 +17,38 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Formato de consulta rápida (tabela/lista/passo a passo), não leitura linear"
+  - "[ ] Cada handout resolve uma tarefa concreta, não um tema inteiro"
+  - "[ ] Autocontido — funciona sem o aluno lembrar em que aula viu o conceito"
+  - "[ ] Sem espaço de preenchimento do aluno (isso é workbook, não handout)"
+  - "[ ] Cabe em 1-2 páginas"
 ---
 
 # Task: write-handout-material
 
-## Metadata
-- **Agent:** content-writer (Scribe)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
-
 ## Objetivo
-Escrever material de apoio
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Escrever um material de referência rápida (handout/job aid) que o aluno consulta enquanto aplica o que aprendeu — não enquanto aprende, e não depois pra revisar.
+
+## A regra que governa
+**O handout serve pra consultar durante a aplicação, não pra ler uma vez.** Isso separa o handout das outras peças de apoio do squad: a lição ensina, a folha de resumo (`write-summary-sheets`) reforça a memória depois, o handout apoia a mão no momento de fazer. Se o material só faz sentido lido do início ao fim, não é handout — é capítulo. Se ele pede pro aluno escrever algo, não é handout — é workbook.
+
+## Passos
+1. **Identifique o momento de uso.** O aluno vai ter isso aberto ENQUANTO faz a tarefa real (preenchendo uma planilha, redigindo uma cláusula, seguindo um checklist), ou é algo pra ler antes? Handout é sempre a primeira opção — se a resposta for a segunda, o formato certo é outro.
+2. **Organize por consulta, não por narrativa.** Nada de parágrafos longos: tabelas, listas numeradas, passo a passo, fórmulas em destaque — o aluno precisa achar o ponto que precisa em segundos, sem reler o material inteiro.
+   ⚠️ Handout denso de texto corrido falha no uso real: ninguém para o trabalho pra ler um parágrafo de apoio.
+3. **Um handout por tarefa concreta.** "Como calcular X" é um handout. "Tudo sobre X" não é — isso é capítulo. Se o material cobre mais de uma tarefa, divida em mais de um handout.
+4. **Torne autocontido.** O aluno pode estar consultando isso sem lembrar em que aula viu o conceito — não use referências tipo "como vimos na aula 3" sem também repetir o essencial ali.
+5. **Teste contra o uso real.** Releia como se estivesse no meio da tarefa procurando a resposta, não como se estivesse estudando. Se demora pra achar, reorganize.
+
+## Formato da saída
+Documento de uma a duas páginas, com título que nomeia a tarefa (não o tema): "Como classificar uma despesa por regime tributário" em vez de "Regimes tributários". Corpo em tabela, lista ou passo numerado — nunca parágrafo corrido como formato principal.
+
+## O que não vale
+- Handout que é a lição reduzida — se cortar não muda o formato, é resumo, não apoio de consulta.
+- Texto corrido de mais de um parágrafo por item.
+- Handout com espaço pro aluno escrever (isso é workbook).
+- Material que só faz sentido lido junto com a aula, sem repetir o essencial.
+
+## Fontes no squad
+- `knowledge-base/adult-learning-principles.md` — Andragogia, orientação pra aplicação imediata ("immediate application")
+- `knowledge-base/engagement-retention-patterns.md` — Microlearning Patterns, princípio "self-contained"

package/squads/squad-courses/tasks/write-lesson-content.md

@@ -17,30 +17,41 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Objetivo com verbo de Bloom, declarado nos primeiros 30-60 segundos / primeiro parágrafo"
+  - "[ ] Um conceito só por lição"
+  - "[ ] Exemplo concreto presente"
+  - "[ ] Exercício ou prompt de aplicação específico incluído"
+  - "[ ] Fecha com checkpoint e 3-5 takeaways"
+  - "[ ] Extensão dentro de 800-2.500 palavras (texto) ou 5-12 min (fala)"
 ---
 
 # Task: write-lesson-content
 
-## Metadata
-- **Agent:** content-writer (Scribe)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
-
 ## Objetivo
-Escrever conteudo da licao
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Escrever o texto (ou roteiro falado) de uma lição individual — a unidade mínima de ensino do curso — pronta pra passar no `lesson-quality-checklist.md` sem revisão.
+
+## A regra que governa
+**Uma lição ensina uma coisa só, e cabe no tempo de atenção real.** Dado medido em `engagement-retention-patterns.md` (Guo et al., dataset edX, 6,9M sessões): vídeo até 6 minutos é assistido quase inteiro; acima de 12 minutos, a queda é grande. Se o conceito precisa de 20 minutos pra ser explicado, isso é duas lições — nunca uma lição longa.
+
+## Passos
+1. **Abra com gancho, não com o tema.** Pergunta, problema ou fato que já conecta com a situação real do aluno — não "hoje vamos falar sobre X". Declare "por que isso importa" nos primeiros 30-60 segundos (texto: primeiro parágrafo).
+2. **Siga a sequência dos 9 Eventos de Gagné** (`instructional-design-frameworks.md`), adaptada pro formato: ganhar atenção → declarar objetivo → ativar conhecimento prévio ("você já sabe X, agora vamos somar Y") → ensinar o conceito → dar um exemplo trabalhado → propor prática → indicar o feedback esperado → fechar com checkpoint.
+   ⚠️ Pular direto pro conteúdo sem ativar conhecimento prévio é o erro mais comum — o aluno perde o gancho com o que ele já sabe.
+3. **Um conceito por lição.** Se ao revisar você encontra "e também" ligando dois conceitos que não dependem um do outro, são duas lições, não uma.
+4. **Inclua pelo menos um exercício ou prompt de aplicação** que o aluno consiga fazer no contexto real dele — não "reflita sobre isso" solto, e sim uma instrução específica.
+5. **Feche com checkpoint e takeaways.** Uma pergunta de verificação (o aluno confere se atingiu o objetivo) e 3–5 pontos-chave, mais a ponte pra próxima lição.
+6. **Confira a extensão antes de entregar:** lição em vídeo, 5–12 minutos de fala; lição em texto, 800–2.500 palavras (faixas do `lesson-quality-checklist.md`).
+
+## Formato da saída
+Texto ou roteiro estruturado em blocos nomeados: **Gancho** → **Objetivo** → **Conexão com o que já sabe** → **Conteúdo** → **Exemplo** → **Prática** → **Checkpoint** → **Takeaways + próxima lição**. Cada bloco curto o bastante pra ser lido de uma vez.
+
+## O que não vale
+- Objetivo escrito com "entender" ou "aprender" em vez de um verbo de Bloom observável.
+- Lição que ensina dois conceitos porque "estão relacionados".
+- Exercício vago tipo "pense sobre isso" sem prompt específico.
+- Lição que ultrapassa 12 minutos/2.500 palavras entregue inteira, sem dividir.
+
+## Fontes no squad
+- `knowledge-base/instructional-design-frameworks.md` — 9 Eventos de Gagné, Bloom's Taxonomy revisada
+- `knowledge-base/engagement-retention-patterns.md` — Pattern 1 (Shorter Lessons), pesquisa de attention span
+- `checklists/lesson-quality-checklist.md` — critérios completos de aprovação da lição

package/squads/squad-courses/tasks/write-slide-content.md

@@ -17,30 +17,50 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Todo título de slide de conceito é uma afirmação, não um rótulo de tema"
+  - "[ ] Cada linha de texto tem no máximo 6 palavras"
+  - "[ ] Cada slide carrega exatamente 1 conceito"
+  - "[ ] Nenhum bullet repete o que a fala/nota vai dizer"
 ---
 
-# Task: write-slide-content
-
-## Metadata
-- **Agent:** slide-designer (Deck)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
+# Task: Escrever o texto dos slides
 
 ## Objetivo
-Escrever conteudo dos slides
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Preencher o esqueleto definido em `design-slide-structure` com o texto final de cada slide — título, bullets, legendas.
+
+## A regra que governa
+**O slide é o resumo; a fala (ou o texto de apoio) é a explicação — nunca os dois dizendo a mesma frase.** É o "redundancy effect" de `adult-learning-principles.md`: repetir na tela, palavra por palavra, o que já vai ser dito é carga cognitiva desperdiçada, não reforço.
+
+## Passos
+
+1. **Título é o ponto, não o tópico.** `presentation-design-principles.md`, regra 2: "Revenue grew 40%" ensina mais que "Revenue". Todo título de slide de conceito é uma afirmação verificável — algo que pode estar certo ou errado — nunca um rótulo de assunto como "Módulo 3" ou "Framework de Precificação".
+
+2. **Máximo de 6 palavras por linha de texto.** Regra 3 da mesma fonte. ⚠️ **A régua é por linha, não por slide inteiro.** Um slide com 3 bullets de 12-15 palavras cada não respeita a regra só porque "são poucos bullets" — cada linha individual precisa caber no teto.
+
+3. **Um conceito por slide, sem exceção por proximidade.** Tabela "Cognitive Load Management": 1 concept per slide é a meta, 3 concepts per slide é o que se evita. Teste rápido: se a frase de conteúdo precisa de "e" ligando dois substantivos que o aluno tem que lembrar separados, são dois slides — não um.
+
+4. **Respeitar atenção dividida.** Quando o slide acompanha uma demonstração ao vivo (tela, código, ferramenta), o texto no slide é rótulo curto, não bloco — `adult-learning-principles.md` ("Split attention": não pedir para ler texto e assistir a demo ao mesmo tempo). Quem precisa do detalhe completo é a nota do apresentador, não o slide.
+
+5. **Densidade muda com o formato — mas dentro da régua.** Slide de curso gravado, sem apresentador ao vivo, pode ter um bullet a mais que um slide de mentoria ao vivo, porque o slide comunica sozinho (ver `adapt-slides-for-format`). Isso não licencia parágrafo: o teto de 6 palavras por linha continua valendo, o que muda é o número de linhas aceitável.
+
+## Formato da saída
+Texto final por slide, pronto para diagramação:
+```
+Slide 6 — Título: "O preço errado mata margem antes de matar venda"
+Bullets: [nenhum — o diagrama carrega o conteúdo]
+
+Slide 9 — Título: "3 sinais de que o preço está baixo"
+Bullets:
+- Cliente nunca questiona o valor
+- Concorrente direto cobra o dobro
+- Margem não cobre o imprevisto
+```
+
+## O que não vale
+- Título que é rótulo de tema em vez de afirmação.
+- Bullet que reescreve, com outras palavras, o que a nota do apresentador já vai dizer.
+- Slide com 3+ ideias porque "está tudo relacionado ao mesmo tópico".
+- "Máximo 6 palavras" cumprido só no bullet mais curto do slide, ignorando os outros.
+
+## Fontes no squad
+`knowledge-base/presentation-design-principles.md`, `knowledge-base/adult-learning-principles.md`.

package/squads/squad-courses/tasks/write-summary-sheets.md

@@ -17,30 +17,38 @@ Saida:
     destino: "next phase"
 
 Checklist:
-  - "[ ] Validar inputs"
-  - "[ ] Executar steps"
-  - "[ ] Verificar qualidade"
-  - "[ ] Gerar output"
+  - "[ ] Formato de recuperação ativa (pergunta antes da resposta), não lista de fatos pra reler"
+  - "[ ] Cobre um módulo inteiro, misturando temas de lições diferentes"
+  - "[ ] Cadência de revisão sugerida (1/3/7/21 dias) indicada no topo"
+  - "[ ] Sem exercício de aplicação nova (isso é workbook, não resumo)"
+  - "[ ] Cabe em uma página"
 ---
 
 # Task: write-summary-sheets
 
-## Metadata
-- **Agent:** content-writer (Scribe)
-- **Squad:** squad-courses
-- **Complexity:** STANDARD
-
 ## Objetivo
-Escrever folhas de resumo
-
-## Steps
-1. Receber inputs e contexto do curso
-2. Executar operacao principal
-3. Validar output contra criterios pedagogicos
-4. Entregar artefato para proxima fase
-
-## Criterios de Qualidade
-- Alinhado aos learning outcomes
-- Nivel adequado para audiencia
-- Formato consistente com tipo de curso
-- Pronto para proxima fase
+Escrever a folha de revisão que o aluno usa depois de terminar um módulo, pra reter o que aprendeu — não pra aprender de novo.
+
+## A regra que governa
+**A folha de resumo testa a memória, não substitui ela.** `adult-learning-principles.md` cita o Testing Effect (Roediger & Karpicke, 2006): quem faz teste de recuperação retém 50% mais depois de uma semana do que quem só releu o material. Uma folha de resumo que só lista fatos pra reler é menos eficaz que uma que pergunta e obriga o aluno a lembrar antes de conferir.
+
+## Passos
+1. **Escreva em formato de recuperação, não de lista.** Prefira "Quais são as 5 bases legais da LGPD?" com a resposta escondida ou numa segunda coluna, em vez de listar as 5 bases direto. Recall guiado funciona melhor que reconhecimento (Retrieval Practice, `adult-learning-principles.md`).
+2. **Cubra o módulo inteiro, misturando os temas.** Não separe por lição em blocos estanques — intercale perguntas de lições diferentes do mesmo módulo (Interleaving, `adult-learning-principles.md`). É mais difícil no momento e retém mais depois.
+   ⚠️ Uma folha de resumo por lição individual quebra o efeito de interleaving — o mínimo é por módulo.
+3. **Marque a cadência de revisão sugerida.** Use os intervalos do `instructional-design-frameworks.md` (Spaced Repetition): 1 dia depois, 3 dias, 7 dias, 21 dias, depois mensal. Uma linha no topo da folha: "Revise isso em 1, 3, 7 e 21 dias."
+4. **Não inclua exercício de aplicação nova.** Se o item pede pro aluno aplicar o conceito num contexto novo, virou exercício de workbook — a folha de resumo só verifica se o que já foi ensinado ficou.
+5. **Limite a uma página.** Se não cabe, o problema é escopo — está tentando resumir mais de um módulo, ou incluindo detalhe demais pra ser resumo.
+
+## Formato da saída
+Uma página, dividida em blocos de recuperação por tema do módulo (pergunta + espaço/resposta oculta), misturando temas de lições diferentes, com a linha de cadência de revisão no topo.
+
+## O que não vale
+- Lista de fatos pra reler, sem nenhuma pergunta de recuperação.
+- Uma folha por lição em vez de por módulo (perde o interleaving).
+- Exercício de aplicação nova disfarçado de resumo.
+- Folha de mais de uma página — sinal de que o escopo passou do módulo.
+
+## Fontes no squad
+- `knowledge-base/adult-learning-principles.md` — Retrieval Practice, Interleaving
+- `knowledge-base/instructional-design-frameworks.md` — Spaced Repetition, tabela de intervalos