"""
Project Together — powered by AI: prompts curados do curso.

A REGRA DE OURO (nao muda em nenhum passo):
    VOCE escreve primeiro. A IA propoe em cima do que voce escreveu. VOCE decide.

O FIO CONDUTOR (o que faz este curso ser "Together")
    Cada prompt come a saida do passo anterior. Voce escreve a JUSTIFICATIVA (por
    que este projeto existe) — e so isso, com as suas palavras. Dali em diante a
    corrente se puxa sozinha:

        justificativa -> objetivos e KRs -> entregas -> partes interessadas
                      -> ABORDAGEM (o COMO: a sua decisao, e a fronteira do curso)
                      -> restricoes/premissas/riscos + onde -> quando e quanto
                      -> escopo -> riscos -> cronograma -> plano aprovado
                      -> execucao -> status -> mudancas -> encerramento

    O COMO vem antes do QUANDO, do QUANTO e do ONDE porque e ele que define como esses
    tres se calculam (marco de entrega ou fim de Sprint? custo do projeto ou custo do
    time por Sprint?). O ONDE, alias, e parte do COMO.

    O modulo contexto.py guarda a saida de cada passo e ja monta o prompt do
    passo seguinte PREENCHIDO (em _saida/prompt-passo-N.txt). Voce nunca remonta
    prompt nem cata dado antigo.

DUAS ABORDAGENS, AS MESMAS PERGUNTAS
    O Guia PMBOK 8 (secao "Initiate Project or Phase") diz que um termo de
    abertura ADAPTATIVO responde as MESMAS perguntas de um preditivo — muda a
    FORMA e o NIVEL DE DETALHE da resposta. Por isso os passos 1 e a espinha do
    quadro sao IGUAIS nas duas abordagens; o que muda (escopo, cronograma,
    execucao, monitoramento, mudancas) tem uma variante por abordagem, escolhida
    pela variavel ABORDAGEM do .env (PREDITIVA ou AGIL).

UM CAMINHO SO: A IA NO CHAT (Eduardo, 2026-08-01)
    O curso tinha dois modos — CHAT (IA no navegador) e IDE (a IA editava o
    script e o aluno aceitava o diff). O modo IDE foi REMOVIDO: exigia um editor
    com IA embutida, criava um segundo conjunto de instrucoes para tudo e era a
    unica parte do curso que pedia ao aluno para abrir um arquivo .py.
    Agora existe um caminho unico, que funciona com QUALQUER IA de chat:
        o script escreve o prompt -> voce cola na IA -> cola a resposta INTEIRA
        na 'Caixa de entrada' do quadro -> o script distribui nos cartoes.
    O aluno NUNCA edita codigo.

CONVENCAO (a espinha do curso): todo prompt declara DE ONDE ele come, com
parametros [INPUT x] — e x e o CARTAO (ou a lista) do quadro do aluno:
    [INPUT 1.1] a justificativa · [INPUT 1.2] o OKR · [INPUT 2.1] as entregas ...
    [INPUT ESCOPO] a EAP/Backlog · [INPUT RISCOS] · [INPUT PARTES] · [INPUT QUADRO]
O quadro.resolver_inputs() le esses cartoes e devolve o prompt PRONTO. O aluno
NUNCA copia o conteudo de um cartao para dentro de um prompt: a informacao ja
esta no quadro, e quem le o quadro e o script (Eduardo, 2026-07-14).

CONVENCAO 2 (nao mude sem ler isto): os campos que a IA preenche no FORMATO DA
RESPOSTA vao entre CHAVES — {assim} — e NUNCA entre <angulos>. O cartao do
ProjectAdm renderiza a descricao como HTML: um <quem> vira uma tag desconhecida,
some da tela e o navegador despeja os fechamentos no fim do cartao
("</quem></quando></numero>..."). Chaves sao texto puro em HTML e a IA entende
igual. Angulo, so em prosa (e escapado).
"""
import re

PAPEL_PT = ("Voce e um gerente de projetos experiente, apoiado no Guia PMBOK 8a "
         "edicao (6 principios, 7 dominios de desempenho, abordagens de "
         "desenvolvimento preditiva, hibrida e adaptativa/agil).")

# ─────────────────────────────────────────────────────────────────────────────
# Passo 1 — Iniciar o projeto (5W2H). A corrente comeca aqui.
#   O aluno escreve a JUSTIFICATIVA (nao ha prompt para isso: e a voz dele).
#   Depois, 5 prompts encadeados preenchem o Termo de Abertura.
# ─────────────────────────────────────────────────────────────────────────────
_CORPOS_PT = {
    # 1.1 — POR QUE (justificativa -> objetivo + Key Results)
    "okr": {
        "alvo": "a lista OBJETIVOS (cada objetivo com os seus KEY RESULTS)",
        "script": "01_iniciar_projeto.py",
        "passo": 1,
        "corpo": (
            "Vou colar a JUSTIFICATIVA do meu projeto (a dor de hoje e o valor que "
            "quero gerar). Com base NELA — sem inventar contexto que eu nao dei — "
            "recomende os OBJETIVOS deste projeto (OKR). Quantos objetivos o projeto "
            "pedir: a maioria dos projetos tem mais de um. Nao force um numero — se a "
            "minha justificativa sustenta tres objetivos, sao tres; se ela so sustenta "
            "um, e um, e voce me diz por que. "
            "Cada objetivo e qualitativo, curto, inspirador e diz ONDE quero chegar "
            "(nao COMO). "
            "Para CADA objetivo, de 2 a 5 Key Results. Cada Key Result e um resultado "
            "observavel: especifico, mensuravel (numero + unidade), realista — e mede "
            "o RESULTADO, nunca a tarefa ('reduzir o tempo de resposta de 5 para 2 "
            "dias', nao 'implantar o sistema'). "
            "Sempre que possivel, escreva a meta como 'de X para Y' (o X = o ponto de "
            "partida: a situacao de hoje, a mesma insatisfacao da justificativa -> o alvo "
            "Y aonde quero chegar): carrega mais informacao que uma variacao percentual "
            "('reduzir o churn de 3,2% para 2,7%', melhor que 'reduzir o churn em 15%'). O "
            "ponto de partida (o X) e RECOMENDADO, nao obrigatorio: quando e a PRIMEIRA "
            "VEZ que se faz algo, nao existe ponto de partida — ai escreva so o alvo "
            "('chegar a Y'). "
            "Um Key Result NAO tem responsavel nem prazo — e so o resultado e a meta. "
            "QUEM faz e QUANDO entra nas ENTREGAS e nas TAREFAS (o cronograma e a "
            "execucao), nao no KR. "
            "Para a META de cada KR, siga esta ordem: (1) se a justificativa der base "
            "para um numero firme, use-o; (2) se der base para uma ESTIMATIVA, mas "
            "ainda sem historico que a confirme, escreva 'meta provisoria: <numero + "
            "unidade>' e, na secao de raciocinio depois do '---', diga em UMA linha "
            "COMO voce chegou a ela (a premissa ou a referencia que usou) e APOS QUE "
            "MARCO ela deve ser revista (ex.: apos a 1a turma); (3) se nao houver base "
            "nenhuma, NAO invente: diga o que falta medir. Prefira sempre a meta "
            "provisoria a um numero sem lastro — mas deixe claro para mim que ela e "
            "provisoria, de onde saiu, e que sou eu quem precisa confirma-la. "
            "\n\nA MINHA JUSTIFICATIVA (cartao 1.1 do meu quadro):\n[INPUT 1.1]"
        ),
    },
    # 1.2 — O QUE (objetivo + KRs -> entregas)
    "entregas": {
        "alvo": "a lista ENTREGAS",
        "script": "01_iniciar_projeto.py",
        "passo": 1,
        "corpo": (
            "Vou colar os objetivos e os Key Results do meu projeto. Com base NELES, "
            "recomende as ENTREGAS principais — o que precisa EXISTIR (produto, "
            "servico ou resultado) para que os KRs sejam atingidos. De 3 a 7 entregas, "
            "cada uma um substantivo (um resultado, nao uma atividade: 'Politica de "
            "compras publicada', nao 'Escrever a politica'). Para cada uma: a qual KR "
            "ela serve (pelo numero — KR 1.2, KR 2.1), 1 requisito essencial e 1 "
            "criterio de aceitacao verificavel (como saberei que ficou pronta). "
            "Nenhum Key Result pode ficar sem pelo menos uma entrega que o alcance: se "
            "sobrar KR sem entrega, me avise. "
            "\n\nOS MEUS OBJETIVOS E KEY RESULTS (cartao 1.2):\n[INPUT 1.2]"
        ),
    },
    # 1.3 — QUEM (entregas -> partes interessadas)
    "partes": {
        "alvo": "a lista PARTES",
        "script": "01_iniciar_projeto.py",
        "passo": 1,
        "corpo": (
            "Vou colar o objetivo e as entregas do meu projeto. Com base NELES, "
            "recomende as PARTES INTERESSADAS — quem e afetado pelo projeto ou pode "
            "afeta-lo. Classifique cada uma em UM grupo: \"cliente\" (quem recebe o "
            "valor), \"equipe\" (quem faz) ou \"demais\" (quem influencia, aprova, "
            "regula ou e impactado). Marque explicitamente quem e o PATROCINADOR "
            "(quem autoriza e banca o projeto) — se nao der para deduzir, escreva "
            "\"[definir]\". Para cada parte: o que ela ESPERA do projeto e o que ela "
            "pode fazer PELO ou CONTRA o projeto (poder e interesse em alto/medio/baixo). "
            "Para os membros da EQUIPE (quem FAZ o trabalho), de o nome ou o papel REAL de "
            "quem entrega — a pessoa ou funcao concreta (ex.: \"Ana — edicao de video\", "
            "\"Henry — infra e ProjectAdm\"), nunca um grupo vago (\"equipe de suporte\"): "
            "e a esses nomes que o passo 4 vai atribuir o responsavel de cada pacote de "
            "trabalho, entao cada membro da equipe precisa ser alguem que de fato entrega algo. "
            "\n\nOS MEUS OBJETIVOS (cartao 1.2):\n[INPUT 1.2]\n\nAS MINHAS ENTREGAS (cartao 2.1):\n[INPUT 2.1]"
        ),
    },
    # ── PMBOK 8 Together, PROCESSO 2 — "Identificar as partes interessadas" ──────────
    #
    # POR QUE ESTE PROMPT EXISTE (Eduardo, 14/08/2026)
    # O Termo de Abertura ja' tem um elo de partes interessadas (o elo 3, acima), e o
    # Processo 2 dos 40 e' inteirinho sobre partes interessadas. Parecia repeticao —
    # "nao faz sentido eu voltar a mesma pergunta no passo 2".
    #
    # Nao e' repeticao, e quem resolve isso e' o proprio Guia: o Termo de Abertura e'
    # ENTRADA do processo 2.5.2.1. Sao duas ALTITUDES da mesma informacao, e a ordem ja'
    # esta certa. Entao o Processo 2 nao pergunta de novo: ele pergunta O QUE FALTA.
    #
    #   elo 3 do Termo      QUEM esta no projeto — quem ele precisa
    #   PROCESSO 2          QUEM MAIS — quem o projeto AFETA e ninguem chamou
    #   PROCESSO 24         onde cada um esta, aonde precisa estar, e como leva-lo la'
    #
    # A resposta volta no bloco ADITIVO [3+]: ela ACRESCENTA ao cartao 3 em vez de
    # substitui-lo (quadro.distribuir_caixa_entrada). Colar o delta como [3] apagaria as
    # partes que o Termo ja' tinha.
    "partes_completar": {
        "alvo": "a lista PARTES (acrescenta) e o cartao 3 do termo",
        "script": "01_iniciar_projeto.py",
        "passo": 1,
        "corpo": (
            "Vou colar as partes interessadas que o meu projeto JA identificou, com os "
            "meus objetivos e as minhas entregas. NAO repita ninguem que ja esta na "
            "minha lista e NAO reescreva quem ja esta la: essas pessoas ja foram "
            "identificadas e ja estao no meu quadro. "
            "O seu trabalho aqui e OUTRO: encontrar QUEM FALTA. "
            "A minha lista nasceu da pergunta 'quem o projeto PRECISA'; agora a pergunta "
            "e 'quem o projeto AFETA' — e e por isso que costuma faltar gente. "
            "Percorra estas seis frentes, uma a uma, e me diga quem falta em cada: "
            "(1) quem APROVA ou libera — patrocinador, comite, quem assina o orcamento; "
            "(2) quem REGULA ou fiscaliza — juridico, compliance, auditoria, orgao "
            "regulador, protecao de dados; "
            "(3) quem e IMPACTADO e nao pediu nada — quem vai OPERAR o resultado depois "
            "da entrega, o cliente final, a area vizinha que herda o trabalho; "
            "(4) quem FORNECE — fornecedor, parceiro, prestador, area interna de quem eu "
            "dependo; "
            "(5) quem pode ser CONTRA — quem perde alguma coisa se este projeto der "
            "certo (essa pessoa existe em quase todo projeto e quase nunca esta na "
            "primeira lista); "
            "(6) quem SUSTENTA depois — suporte, manutencao, quem atende quando quebrar. "
            "Se uma frente nao tiver ninguem novo, apenas pule — nao invente nome para "
            "preencher. "
            "Para cada parte NOVA: o grupo (\"cliente\", \"equipe\" ou \"demais\"), o "
            "papel dela no projeto, o que ela espera, e poder e interesse em "
            "alto/medio/baixo. "
            "Se na minha lista o PATROCINADOR estiver como \"[definir]\" ou nao houver "
            "nenhum marcado, diga quem deveria ser e por que — essa e a lacuna mais cara "
            "de todas. "
            "Se NINGUEM faltar, nao me devolva o formato: escreva so uma linha dizendo "
            "que a lista esta completa, e por que voce acha isso."
            "\n\nAS PARTES INTERESSADAS QUE EU JA TENHO:\n[INPUT PARTES]"
            "\n\nOS MEUS OBJETIVOS (cartao 1.2):\n[INPUT 1.2]"
            "\n\nAS MINHAS ENTREGAS (cartao 2.1):\n[INPUT 2.1]"
        ),
    },
    # 1.5 — COMO (o detalhe): restricoes, premissas, riscos iniciais e ONDE
    #   O ONDE mora AQUI porque ele E parte do como: onde o trabalho acontece e ate
    #   onde ele vai depende de como voce vai conduzi-lo. E o Guia PMBOK 8 lista o
    #   "Where will it occur?" entre as perguntas do termo de abertura.
    "restricoes_premissas_riscos": {
        "alvo": "as listas RESTRICOES, PREMISSAS e RISCOS_INICIAIS e a variavel ONDE",
        "script": "01_iniciar_projeto.py",
        "passo": 1,
        "corpo": (
            "Vou colar o meu projeto e a ABORDAGEM que eu escolhi. Complete o detalhe do "
            "'Como?' do termo de abertura com o que ja da para saber HOJE — nivel de "
            # "nos passos 2 a 4" (intervalo) saiu: no curso de 40 os numeros nao sao
            # contiguos e "processos 5 a 9" incluiria processos que nao detalham isto.
            # O filtro de vocabulario recusa intervalos de proposito — ver catalogo.
            "abertura, nao de planejamento (o detalhe vem nos passos seguintes). "
            "RESTRICOES: os limites impostos DE FORA e que eu nao negocio "
            "dentro do projeto — prazo, orcamento, norma, tecnologia, contrato, pessoas. "
            "PREMISSAS: o que eu estou ASSUMINDO como verdade sem ter certeza "
            "('o fornecedor entrega em 30 dias'). Escreva cada uma de forma que de para "
            "checar depois se caiu — porque premissa que cai vira risco. "
            "RISCOS INICIAIS: de 3 a 6 riscos de alto nivel, na forma CAUSA -> EVENTO -> "
            "IMPACTO ('porque a equipe e nova na ferramenta, a configuracao pode atrasar, "
            "empurrando a primeira entrega'); probabilidade e impacto em alta/media/baixa; "
            "resposta preliminar = a acao concreta. Inclua ao menos um risco que venha "
            "diretamente de uma premissa que voce listou. "
            "ONDE: onde o trabalho acontece e ate onde ele vai — area, unidade, sistema, "
            "regiao, presencial ou remoto — e, principalmente, o que fica de FORA (2 a 4 "
            "linhas). O onde e parte do COMO: ele muda conforme a maneira de conduzir o "
            "projeto. Se eu ainda nao souber, diga isso com todas as letras em vez de "
            "inventar — eu decido no momento certo. "
            "So o suficiente para alguem decidir se AUTORIZA o projeto. "
            "\n\nO MEU PROJETO (cartoes 1.1, 1.2, 2.1 e 3):\n[INPUT 1.1]\n[INPUT 1.2]\n[INPUT 2.1]\n[INPUT 3]\n\nA ABORDAGEM QUE EU ESCOLHI (cartao 4.1):\n[INPUT 4.1]"
        ),
    },
    # 1.6 — QUANDO e QUANTO (preliminares) — DEPOIS do como, porque e ele que os define
    "quando_quanto": {
        "alvo": "as variaveis MARCOS e ORDEM_DE_GRANDEZA",
        "script": "01_iniciar_projeto.py",
        "passo": 1,
        "corpo": (
            "Vou colar o meu projeto ate aqui, JA COM A ABORDAGEM ESCOLHIDA. Agora "
            "responda as duas ultimas perguntas do termo de abertura, EM NIVEL "
            "PRELIMINAR (no passo 4 eu detalho com numero; aqui e ordem de grandeza) — e "
            "responda-as NA FORMA DA MINHA ABORDAGEM, porque e o COMO que define como se "
            "calcula o QUANDO e o QUANTO: "
            "(a) MARCOS — de 3 a 6 marcos preliminares, com prazos RELATIVOS ao inicio "
            "('Semana 4', 'Mes 2'), porque eu ainda nao tenho cronograma. Se a minha "
            "abordagem for PREDITIVA, os marcos sao as entregas concluidas; se for AGIL, "
            "pense em quando sai o primeiro incremento util e na cadencia (a data tende a "
            "ser fixa e o escopo a flutuar). "
            "(b) QUANTO — uma estimativa grosseira do custo, dizendo em que ela se baseia "
            "e qual a margem (ex.: 'R$ 20 a 30 mil — 2 pessoas x 3 meses; margem "
            "-25%/+50%'). Na abordagem AGIL, raciocine pelo custo do time por Sprint (ele "
            "tende a ser fixo; o que varia e quanto valor cabe dentro dele). "
            "Se faltar informacao, diga o que voce assumiu, em vez de fingir precisao. "
            "\n\nO MEU PROJETO (cartoes 1.2 e 2.1):\n[INPUT 1.2]\n[INPUT 2.1]\n\nA ABORDAGEM QUE EU ESCOLHI (cartao 4.1):\n[INPUT 4.1]\n\nRESTRICOES, PREMISSAS E RISCOS INICIAIS (cartoes 4.2, 4.3 e 4.4):\n[INPUT 4.2]\n[INPUT 4.3]\n[INPUT 4.4]"
        ),
    },
    # 1.4 — COMO (a decisao) — a abordagem de desenvolvimento: o coracao do redesenho
    "abordagem": {
        "alvo": "a variavel ABORDAGEM (e a sua justificativa)",
        "script": "01a_escolher_abordagem.py",
        "passo": 1,
        "corpo": (
            "Vou colar o meu projeto e as minhas notas nos 5 eixos que decidem a "
            "ABORDAGEM DE DESENVOLVIMENTO — o meio usado para criar e evoluir o produto "
            "ao longo do ciclo de vida (Guia PMBOK 8). Me de a sua SEGUNDA OPINIAO, em "
            "3 partes curtas: "
            "(a) RECOMENDACAO: PREDITIVA ou AGIL (uma palavra); "
            "(b) POR QUE: 2 ou 3 razoes ligadas as MINHAS notas — cite o eixo, nao "
            "teoria generica; "
            "(c) O QUE OBSERVAR: 2 sinais de que eu deveria pegar emprestado da outra "
            "abordagem (o hibrido nasce assim, na pratica). "
            "Regra de bolso do Guia: requisitos claros e estaveis -> preditiva; "
            "requisitos incertos e feedback frequente valioso -> agil (a familia que o "
            "Guia chama de adaptativa). "
            "DISCORDE de mim se as minhas notas disserem outra coisa — mas nao decida "
            "por mim: quem escolhe sou eu. "
            "\n\nO MEU PROJETO (cartoes 1.1, 1.2 e 2.1):\n[INPUT 1.1]\n[INPUT 1.2]\n[INPUT 2.1]\n\nO MEU DIAGNOSTICO (as 5 notas que eu dei):\n[INPUT DIAGNOSTICO]"
        ),
    },

    # ── Passo 2 — Escopo (a mesma pergunta O QUE, em duas formas) ─────────────
    "escopo_preditiva": {
        "alvo": "a lista EAP",
        "script": "02_escopo.py",
        "passo": 2,
        "corpo": (
            "Vou colar as entregas do meu termo de abertura. Decomponha-as em uma EAP "
            "(Estrutura Analitica do Projeto). Se o meu projeto tiver FASES — etapas do "
            "ciclo de vida que terminam com a conclusao de uma ou mais entregas (ex.: "
            "Preparacao -> Execucao -> Encerramento) —, organize a EAP em TRES niveis: "
            "FASE (nivel 1) > ENTREGA (nivel 2) > PACOTE DE TRABALHO (nivel 3); o Guia "
            "PMBOK 8 recomenda usar as fases do ciclo de vida como um nivel da "
            "decomposicao, com as entregas abaixo. Se o projeto NAO tiver fases naturais, "
            "pule as fases e faca DOIS niveis: ENTREGA > PACOTE. "
            "O pacote de trabalho e o menor pedaco que da para estimar, atribuir a alguem "
            "e verificar como pronto. Regras: 100% do escopo e so o escopo (nada que nao "
            "sirva a uma entrega); o nome da fase, da entrega e do pacote e um SUBSTANTIVO "
            "(um resultado: 'Fornecedores homologados'), nunca um verbo; de 2 a 6 pacotes "
            "por entrega; cada pacote com 1 criterio de aceitacao verificavel. "
            "NAO estime prazo, esforco nem custo aqui: o escopo responde ao O QUE (as "
            "fases, as entregas e os pacotes); o QUANTO TEMPO e o QUANTO CUSTA entram no "
            "passo 4. "
            "\n\nAS MINHAS ENTREGAS (cartao 2.1):\n[INPUT 2.1]\n\nOS REQUISITOS DELAS (cartao 2.2):\n[INPUT 2.2]"
        ),
    },
    "escopo_agil": {
        "alvo": "a lista BACKLOG",
        "script": "02_escopo.py",
        "passo": 2,
        "corpo": (
            "Vou colar a justificativa, os objetivos e as entregas do meu termo de "
            "abertura. Transforme-as em uma META DO PRODUTO e um PRODUCT BACKLOG. "
            "COMECE PELA META DO PRODUTO. Pelo Guia Scrum, cada artefato tem um "
            "COMPROMISSO, e o compromisso do Product Backlog e a META DO PRODUTO: o "
            "estado futuro do produto que da sentido a ORDEM do backlog. Sem ela o "
            "backlog e uma lista de desejos — com ela, todo item responde a uma unica "
            "pergunta: 'isto me aproxima da meta?'. Regras da Meta do Produto: UMA frase "
            "(no maximo duas linhas); descreve um ESTADO alcancado, nunca uma atividade "
            "('X em operacao', nao 'implantar X'); e alcancavel dentro do horizonte "
            "deste projeto e verificavel pelos Key Results do cartao 1.2 — e a meta que, "
            "atingida, permite ENCERRAR o projeto; e uma so' de cada vez. Ela NAO repete "
            "o objetivo: o objetivo diz por que o projeto existe, a Meta do Produto diz "
            "o que tera de ser verdade sobre o PRODUTO no fim. "
            "Depois dela, os itens. Pelo Guia PMBOK 8, o backlog "
            "de produto e 'uma lista dinamica e priorizada de itens de trabalho e "
            "funcionalidades', focada em RESULTADOS ORIENTADOS POR VALOR; e uma HISTORIA "
            "DE USUARIO, no proprio Guia, e 'uma descricao breve de um RESULTADO sob a "
            "perspectiva de uma PARTE INTERESSADA'. Logo, cada item do backlog e um "
            "RESULTADO que uma parte interessada passa a ter — NAO uma funcionalidade de "
            "sistema. "
            "REGRA QUE MUDA TUDO: este projeto NAO e, por padrao, desenvolvimento de "
            "software. Olhe a MINHA justificativa (cartao 1.1) para saber o que estamos "
            "construindo. O 'o que' de cada item e um resultado REAL que a parte "
            "interessada vive (ex.: um habito adotado, uma rotina em pratica, um evento "
            "realizado, um espaco entregue, uma decisao tomada), NUNCA uma tela, um botao "
            "ou uma funcao de sistema. Só escreva o 'o que' como funcionalidade de "
            "software SE a minha justificativa disser, com todas as letras, que o produto "
            "deste projeto e um sistema/aplicativo/plataforma com usuarios. Na duvida, "
            "descreva o resultado na vida real, nao a ferramenta. "
            "{FORMATO} "
            "Um item NUNCA pode perder valor, prioridade, tamanho e criterio de pronto — "
            "o Guia Scrum nao exige um formato fixo de escrita. "
            "Cada item leva: criterio(s) de aceitacao VERIFICAVEIS, em linguagem simples "
            "('como vou saber que esta pronto'); e pontos relativos (1, 2, 3, 5, 8, 13). "
            "Aplique o espirito do INVEST: cada item independente, valioso, estimavel, "
            "PEQUENO o bastante para caber numa iteracao (se nao couber, quebre) e "
            "verificavel. De 8 a 15 itens. TODO item tem de servir a META DO PRODUTO: se "
            "um item nao aproxima da meta, ele nao entra (ou a meta esta errada — diga "
            "qual dos dois). Priorize por VALOR e risco RUMO A META — o que entrega "
            "valor ou reduz incerteza mais cedo vem antes — e diga por que o primeiro e o "
            "primeiro.Entregue os itens JA NA ORDEM de prioridade (o primeiro e o mais "
            "prioritario) e de a cada um um CODIGO curto e estavel — B1, B2, B3... na "
            "ordem (B1 = o mais prioritario). Esse codigo e a alca do item: e por ele que "
            "os proximos passos (riscos, Sprints, execucao) vao se referir a este item. "
            "\n\nA MINHA JUSTIFICATIVA — O QUE ESTAMOS CONSTRUINDO (cartao 1.1):\n[INPUT 1.1]\n\nOS MEUS OBJETIVOS (cartao 1.2):\n[INPUT 1.2]\n\nAS MINHAS ENTREGAS E REQUISITOS (cartoes 2.1 e 2.2):\n[INPUT 2.1]\n[INPUT 2.2]"
        ),
    },

    # ── Passo 3 — Riscos ─────────────────────────────────────────────────────
    "riscos_preditiva": {
        "alvo": "as listas RISCOS, PREMISSAS e RESTRICOES",
        "script": "03_riscos.py",
        "passo": 3,
        "corpo": ("Vou colar o meu escopo (EAP) e o termo de abertura. Identifique o que pode dar errado — e o que pode dar MUITO certo. Escreva cada risco na forma CAUSA -> EVENTO -> IMPACTO (um risco nao e 'atraso': e 'porque depende de um fornecedor unico, o contrato pode atrasar, empurrando a entrega X'). Marque o tipo (ameaca ou oportunidade — inclua ao menos 1 oportunidade). A resposta e a acao concreta: para ameaca, evitar/mitigar/transferir/aceitar; para oportunidade, explorar/ampliar/compartilhar/aceitar — ligada a um pacote da EAP quando fizer sentido. TODO DONO deste passo — o dono da resposta de um risco (quem EXECUTA a acao) e o dono que confirma uma premissa — SO' pode ser uma das pessoas da lista A MINHA EQUIPE (no fim deste prompt), os membros do cartao 'EQUIPE — quem faz'. Escreva o nome EXATAMENTE como aparece nessa lista; e PROIBIDO usar qualquer nome fora dela (cliente, patrocinador, area, fornecedor ou nome inventado); se ainda nao der para saber, escreva '[definir]'. De 5 a 10 riscos na secao RISCOS, do mais grave para o menos. Depois, na secao PREMISSAS, liste o que voce assume como verdade sem ter certeza (se cair, vira risco), cada uma com o dono (um membro da equipe) que a confirma; e na secao RESTRICOES, os limites impostos de fora (prazo, orcamento, norma, tecnologia). Use os cabecalhos RISCOS:, PREMISSAS: e RESTRICOES: exatamente assim. Premissa e restricao NAO tem probabilidade, impacto nem resposta. \n\nA MINHA EAP (lista do quadro):\n[INPUT ESCOPO]\n\nO TERMO DE ABERTURA (cartoes 1.1, 1.2 e 4.4):\n[INPUT 1.1]\n[INPUT 1.2]\n[INPUT 4.4]\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser dono de uma acao ou premissa (use SO' estes nomes, exatamente assim):\n[INPUT EQUIPE]"),
    },
    "riscos_agil": {
        "alvo": "as listas RISCOS, PREMISSAS e RESTRICOES",
        "script": "03_riscos.py",
        "passo": 3,
        "corpo": ('Vou colar o meu Product Backlog e o termo de abertura. Identifique o que pode dar errado — e o que pode dar MUITO certo — no formato adaptativo: risco tratado NO backlog, nao num documento paralelo. Escreva cada risco como CAUSA -> EVENTO -> IMPACTO e marque o tipo (ameaca ou oportunidade — inclua ao menos 1 oportunidade). A resposta e a acao concreta; quando a incerteza e de CONHECIMENTO (nao sei como fazer, nao sei se funciona), proponha um SPIKE: um item de investigacao com tempo fixo e um criterio claro do que a gente vai SABER no fim. TODO DONO deste passo — o dono da resposta de um risco (quem EXECUTA a acao) e o dono que confirma uma premissa — SO\' pode ser uma das pessoas da lista A MINHA EQUIPE (no fim deste prompt), os membros do cartao \'EQUIPE — quem faz\'. Escreva o nome EXATAMENTE como aparece nessa lista; e PROIBIDO usar qualquer nome fora dela (cliente, patrocinador, area, fornecedor ou nome inventado); se ainda nao der para saber, escreva \'[definir]\'. Ordene os mais graves primeiro — aprender cedo o que mata o projeto sobe na prioridade. De 5 a 10 riscos na secao RISCOS. Depois, na secao PREMISSAS, liste o que voce assume sem ter certeza (cada uma com o dono, um membro da equipe, que a confirma); e na secao RESTRICOES, os limites impostos de fora. Use os cabecalhos RISCOS:, PREMISSAS: e RESTRICOES: exatamente assim. Premissa e restricao NAO tem probabilidade, impacto nem resposta. \n\nO MEU PRODUCT BACKLOG (lista do quadro):\n[INPUT ESCOPO]\n\nO TERMO DE ABERTURA (cartoes 1.1, 1.2 e 4.4):\n[INPUT 1.1]\n[INPUT 1.2]\n[INPUT 4.4]\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser dono de uma acao ou premissa (use SO\' estes nomes, exatamente assim):\n[INPUT EQUIPE]'),
    },

    # ── Passo 4 — Quando e Quanto ────────────────────────────────────────────
    "cronograma_preditiva": {
        "alvo": "as listas CRONOGRAMA e ORCAMENTO",
        "script": "04_cronograma_orcamento.py",
        "passo": 4,
        "corpo": ('Vou colar a minha EAP, os meus riscos e a minha linha do tempo preliminar — que traz a DATA DE INICIO do projeto (cartao 5, Quando). Use essa data de inicio como a ANCORA do cronograma; NAO me peca a data de inicio — ela esta no INPUT 5, no fim deste prompt. (Se por acaso ela nao estiver preenchida ali, assuma o proximo dia util a partir de hoje e DECLARE essa suposicao na primeira linha da resposta — nunca pare para perguntar a data.) Para CADA pacote de trabalho, primeiro ESTIME a duracao em dias uteis (estimar a duracao e parte de montar o cronograma — no Guia PMBOK 8 a estimativa de duracao vive AQUI, em Desenvolver o Cronograma, e nao na definicao do escopo). Com base nessa duracao e nas dependencias, calcule as datas. As datas sao reais (AAAA-MM-DD), contando so dias uteis e respeitando as dependencias. Para CADA dependencia, escolha o TIPO certo (nem toda dependencia e Termino-a-Inicio): TI = Termino-a-Inicio (o padrao — a sucessora so comeca quando a predecessora TERMINA); II = Inicio-a-Inicio (as duas comecam juntas, ex.: comecar a registrar a presenca quando os encontros COMECAM); TT = Termino-a-Termino (terminam juntas); IT = Inicio-a-Termino (raro). Use II ou TT quando as tarefas correm em PARALELO — nao invente uma espera Termino-a-Inicio que nao existe. Diga qual e o CAMINHO CRITICO (a sequencia que, se atrasar, atrasa o projeto) e nao esconda folga dentro das tarefas: se precisar de reserva, declare-a como um item explicito. O RESPONSAVEL de cada pacote de trabalho SOMENTE pode ser uma das pessoas da lista A MINHA EQUIPE (no fim deste prompt) — sao os membros do cartao "EQUIPE — quem faz", e sao os UNICOS responsaveis validos no projeto inteiro. Regras, sem excecao: (a) cada pacote tem UM UNICO responsavel; (b) escreva o nome EXATAMENTE como aparece na lista A MINHA EQUIPE; (c) e PROIBIDO usar qualquer nome que nao esteja nessa lista — nada de cliente, patrocinador, area, papel generico ("time de TI"), fornecedor, nem pessoa inventada; (d) se nenhum membro da equipe servir a um pacote, escreva "[definir]" (nunca deixe em branco e nunca invente alguem). Distribua a carga entre os membros da equipe — nao concentre tudo numa pessoa. Todo pacote traz tambem o campo "entrega": o nome EXATO da entrega da EAP a que ele pertence. Se, ao estimar as duracoes, voce perceber que falta um pacote de trabalho na minha EAP — trabalho real que ninguem listou —, INCLUA esse pacote no cronograma com o campo "entrega" preenchido: isso e elaboracao progressiva (o detalhe aparece quando a gente chega perto), nao e erro, e e assim que eu sei em que entrega pendura-lo. NAO invente pacotes so para engordar o plano: so o que for trabalho de verdade que falta. No orcamento, LIGUE cada item de custo ao PACOTE DE TRABALHO da EAP que o consome (campo "pacote": o nome EXATO do pacote, igual ao cartao da EAP) — assim o custo pousa na entrega certa no Dicionario da EAP, em vez de virar uma lista solta. Apenas um custo do projeto INTEIRO (a reserva de contingencia, por exemplo) fica com "pacote: -". Inclua uma linha de RESERVA DE CONTINGENCIA proporcional aos riscos do passo 3. Compare o total com a ordem de grandeza que estimei no passo 1 e aponte a diferenca no ultimo item do orcamento. NAO inclua uma linha de TOTAL nem de SUBTOTAL no orcamento — cada item e um custo real (o total quem calcula e o meu script). \n\nA MINHA EAP (lista do quadro):\n[INPUT ESCOPO]\n\nOS MEUS RISCOS (lista do quadro):\n[INPUT RISCOS]\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser responsavel (use APENAS estes nomes, exatamente assim):\n[INPUT EQUIPE]\n\nA DATA DE INICIO E A LINHA DO TEMPO PRELIMINAR (cartao 5):\n[INPUT 5]'),
    },
    "roadmap_agil": {
        "alvo": "as listas SPRINTS e ORCAMENTO",
        "script": "04_cronograma_orcamento.py",
        "passo": 4,
        "corpo": ('Vou colar o meu Product Backlog priorizado (com pontos), o tamanho da Sprint e a capacidade do time. A DATA DE INICIO DA SPRINT 1 e MINHA decisao, e NAO a data de inicio do projeto: quem decide quando a Sprint comeca e o time, e o projeto pode ter comecado semanas antes. Se eu tiver escrito no cartao 5 (Quando), no fim deste prompt, uma data de inicio para a Sprint 1 ("Sprint 1 comeca em AAAA-MM-DD" ou parecido), use EXATAMENTE essa. Se eu nao tiver escrito nenhuma, assuma HOJE e declare essa suposicao em uma linha ANTES do formato — nunca pare para me perguntar a data. A data de inicio do PROJETO, se aparecer no cartao 5, e so contexto: nao a use como inicio da Sprint. Monte o roadmap por Sprints e o orcamento. Planeje so as 2 ou 3 primeiras Sprints com detalhe e deixe o resto grosso (elaboracao progressiva: o que esta longe muda). Respeite a capacidade — nao estufe a Sprint. No orcamento, a Sprint tem custo fixo (o time por Sprint; e o escopo que flutua) mais compras/licencas/servicos. Compare o total com a ordem de grandeza do passo 1 no ultimo item. NAO inclua uma linha de TOTAL nem de SUBTOTAL — cada item e um custo real (o total quem calcula e o meu script). \n\nO MEU PRODUCT BACKLOG, COM PONTOS E PRIORIDADE (lista do quadro):\n[INPUT ESCOPO]\n\nOS MEUS RISCOS (lista do quadro):\n[INPUT RISCOS]\n\nA DATA DE INICIO E A LINHA DO TEMPO PRELIMINAR (cartao 5):\n[INPUT 5]'),
    },

    # ── Passo 5 — Revisar e aprovar o plano ──────────────────────────────────
    # A revisao de COMPLETUDE do plano (ha entrega para cada KR? todo risco tem
    # prob/impacto/resposta/dono? todo pacote tem data e responsavel? o orcamento fecha?)
    # e' DETERMINISTICA: o python a faz sozinho, lendo o quadro (auditoria.py) — sem IA,
    # sem alucinar (uma IA que so' ve os titulos dos cartoes acusa buracos que nao existem
    # e inventa numeros). Por isso a PREDITIVA nao tem prompt de IA no Passo 5
    # (PASSO_PROMPT[5] = (None, ...)): rodar o passo AUDITA o plano e captura a linha de base.
    #
    # No AGIL, o Passo 5 e' a SPRINT PLANNING — o evento que abre a Sprint (Eduardo,
    # 2026-07-27: "o passo 5 da abordagem de desenvolvimento deveria ser o Sprint
    # Planning"). Aprovar o plano, no adaptativo, NAO e' assinar um documento: e' o time
    # se COMPROMETER com uma Meta de Sprint e com os itens que cabem nela. O prompt cobre
    # os TRES topicos que o Guia Scrum descreve no evento — (1) por que esta Sprint e'
    # valiosa (a Meta), (2) o que pode ser concluido (os itens), (3) como o trabalho sera
    # feito (as tarefas) — e mais a Definicao de Pronto, que e' do PROJETO e nao da Sprint.
    "revisar_plano_agil": {
        "alvo": "as variaveis DOD, META, ITENS e TAREFAS (a Sprint Planning)",
        "script": "05_aprovar_plano.py",
        "passo": 5,
        "corpo": (
            'O meu plano ja foi auditado pelo meu proprio script (completude: entregas, '
            'riscos, datas, orcamento) — nao preciso que voce confira isso. O que eu '
            'preciso de VOCE e conduzir comigo a SPRINT PLANNING da SPRINT {SPRINT}: o '
            'evento que ABRE a Sprint. Pelo Guia Scrum, a Sprint Planning responde a TRES '
            'perguntas, e eu quero as tres. '
            '\n\n(1) POR QUE esta Sprint e valiosa? -> a META DA SPRINT (Sprint Goal): UMA '
            'frase curta, um unico objetivo que da coerencia a tudo o que o time vai fazer. '
            'A Meta NAO e a lista de itens — e o RESULTADO que o time persegue; os itens sao '
            'o caminho. Se metade dos itens escolhidos nao servir a essa frase, a meta esta '
            'errada: reescreva a meta ou troque os itens. '
            'E a Meta da Sprint NAO nasce solta: ela e um PASSO em direcao a META DO PRODUTO '
            '(colada abaixo), que e o compromisso do Product Backlog. Diga, em uma linha, o '
            'quanto esta Sprint aproxima o produto dessa meta maior. Se voce nao conseguir '
            'ligar as duas, o problema nao e a frase — sao os itens escolhidos. '
            '\n\n(2) O QUE pode ser CONCLUIDO nesta Sprint? -> os ITENS do Product Backlog '
            'que entram, na ordem de prioridade que ele ja tem. Use o CODIGO do item (B1, '
            'B2...) e o titulo EXATAMENTE como estao no meu backlog — e proibido inventar '
            'item que nao esta la. NAO ESTUFE a Sprint: some os pontos e respeite a '
            'capacidade do time; se eu nao informei a capacidade, use como referencia os '
            'pontos que o time concluiu na Sprint anterior (a velocidade) e, se esta e a '
            'Sprint 1, seja conservador e me DIGA qual capacidade voce assumiu e por que. E '
            'melhor terminar 3 itens do que comecar 6. Um item so entra se (a) servir a Meta '
            'da Sprint e (b) tiver condicoes de atingir a Definicao de Pronto DENTRO desta '
            'Sprint — se nao tiver, deixe-o fora e me diga por que. '
            '\n\n(3) COMO o trabalho escolhido sera feito? -> as TAREFAS. Quebre CADA item '
            'selecionado nas tarefas necessarias para conclui-lo, cada uma pequena o '
            'bastante para caber em ATE UM DIA de trabalho. A tarefa e o COMO (pertence ao '
            'time); o item e o O QUE (pertence ao Product Owner). Cada tarefa aponta o '
            'codigo do item a que pertence e tem UM responsavel — e o responsavel SO pode '
            'ser uma das pessoas da lista A MINHA EQUIPE (no fim deste prompt), escrito '
            'EXATAMENTE como aparece la; e proibido usar qualquer nome fora dela; se ainda '
            'nao der para saber, escreva "[definir]". '
            '\n\nE a DEFINICAO DE PRONTO (DoD). Ela e do PROJETO INTEIRO, nao de um item e '
            'nao desta Sprint: sao as condicoes que QUALQUER incremento deste projeto cumpre '
            'para ser considerado concluido — cada uma verificavel por OUTRA PESSOA (nao '
            '"funciona", mas "foi revisado por outra pessoa e o registro esta no quadro"). E '
            'PROIBIDO citar um item especifico (B1, B2...) ou uma condicao que so faz sentido '
            'para um item: a validacao individual de CADA item ja mora no CRITERIO DE '
            'ACEITACAO dele, escrito no Passo 2 — se um criterio so serve a um item, ele NAO '
            'e DoD, e criterio de aceitacao, e nao entra aqui. De 4 a 8 condicoes. Se a minha '
            'DoD ja estiver colada abaixo, REPITA-A IDENTICA (ela nao muda a cada Sprint) e '
            'so proponha mudanca se algo do plano a tornou insuficiente — dizendo por que. '
            '\n\nUma ultima coisa: o roadmap de Sprints do Passo 4 e uma PREVISAO, feita '
            'quando eu sabia menos. A Sprint Planning e o COMPROMISSO, feito com o que eu sei '
            'HOJE. Se o quadro mostrar que a previsao nao se sustenta, siga o quadro e me diga '
            'o que mudou. '
            '\n\nA MINHA META DO PRODUTO — para onde este backlog inteiro caminha:\n[INPUT META_PRODUTO]'
            '\n\nO MEU PRODUCT BACKLOG PRIORIZADO (lista do quadro):\n[INPUT ESCOPO]'
            '\n\nA MINHA DEFINICAO DE PRONTO, SE EU JA A TIVER:\n[INPUT DOD]'
            '\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser responsavel (use APENAS '
            'estes nomes, exatamente assim):\n[INPUT EQUIPE]'
            '\n\nO MEU PLANO E A SITUACAO ATUAL DO QUADRO:\n[INPUT QUADRO]'),
    },

    # ── Passo 6 — Engajar as partes interessadas ─────────────────────────────
    "engajamento": {
        "alvo": "o plano de engajamento (na descricao de cada parte)",
        "script": "06_engajar_partes.py",
        "passo": 6,
        "corpo": ('Vou colar as minhas partes interessadas (com poder e interesse) e os meus objetivos. Projeto e gente: monte o plano de engajamento. Para cada parte, diga onde ela esta hoje e aonde precisa estar, numa destas cinco posturas (da menos para a mais engajada): desconhecido (nao sabe que o projeto existe ou ainda nao deu para classificar) / resistente / neutro / apoiador / lider. O "desconhecido" so faz sentido no estado ATUAL — o desejado nunca e deixar alguem sem saber do projeto. Depois, a estrategia concreta para leva-la de onde esta aonde precisa estar — alto poder + alto interesse: gerenciar de perto; alto poder + baixo interesse: manter satisfeito; baixo poder + alto interesse: manter informado; baixo/baixo: monitorar. Seja especifico: a estrategia e uma acao concreta e, quando fizer sentido, ja traz embutida a frequencia e o rito da conversa (ex.: "reuniao quinzenal de 15 min mostrando o KR2", nao "comunicar melhor") — sempre com um objetivo de DECISAO; nao proponha reuniao sem decisao. \n\nAS MINHAS PARTES INTERESSADAS (lista do quadro):\n[INPUT PARTES]\n\nOS MEUS OBJETIVOS (cartao 1.2):\n[INPUT 1.2]'),
    },

    # ── Passo 7 — Orientar e executar ────────────────────────────────────────
    "execucao_preditiva": {
        "alvo": "a lista PROXIMAS_ACOES",
        "script": "07_executar.py",
        "passo": 7,
        # O QUE MUDOU EM 2026-08-07: este prompt pedia a IA "diga o que fazer AGORA"
        # sobre uma foto GENERICA do quadro — e ela gastava metade da resposta deduzindo
        # o que ja estava escrito no cronograma (o que atrasou, quem tem o que). Agora o
        # proprio passo calcula isso ANTES (execution.py) e entrega pronto em
        # [INPUT SITUACAO_EXECUCAO]. Sobra para a IA a unica parte que os dados nao
        # respondem: o que fazer com as PESSOAS. E' a diferenca entre pedir um relatorio
        # e pedir uma decisao.
        "corpo": ('Vou colar a SITUACAO REAL DA EXECUCAO do meu projeto — LIDA do meu cronograma, nao estimada: o que ja atrasou (e ha quantos dias), o que vence no horizonte, quanto cada pessoa tem na mao e o que esta sem dono. Os numeros ja estao levantados: NAO os repita de volta para mim, e nao invente atividade que nao esta na lista. \n\nMe diga o que FAZER com isso, nesta ordem: (1) o que atacar primeiro, comecando pelo caminho critico e pelo que esta travando outra coisa; (2) para cada atraso relevante, a acao concreta que o tira do atraso — replanejar, dividir, pedir ajuda, renegociar a data com quem espera; (3) o que fazer com quem esta sobrecarregado e com quem esta ocioso (redistribuir e uma acao valida, e barata); (4) o que fazer com as atividades sem dono, se houver — porque ninguem executa o que nao e de ninguem. \n\nExecutar nao e so tocar tarefas: inclua ao menos 1 acao de PESSOAS (quem precisa de apoio, quem esta sobrecarregado, quem precisa de uma conversa). O Guia PMBOK chama isso de lideranca do gerente de projetos, e e a parte que mais falha. Seja concreto e curto: cada acao tem de caber numa linha e ter dono e data. \n\nA SITUACAO REAL DA MINHA EXECUCAO (lida do cronograma):\n[INPUT SITUACAO_EXECUCAO]\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser responsavel:\n[INPUT EQUIPE]\n\nO MEU PLANO E A SITUACAO ATUAL DO QUADRO:\n[INPUT QUADRO]'),
    },
    # No AGIL o Passo 7 e' a DAILY SCRUM — a inspecao diaria do progresso rumo a Meta da
    # Sprint. A Sprint Planning (a Meta, os itens e a primeira leva de tarefas) ja
    # aconteceu no Passo 5; aqui o time olha o quadro TODO DIA, decide o foco de hoje,
    # nomeia o que esta travando (impedimento) e cria as tarefas que apareceram no
    # caminho — porque o plano da Sprint e do time e muda todo dia.
    "execucao_agil": {
        "alvo": "as variaveis FOCO, IMPEDIMENTOS e TAREFAS (a Daily Scrum)",
        "script": "07_executar.py",
        "passo": 7,
        "corpo": (
            'Conduza comigo a DAILY SCRUM de hoje. Vou colar a Meta da Sprint, o Sprint '
            'Backlog com o status de cada cartao e o resto do quadro. A Daily NAO e reuniao '
            'de status para o gerente: e a inspecao, pelo proprio time, do progresso rumo a '
            'META DA SPRINT — e se a meta esta em risco, o plano de hoje MUDA. Timebox de 15 '
            'minutos: seja curto. '
            '\n\nMe devolva tres coisas. '
            '\n\n(1) FOCO — o que precisa acontecer HOJE para a Meta da Sprint continuar de '
            'pe. Comece pelo que esta mais perto de ficar PRONTO (pela Definicao de Pronto): '
            'terminar vale mais que comecar. Se ha cartao parado ha dias, aponte-o. '
            '\n\n(2) IMPEDIMENTOS — o que esta TRAVANDO o trabalho, com todas as letras: um '
            'impedimento e algo que impede o time de progredir e que ele nao resolve sozinho '
            '(uma espera, um acesso que falta, uma decisao que nao veio, uma pessoa '
            'indisponivel). Nao invente impedimento para preencher: se nao houver nenhum '
            'visivel no quadro, escreva "nenhum impedimento visivel no quadro hoje" e '
            'pronto. Para cada um, diga QUEM remove — e quem remove tambem sai da lista A '
            'MINHA EQUIPE. '
            '\n\n(3) TAREFAS — apenas as tarefas NOVAS que apareceram e ainda nao estao no '
            'quadro (o trabalho que so se enxerga fazendo). Nao repita tarefa que ja esta la. '
            'Se nao apareceu nenhuma, deixe a secao vazia. '
            '\n\nUma regra que nao se quebra: o que muda durante a Sprint e o COMO (as '
            'tarefas). O QUE (os itens do Sprint Backlog) e um compromisso do time com a '
            'Meta — item novo nao entra no meio da Sprint, vai para o Product Backlog e se '
            'discute no Passo 9. '
            '\n\nTODO responsavel citado SO pode ser uma das pessoas da lista A MINHA EQUIPE '
            '(no fim deste prompt), escrito EXATAMENTE como aparece la; se ainda nao der '
            'para saber, escreva "[definir]". '
            '\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser responsavel:\n[INPUT EQUIPE]'
            '\n\nA SITUACAO ATUAL DO QUADRO (a Meta da Sprint e o Sprint Backlog estao '
            'aqui):\n[INPUT QUADRO]'
            '\n\nA MINHA DEFINICAO DE PRONTO:\n[INPUT DOD]'),
    },

    # ── Passo 8 — Monitorar e Status Report ──────────────────────────────────
    "status_report": {
        "alvo": "as variaveis RESUMO, ALERTAS e DECISOES",
        "script": "08_status_report.py",
        "passo": 8,
        "corpo": ('Vou colar os DADOS REAIS do meu quadro: planejado x realizado, consumo do orcamento e riscos abertos. Escreva o Status Report para quem DECIDE, nao para quem executa. Comece pelo veredito e ponha o numero na frente da opiniao. Nos alertas, so o que muda uma decisao — nada de ruido. Nas decisoes, o que a diretoria/patrocinador precisa decidir, com as opcoes e o custo de cada uma. Se o projeto esta bem, diga em uma linha e nao invente problema; se um numero esta ruim, nao suavize — o Status Report existe para dar tempo de reagir. Ligue cada alerta ao Key Result que ele ameaca: reportar prazo e custo sem falar do valor prometido e reportar movimento, nao resultado. \n\nO QUE EU PROMETI — os meus objetivos e Key Results (cartao 1.2):\n[INPUT 1.2]\n\nOS DADOS DO MEU QUADRO (planejado x realizado):\n[INPUT QUADRO]'),
    },

    # No AGIL o Passo 8 e' a SPRINT REVIEW — o evento em que o time e as partes
    # interessadas INSPECIONAM o incremento e adaptam o backlog. Nao e uma apresentacao
    # de slides: e uma sessao de trabalho. O Status Report continua aqui (quem decide
    # precisa do numero na frente da opiniao), mas ele vira a SAIDA da Review, e nao um
    # relatorio paralelo. O veredito de "pronto" e' da Definicao de Pronto: item que nao
    # a atende NAO e' incremento — volta para o Product Backlog, sem meio-termo.
    "sprint_review": {
        "alvo": "as variaveis INCREMENTO, NAO_CONCLUIDO, FEEDBACK, RESUMO, ALERTAS e DECISOES",
        "script": "08_status_report.py",
        "passo": 8,
        "corpo": (
            'Conduza comigo a SPRINT REVIEW da SPRINT {SPRINT} — o evento que fecha o '
            'trabalho da Sprint com as partes interessadas. Vou colar a Meta da Sprint, o '
            'Sprint Backlog com o status de cada cartao, a minha Definicao de Pronto e os '
            'meus Key Results. '
            '\n\nPrimeiro, o VEREDITO ITEM A ITEM, e ele so tem duas respostas. Um item que '
            'atende a TODA a Definicao de Pronto e INCREMENTO: esta pronto, pode ser usado. '
            'Um item que nao atende a DoD — mesmo que falte pouco, mesmo que "quase" — NAO '
            'esta pronto: volta para o Product Backlog e sera repriorizado, e voce diz em uma '
            'linha o que faltou. Nao existe 80% pronto: essa e a transparencia que a DoD '
            'existe para criar. Use o codigo e o titulo EXATOS dos itens, como estao no meu '
            'quadro. '
            '\n\nDepois, a META DA SPRINT: ela foi atingida? Responda sim, parcialmente ou '
            'nao — e por que, com o numero na frente (quantos itens, quantos pontos). '
            '\n\nDepois, o PROGRESSO RUMO A META DO PRODUTO. Pelo Guia Scrum e isto que a '
            'Sprint Review inspeciona: nao "a Sprint fechou?", mas "o produto esta mais '
            'perto do que prometemos?". Diga onde estamos em relacao a meta (colada abaixo), '
            'com o numero que sustenta a frase, e se o ritmo atual chega la no horizonte do '
            'projeto. Se nao chega, diga isso agora — e nao na ultima Sprint. '
            '\n\nDepois, o FEEDBACK: o que as partes interessadas provavelmente vao querer '
            'discutir ao ver este incremento, e o que isso muda no Product Backlog. A Review '
            'existe para ADAPTAR o backlog — se nada muda nele, a conversa nao aconteceu. '
            '\n\nPor fim, o STATUS REPORT para quem DECIDE (patrocinador, diretoria), nas '
            'secoes RESUMO, ALERTAS e DECISOES: comece pelo veredito e ponha o numero na '
            'frente da opiniao; nos alertas, so o que muda uma decisao; nas decisoes, o que o '
            'patrocinador precisa decidir, com as opcoes e o custo de cada uma. Ligue cada '
            'alerta ao Key Result que ele ameaca: reportar Sprint fechada sem falar do valor '
            'prometido e reportar movimento, nao resultado. Se o projeto esta bem, diga em '
            'uma linha e nao invente problema; se um numero esta ruim, nao suavize. '
            '\n\nO QUE EU PROMETI — os meus objetivos e Key Results (cartao 1.2):\n[INPUT 1.2]'
            '\n\nA MINHA META DO PRODUTO — o compromisso que esta Review inspeciona:\n[INPUT META_PRODUTO]'
            '\n\nA MINHA DEFINICAO DE PRONTO:\n[INPUT DOD]'
            '\n\nOS DADOS DO MEU QUADRO (a Meta da Sprint, o Sprint Backlog e o que ja foi '
            'entregue):\n[INPUT QUADRO]'),
    },

    # ── Passo 9 — Controlar mudancas ─────────────────────────────────────────
    "mudanca_preditiva": {
        "alvo": "a lista ANALISE_MUDANCA",
        "script": "09_mudancas.py",
        "passo": 9,
        "corpo": ('Vou colar a solicitacao de mudanca que recebi e o meu plano aprovado. Analise o IMPACTO — sem julgar se a mudanca e boa ou ruim; o dono da decisao e o patrocinador. Uma linha para cada dimensao (escopo, prazo, custo, qualidade, riscos, partes). Depois a recomendacao com as opcoes e o que acontece se nada for feito. Toda mudanca aprovada muda a baseline: diga explicitamente o que a nova baseline passa a ser. \n\n[INPUT DETALHAR]\n\nA MUDANCA QUE ESTAO ME PEDINDO:\n[INPUT MUDANCA]\n\nO MEU PLANO APROVADO (baseline) E A SITUACAO ATUAL:\n[INPUT QUADRO]\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser responsavel:\n[INPUT EQUIPE]'),
    },
    "mudanca_agil": {
        "alvo": "a lista REPRIORIZACAO",
        "script": "09_mudancas.py",
        "passo": 9,
        "corpo": ('Vou colar o pedido novo, o meu Product Backlog priorizado e a Sprint em andamento. No agil a mudanca nao e um desvio: e o esperado — mas ela NAO entra no meio da Sprint (a Sprint e um compromisso; o que muda e a ordem do backlog). Diga onde o pedido entra, por que, e principalmente O QUE SAI ou desce para caber. A regua e a META DO PRODUTO (colada abaixo): o pedido novo aproxima ou afasta dela? E o que sai — sai porque aproxima menos. Se o pedido nao servir a meta, diga isso com todas as letras: ou ele fica de fora, ou a meta mudou (e ai o projeto virou outro). Se for grande a ponto de mudar a Visao do Produto, e um novo projeto; se for incerto, talvez vire um spike antes. E, ja que estamos mexendo no backlog, faca junto o REFINAMENTO dele (Product Backlog Refinement — no Guia Scrum nao e um evento com hora marcada, e uma ATIVIDADE CONTINUA: o backlog do topo tem de estar sempre pronto para a proxima Sprint Planning). No fim da recomendacao, aponte em ate 3 linhas o que precisa ser refinado ANTES da proxima Sprint: item grande demais para caber numa Sprint (quebre), item sem criterio de aceitacao claro (detalhe), item que ninguem sabe estimar (vire spike) ou item que perdeu o valor (descarte). Se o topo do backlog ja esta refinado, diga isso em uma linha e nao invente trabalho. \n\nO PEDIDO NOVO:\n[INPUT MUDANCA]\n\nA MINHA META DO PRODUTO — a regua da repriorizacao:\n[INPUT META_PRODUTO]\n\nO MEU PRODUCT BACKLOG E A SPRINT EM ANDAMENTO:\n[INPUT ESCOPO]\n[INPUT QUADRO]\n\n[INPUT DETALHAR]'),
    },

    # ── Passo 10 — Encerrar e verificar o valor ──────────────────────────────
    "encerramento": {
        "alvo": "as listas RESULTADO_OKR e LICOES",
        "script": "10_encerrar.py",
        "passo": 10,
        "corpo": ("Vou colar o OKR que defini no passo 1 e o que de fato aconteceu no que estou encerrando — pode ser o PROJETO INTEIRO ou apenas uma FASE dele (o Guia PMBOK 8 trata os dois no mesmo processo, 'Encerrar o Projeto ou Fase'). Na PRIMEIRA linha, diga se e o PROJETO ou uma FASE (e qual), inferindo do que o quadro mostra entregue. Encerrar nao e 'acabou': e verificar se o que foi prometido foi cumprido e deixar o proximo ciclo mais forte. "
                  "Se for o PROJETO: um item por Key Result, com o numero real e se foi atingido (sim/parcial/nao) e por que; se um beneficio so aparece depois (ex.: economia anual), diga QUANDO e QUEM vai medir — projeto que entrega produto mas nao entrega valor nao acabou, so parou. "
                  "Se for uma FASE: um item por ENTREGA da fase, conferida contra o seu criterio de aceitacao, dizendo o quanto ela avancou os Key Results ate aqui; e feche com um item de RECOMENDACAO para a proxima fase — SEGUIR / SEGUIR COM RESSALVAS / NAO SEGUIR (o go/no-go) — dizendo o que precisa estar pronto antes de comecar a proxima. "
                  "Depois, em qualquer caso, de 4 a 8 licoes acionaveis, metade do que deu certo (para repetir) e metade do que deu errado — validas para a proxima fase ou o proximo projeto. "
                  "\n\nOS MEUS OBJETIVOS E KEY RESULTS (cartao 1.2):\n[INPUT 1.2]\n\nO QUE O QUADRO DIZ QUE FOI ENTREGUE DE FATO:\n[INPUT QUADRO]"),
    },

    # No AGIL o Passo 10 tem DOIS usos, e o mesmo prompt cobre os dois porque a pergunta
    # e' a mesma em escalas diferentes: "o que prometi aconteceu, e o que levo daqui?".
    #   fim de SPRINT   -> a SPRINT RETROSPECTIVE: o evento que CONCLUI a Sprint. Depois
    #                      dela o ciclo volta ao Passo 5 (a Planning da Sprint seguinte).
    #   fim do PROJETO  -> o encerramento: realizado x Key Results do Passo 1.
    # A Retrospectiva olha para o COMO o time trabalhou (pessoas, processo, ferramentas),
    # nao para o produto — o produto foi inspecionado na Review (Passo 8). E ela nao
    # termina em desabafo: termina em ACOES de melhoria que entram na proxima Sprint.
    "retrospectiva_agil": {
        "alvo": "as variaveis ENCERRANDO, RESULTADO, LICOES e ACOES",
        "script": "10_encerrar.py",
        "passo": 10,
        "corpo": (
            'Vou colar o meu OKR do Passo 1 e o que de fato aconteceu no quadro. Estou '
            'fechando um ciclo — e ele pode ser de dois tamanhos. Na PRIMEIRA linha, escreva '
            'ENCERRANDO: seguido de "SPRINT {SPRINT}" (o normal: acabou a Sprint e vem a '
            'proxima) ou "PROJETO" (o produto ja entrega o valor prometido, ou o projeto vai '
            'parar aqui) — infira do quadro qual dos dois e, e diga em uma linha por que. '
            '\n\nSe for a SPRINT: conduza a SPRINT RETROSPECTIVE, o evento que CONCLUI a '
            'Sprint. Em RESULTADO, um item so: a Meta da Sprint — ela foi atingida? Depois, '
            'a retrospectiva propriamente dita, e aqui vale uma regra: a Review (Passo 8) '
            'olhou o PRODUTO; a Retrospectiva olha o COMO o time trabalhou — pessoas, '
            'relacoes, processo e ferramentas. Nao repita a conversa do produto. '
            '\n\nSe for o PROJETO: em RESULTADO, um item por Key Result, com o numero real e '
            'se foi atingido (sim/parcial/nao) e por que; se um beneficio so aparece depois '
            '(ex.: economia anual), diga QUANDO e QUEM vai medir — projeto que entrega '
            'produto mas nao entrega valor nao acabou, so parou. '
            '\n\nEm qualquer um dos dois casos, feche com duas coisas. LICOES: de 4 a 8, '
            'metade do que deu certo (para repetir) e metade do que atrapalhou. E ACOES: no '
            'MAXIMO 3 melhorias concretas — as mais impactantes, porque um time que promete '
            'dez melhorias nao faz nenhuma. Cada acao com um dono (um membro da lista A '
            'MINHA EQUIPE, escrito EXATAMENTE como aparece la) e com o sinal que vai mostrar '
            'que ela funcionou. Acao de melhoria e trabalho: ela entra no Sprint Backlog da '
            'proxima Sprint como qualquer outro item. Nada de "comunicar melhor" — isso nao '
            'e acao, e desejo. '
            '\n\nAntes das licoes, uma linha so: depois desta Sprint, o produto ficou mais '
            'perto da META DO PRODUTO (colada abaixo)? Se ENCERRANDO for PROJETO, a pergunta '
            'e mais dura: a meta foi ATINGIDA? Um projeto agil nao termina quando o backlog '
            'esvazia — termina quando a meta do produto foi alcancada. '
            '\n\nA MINHA EQUIPE — a lista FECHADA de quem pode ser dono de uma acao:\n[INPUT EQUIPE]'
            '\n\nOS MEUS OBJETIVOS E KEY RESULTS (cartao 1.2):\n[INPUT 1.2]'
            '\n\nA MINHA META DO PRODUTO:\n[INPUT META_PRODUTO]'
            '\n\nO QUE O QUADRO DIZ QUE ACONTECEU DE FATO:\n[INPUT QUADRO]'),
    },
}

# ─────────────────────────────────────────────────────────────────────────────
# O FORMATO DE RESPOSTA (modo CHAT) — e o que faz o aluno NUNCA editar codigo.
#
# A IA devolve TEXTO com rotulos entre colchetes ([1.2], [2.1]...). O aluno cola a
# resposta INTEIRA na "Caixa de entrada" da lista INPUTS do quadro; o script
# distribui cada bloco no cartao certo e le de la. O rotulo E o numero do cartao —
# que e a secao do Termo de Abertura — que e a secao do documento gerado no fim.
# Uma coisa so, do prompt ao .docx.
# ─────────────────────────────────────────────────────────────────────────────
_FORMATOS_PT = {
    "riscos_preditiva": (
        '[P3]\nRISCOS:\n• {a CAUSA leva a um EVENTO que gera um IMPACTO — nao escreva "atraso", escreva "porque depende de um fornecedor unico (causa), o contrato pode atrasar (evento), empurrando a entrega X (impacto)"}\n    tipo: ameaca|oportunidade\n    probabilidade: muito baixa|baixa|media|alta|muito alta · impacto: muito baixo|baixo|medio|alto|muito alto\n    resposta: {acao concreta} · dono: {o nome EXATO de UM membro da lista A MINHA EQUIPE — nunca outra pessoa; ou "[definir]"}\n• {proximo risco...}\nPREMISSAS:\n• {algo que voce assume como verdade sem ter certeza — se cair, vira risco}\n    dono: {o nome EXATO de UM membro da lista A MINHA EQUIPE que confirma; ou "[definir]"}\n• {proxima premissa...}\nRESTRICOES:\n• {um limite imposto de fora — prazo, orcamento, norma, tecnologia}\n• {proxima restricao...}'
    ),
    "riscos_agil": (
        '[P3]\nRISCOS:\n• {CAUSA -> EVENTO -> IMPACTO}\n    tipo: ameaca|oportunidade\n    probabilidade: muito baixa|baixa|media|alta|muito alta · impacto: muito baixo|baixo|medio|alto|muito alto\n    resposta: {acao concreta — quando a incerteza e de CONHECIMENTO, proponha um SPIKE: investigacao com tempo fixo, ex. "Spike: testar integracao com o ERP — 2 dias"} · dono: {o nome EXATO de UM membro da lista A MINHA EQUIPE — nunca outra pessoa; ou "[definir]"}\n• {proximo risco...}\nPREMISSAS:\n• {algo que voce assume como verdade sem ter certeza — se cair, vira risco}\n    dono: {o nome EXATO de UM membro da lista A MINHA EQUIPE que confirma; ou "[definir]"}\n• {proxima premissa...}\nRESTRICOES:\n• {um limite imposto de fora — prazo, orcamento, norma, tecnologia}\n• {proxima restricao...}'
    ),
    "cronograma_preditiva": (
        '[P4]\nCRONOGRAMA:\n• {o nome EXATO do pacote de trabalho, igual ao cartao da EAP}\n    duracao: {N} dias uteis · inicio: AAAA-MM-DD · fim: AAAA-MM-DD · depende de: {o nome EXATO do pacote que a condiciona, seguido do TIPO entre parenteses — (TI) padrao, (II), (TT) ou (IT); se for mais de um, separe por virgula; ou "-"} · responsavel: {o nome EXATO de UM membro da lista A MINHA EQUIPE — nunca outra pessoa; ou "[definir]"} · entrega: {o nome EXATO da ENTREGA da EAP a que este pacote pertence}\n• {proximo pacote...}\nORCAMENTO:\n• {item de custo}\n    tipo: pessoas|compra|servico|licenca|reserva · valor: {numero} · quando: {AAAA-MM} · pacote: {o nome EXATO do pacote de trabalho da EAP que consome este custo; ou "-" se for do projeto inteiro, como a reserva de contingencia}\n• {proximo item...}'
    ),
    "roadmap_agil": (
        '[P4]\nCRONOGRAMA:\n• {o item do Product Backlog EXATAMENTE como aparece no cartao — com o codigo na frente, ex.: "B1: Rotina de forca 2x/semana em pratica"}\n    sprint: {numero da Sprint em que ele entra} · inicio: AAAA-MM-DD · fim: AAAA-MM-DD\n• {proximo item — nas primeiras 2 ou 3 Sprints com detalhe; o resto do roadmap fica grosso}\nORCAMENTO:\n• {item de custo — inclua o custo do time por Sprint}\n    tipo: pessoas|compra|servico|licenca · valor: {numero} · quando: {AAAA-MM ou Sprint N}\n• {proximo item...}'
    ),
    "revisar_plano_agil": (
        '[P5]\nDOD:\n'
        '• {uma condicao que QUALQUER incremento deste projeto cumpre para ser "pronto" — '
        'verificavel por outra pessoa, e SEM citar nenhum item especifico}\n'
        '• {proxima condicao... (de 4 a 8)}\n'
        'META:\n'
        '{a Meta da Sprint {SPRINT} em UMA frase — por que esta Sprint e valiosa}\n'
        'ITENS:\n'
        '• {o codigo e o titulo EXATOS do item, como estao no meu Product Backlog, ex.: '
        '"B1: Rotina de treinos em pratica"}\n'
        '    pontos: {os pontos do item} · por que entra: {como ele serve a Meta da Sprint}\n'
        '• {proximo item selecionado — pare quando a soma dos pontos chegar a capacidade}\n'
        'TAREFAS:\n'
        '• {a tarefa — o COMO, pequena o bastante para caber em ate UM DIA de trabalho}\n'
        '    item: {o codigo do item a que ela pertence, ex. B1} · responsavel: {o nome '
        'EXATO de UM membro da lista A MINHA EQUIPE; ou "[definir]"} · estimativa: {horas '
        'ou "1 dia"}\n'
        '• {proxima tarefa...}'
    ),
    "engajamento": (
        '[P6]\n• {o nome EXATO da parte interessada, igual ao cartao da lista Partes}\n    atual: desconhecido|resistente|neutro|apoiador|lider  ->  desejado: resistente|neutro|apoiador|lider\n    estrategia: {a acao concreta para leva-la de onde esta aonde precisa estar, ja com a frequencia e o rito quando fizer sentido — "reuniao quinzenal de 15 min mostrando o KR2", nao "comunicar melhor"}\n• {proxima parte...}'
    ),
    "execucao_preditiva": (
        '[P7]\n• {a acao concreta — o proximo passo}\n    pacote: {a que pacote da EAP pertence} · responsavel: {quem} · ate: AAAA-MM-DD · desbloqueia: {o que trava se isto nao acontecer}\n• {proxima acao...}'
    ),
    "execucao_agil": (
        '[P7]\nFOCO:\n'
        '• {o que precisa acontecer HOJE para a Meta da Sprint continuar de pe}\n'
        '    item: {o codigo do item a que isso pertence, ex. B1} · responsavel: {o nome '
        'EXATO de UM membro da lista A MINHA EQUIPE; ou "[definir]"}\n'
        '• {proximo foco do dia — poucos, o dia e curto}\n'
        'IMPEDIMENTOS:\n'
        '• {o que esta TRAVANDO o trabalho — ou "nenhum impedimento visivel no quadro hoje"}\n'
        '    afeta: {o codigo do item travado, ex. B1} · quem remove: {o nome EXATO de UM '
        'membro da lista A MINHA EQUIPE}\n'
        '• {proximo impedimento, se houver}\n'
        'TAREFAS:\n'
        '• {SO as tarefas NOVAS que apareceram e ainda nao estao no quadro — se nao houver '
        'nenhuma, deixe esta secao vazia}\n'
        '    item: {o codigo do item, ex. B1} · responsavel: {o nome EXATO de UM membro da '
        'lista A MINHA EQUIPE} · estimativa: {horas ou "1 dia"}\n'
        '• {proxima tarefa nova...}'
    ),
    "status_report": (
        '[P8]\nRESUMO:\n{4 a 6 linhas: comece pelo VEREDITO (no rumo / atencao / critico) e so depois explique, sempre com o NUMERO na frente da opiniao — prazo, custo, escopo, valor/KRs}\nALERTAS:\n• {o alerta} | evidencia: {o numero/fato} | impacto se nao agir: {o que acontece}\n• {proximo alerta — so o que muda uma decisao}\nDECISOES:\n• {a decisao que eu preciso} | de quem: {quem decide} | ate: {quando} | opcoes: {as opcoes e o custo de cada uma}\n• {proxima decisao...}'
    ),
    "sprint_review": (
        '[P8]\nINCREMENTO:\n'
        '• {o codigo e o titulo EXATOS do item que atende a TODA a Definicao de Pronto — '
        'este esta pronto, ex.: "B1: Rotina de treinos em pratica"}\n'
        '• {proximo item pronto...}\n'
        'NAO_CONCLUIDO:\n'
        '• {o codigo e o titulo EXATOS do item que NAO atende a DoD — volta ao Product '
        'Backlog}\n'
        '    faltou: {o que falta para ele atingir a Definicao de Pronto}\n'
        '• {proximo item nao concluido...}\n'
        'META:\n'
        '{a Meta da Sprint foi atingida? sim|parcialmente|nao — e por que, com o numero na '
        'frente}\n'
        'FEEDBACK:\n'
        '• {o que as partes interessadas vao querer discutir ao ver este incremento}\n'
        '    muda no backlog: {o que entra, sai ou muda de prioridade por causa disso}\n'
        '• {proximo ponto de feedback...}\n'
        'RESUMO:\n'
        '{4 a 6 linhas: comece pelo VEREDITO (no rumo / atencao / critico) e so depois '
        'explique, sempre com o NUMERO na frente da opiniao — Sprint, escopo, custo, '
        'valor/KRs}\n'
        'ALERTAS:\n'
        '• {o alerta} | evidencia: {o numero/fato} | impacto se nao agir: {o que acontece}\n'
        '• {proximo alerta — so o que muda uma decisao}\n'
        'DECISOES:\n'
        '• {a decisao que eu preciso} | de quem: {quem decide} | ate: {quando} | opcoes: {as '
        'opcoes e o custo de cada uma}\n'
        '• {proxima decisao...}'
    ),
    "mudanca_preditiva": (
        '[P9]\nSOLICITACAO:\n{o que estao me pedindo, em 1 ou 2 linhas}\nIMPACTO:\n• escopo: {o que entra/sai}\n• prazo: {quantos dias, e se mexe no caminho critico}\n• custo: {quanto, e de onde sai o dinheiro}\n• qualidade: {o que muda}\n• riscos: {quais nascem ou crescem}\n• partes interessadas: {quem precisa concordar}\nRECOMENDACAO:\n{aprovar / aprovar com condicoes / rejeitar / adiar — e o que acontece se nada for feito; diga qual passa a ser a nova baseline se aprovada}'
    ),
    "mudanca_agil": (
        '[P9]\nSOLICITACAO:\n{o pedido novo que chegou}\nIMPACTO:\n• onde entra no backlog: {a prioridade nova}\n• por que: {valor, risco ou dependencia}\n• o que sai ou desce para caber: {porque capacidade e finita — se ninguem sai, a data muda}\n• muda a Visao do Produto? {se for grande demais, nao e repriorizacao, e um novo projeto}\nRECOMENDACAO:\n{entra na proxima Sprint / vira spike antes / fica no backlog — a Sprint em andamento NAO se mexe}'
    ),
    "encerramento": (
        '[P10]\nRESULTADO:\n• {para o PROJETO: um Key Result do passo 1; para uma FASE: uma entrega da fase} | meta: {a meta que voce definiu, ou o criterio de aceitacao da entrega} | realizado: {o numero/estado real} | atingido: sim|parcial|nao | por que: {a causa, com o numero}\n• {proximo item... — e, se estiver encerrando uma FASE, feche com o go/no-go abaixo}\n• Recomendacao para a proxima fase | realizado: SEGUIR|SEGUIR COM RESSALVAS|NAO SEGUIR | por que: {o que sustenta a decisao e o que precisa estar pronto antes} (SO no encerramento de FASE)\nLICOES:\n• {a licao} | o que aconteceu: {o fato} | o que eu faria diferente: {acionavel — "estimar com 3 pessoas em vez de 1", nao "comunicar melhor"} | serve para: {quem — ou "a proxima fase"}\n• {proxima licao — de 4 a 8, metade do que deu certo, metade do que deu errado}'
    ),
    "retrospectiva_agil": (
        '[P10]\n'
        'ENCERRANDO: {SPRINT {SPRINT} ou PROJETO — e, na mesma linha, por que}\n'
        'RESULTADO:\n'
        '• {na SPRINT: a Meta da Sprint. No PROJETO: um Key Result do Passo 1} | meta: {a '
        'meta} | realizado: {o numero/estado real} | atingido: sim|parcial|nao | por que: {a '
        'causa, com o numero}\n'
        '• {proximo item — so no encerramento do PROJETO, um por Key Result}\n'
        'LICOES:\n'
        '• {a licao — sobre COMO o time trabalhou} | o que aconteceu: {o fato} | o que eu '
        'faria diferente: {acionavel} | serve para: {quem}\n'
        '• {proxima licao — de 4 a 8, metade do que deu certo, metade do que atrapalhou}\n'
        'ACOES:\n'
        '• {a melhoria concreta que entra na proxima Sprint} | dono: {o nome EXATO de UM '
        'membro da lista A MINHA EQUIPE} | como saberei que funcionou: {o sinal observavel}\n'
        '• {proxima acao — no MAXIMO 3}'
    ),
    "okr": (
        "[1.2]\n"
        "OBJETIVO 1: {frase curta e qualitativa: onde quero chegar}\n"
        "KR 1.1: {resultado observavel} — meta: {numero + unidade; de preferencia 'de X para Y'}\n"
        "KR 1.2: {resultado observavel} — meta provisoria: {numero + unidade}\n"
        "OBJETIVO 2: {o proximo objetivo, se o projeto tiver}\n"
        "KR 2.1: {...}\n"
        "KR 2.2: {...}\n"
        "(quantos objetivos o projeto pedir; de 2 a 5 KRs em CADA objetivo. Use "
        "'meta provisoria:' so quando o numero for uma estimativa a confirmar)\n"
        "---\n"
        "COMO CHEGUEI AS METAS PROVISORIAS (uma linha por KR que marquei como provisorio):\n"
        "• para o KR 1.2: {como cheguei a esse numero — a premissa ou a referencia}; revisar apos {o marco que da o numero real, ex.: a 1a turma}\n"
        "• {proxima meta provisoria, se houver}"
    ),
    "entregas": (
        "[2.1]\n"
        "• {nome da entrega — um resultado, substantivo}\n"
        "    serve ao KR: {o numero do KR — KR 1.2, KR 2.1...}\n"
        "    requisito: {o requisito essencial}\n"
        "    criterio de aceitacao: {como saberemos que ficou pronta}\n"
        "• {proxima entrega...}"
    ),
    "partes": (
        "[3]\n"
        "• {nome ou papel} [cliente|equipe|demais]\n"
        "    papel: {o que essa pessoa faz no projeto — marque o PATROCINADOR aqui}\n"
        "    espera: {o que ela espera do projeto}\n"
        "    poder: alto|medio|baixo · interesse: alto|medio|baixo\n"
        "• {proxima parte...}"
    ),
    # [3+] e' ADITIVO: acrescenta ao cartao 3 em vez de substitui-lo. So' as partes NOVAS
    # entram aqui — quem ja' esta no quadro nao volta (ver o corpo de "partes_completar").
    "partes_completar": (
        "[3+]\n"
        "• {nome ou papel de quem FALTA} [cliente|equipe|demais]\n"
        "    papel: {o que essa pessoa faz no projeto — marque o PATROCINADOR aqui}\n"
        "    espera: {o que ela espera do projeto}\n"
        "    poder: alto|medio|baixo · interesse: alto|medio|baixo\n"
        "• {proxima parte que falta...}"
    ),
    "restricoes_premissas_riscos": (
        "[4.2]\n"
        "• {restricao: limite imposto de fora}\n\n"
        "[4.3]\n"
        "• {premissa: o que assumo como verdade sem ter certeza}\n\n"
        "[4.4]\n"
        "• {causa -> evento -> impacto}\n"
        "    probabilidade: muito baixa|baixa|media|alta|muito alta · impacto: muito baixo|baixo|medio|alto|muito alto\n"
        "    resposta: {acao concreta}\n"
        "• {proximo risco...}\n\n"
        "[4.6]\n"
        "{onde o trabalho acontece e ate onde vai — e o que fica de FORA}"
    ),
    "quando_quanto": (
        "[5]\n"
        "• {marco} — {quando: data ou 'Semana 4'}\n"
        "• {proximo marco...}\n\n"
        "[6]\n"
        "{ordem de grandeza do custo, com a base do calculo e a margem}"
    ),
    "abordagem": (
        "[4.1]\n"
        "RECOMENDACAO: {PREDITIVA ou AGIL}\n"
        "POR QUE:\n"
        "• {razao ligada a um eixo MEU (cite o eixo)}\n"
        "O QUE OBSERVAR:\n"
        "• {sinal de que eu deveria combinar elementos da outra abordagem}"
    ),
    "escopo_preditiva": (
        "[P2]\n"
        "FASE: {nome da fase — OMITA as linhas FASE: se o projeto nao tiver fases}\n"
        "ENTREGA: {nome da entrega — um resultado, substantivo}\n"
        "• {pacote de trabalho — um resultado, substantivo} — aceitacao: {criterio verificavel}\n"
        "• {proximo pacote da MESMA entrega...}\n"
        "ENTREGA: {proxima entrega da mesma fase}\n"
        "• {pacote...}\n"
        "FASE: {proxima fase, se houver}\n"
        "..."
    ),
    "escopo_agil": (
        "[P2]\n"
        "META DO PRODUTO: {UMA frase — o estado do produto que, atingido, permite "
        "encerrar este projeto. Nunca uma atividade}\n"
        "• B1: {o item do backlog, escrito na FORMA que eu defini no pedido — um resultado de valor por padrao, ex.: 'Rotina de forca 2x/semana em pratica'. NUNCA uma tela/funcao de sistema, a nao ser que a justificativa (1.1) diga que o produto e um software}\n"
        "    aceitacao: {como vou saber que esta pronto — criterios verificaveis, em linguagem simples}\n"
        "    pontos: {1, 2, 3, 5, 8 ou 13}\n"
        "• B2: {proximo item do backlog...}"
    ),
}


# A UNICA diferenca entre os tipos de IA: COMO a resposta chega ate o script.
#   CHAT = a IA devolve TEXTO -> o aluno cola no QUADRO -> o script le o quadro.
#          (o aluno nao abre um arquivo .py em nenhum momento)
_ENTREGAS_PT = {
    "CHAT": (
        "Voce NAO tem acesso aos meus arquivos nem ao meu quadro. DEVOLVA a resposta "
        "em TEXTO SIMPLES, exatamente no FORMATO abaixo — com os rotulos entre "
        "colchetes, que sao os numeros dos cartoes do meu quadro. Eu colo a sua "
        "resposta inteira na 'Caixa de entrada' do quadro e o meu script distribui "
        "cada bloco no cartao certo. NAO use bloco de codigo, NAO escreva nada fora do "
        "formato, NAO invente rotulos novos. Mantenha os rotulos exatamente como estao."
        "\n\nFORMATO DA RESPOSTA:\n{formato}\n"
    ),
}

# ─────────────────────────────────────────────────────────────────────────────
# Abordagem de desenvolvimento (a variavel do curso)
# ─────────────────────────────────────────────────────────────────────────────
ABORDAGENS = ("PREDITIVA", "AGIL")
ABORDAGEM_PADRAO = "PREDITIVA"
_SIN_ABORDAGEM = {
    "preditiva": "PREDITIVA", "preditivo": "PREDITIVA", "cascata": "PREDITIVA",
    "waterfall": "PREDITIVA", "pmo": "PREDITIVA", "predictive": "PREDITIVA",
    "agil": "AGIL", "ágil": "AGIL", "agile": "AGIL", "scrum": "AGIL",
    "adaptativa": "AGIL", "adaptativo": "AGIL", "adaptive": "AGIL",
}

# ─────────────────────────────────────────────────────────────────────────────
# COMO O ALUNO REPRESENTA CADA ITEM DO PRODUCT BACKLOG (so' na abordagem AGIL)
#
# A historia de usuario NAO e obrigatoria (o Guia Scrum nao exige formato fixo) e
# um projeto agil pode ser feito sem nenhuma. O aluno escolhe no 01a; a escolha vai
# para BACKLOG_FORMATO no .env e este texto entra no marcador {FORMATO} do prompt do
# Passo 2. Padrao = RESULTADO (o jeito mais simples, serve a qualquer projeto).
# ─────────────────────────────────────────────────────────────────────────────
BACKLOG_FORMATOS = ("RESULTADO", "HISTORIA", "MISTO")
BACKLOG_FORMATO_PADRAO = "RESULTADO"
_SIN_FORMATO = {
    "resultado": "RESULTADO", "resultados": "RESULTADO", "valor": "RESULTADO",
    "entrega": "RESULTADO", "substantivo": "RESULTADO", "1": "RESULTADO",
    "historia": "HISTORIA", "história": "HISTORIA", "historias": "HISTORIA",
    "user story": "HISTORIA", "usuario": "HISTORIA", "2": "HISTORIA",
    "misto": "MISTO", "mista": "MISTO", "hibrido": "MISTO", "híbrido": "MISTO",
    "ia": "MISTO", "ajuda": "MISTO", "3": "MISTO",
}

_FORMA_BACKLOG_PT = {
    "RESULTADO": (
        "FORMA: escreva CADA item como um RESULTADO de valor — um substantivo/resultado "
        "que passa a existir (ex.: 'Rotina de forca 2x/semana em pratica', 'Plano "
        "alimentar adotado', 'Espaco da casa adaptado'). NAO use historia de usuario "
        "('Como..., quero...'): um backlog inteiro de resultados e valido e completo."
    ),
    "HISTORIA": (
        "FORMA: escreva cada item como HISTORIA DE USUARIO — 'Como {a parte interessada "
        "que se beneficia}, quero {o resultado que ela passa a ter}, para {o valor}'. O "
        "'quero' e um resultado real na vida da pessoa, nunca uma funcao de sistema. Se "
        "um item ficar forcado nessa forma, escreva-o como resultado direto (substantivo) "
        "— nao distorca o item so' para caber no formato."
    ),
    "MISTO": (
        "FORMA: use a melhor forma para CADA item e me ajude a decidir. Por PADRAO "
        "escreva um RESULTADO de valor (substantivo). Use a historia de usuario 'Como "
        "{parte interessada}, quero {resultado}, para {valor}' SOMENTE quando houver uma "
        "parte interessada distinta cujo beneficio fica mais claro assim — e, nesses "
        "itens, deixe explicito para quem e o valor. Nunca torne a historia obrigatoria; "
        "na duvida, fique no resultado."
    ),
}


# ─────────────────────────────────────────────────────────────────────────────
# PASSO 9 — A MUDANCA QUE JA VEM DETALHADA (Eduardo, 2026-07-29)
#
#   "Permita ainda que eu possa fazer um prompt que a IA fara todo o detalhamento
#    incluindo o passo 3 (riscos) e o passo 4 (cronograma e orcamento). Permita-me
#    ajustar facilmente o prompt para remover a parte dos riscos e tambem do cronograma
#    ou do orcamento caso eu deseje."
#
# A ideia: uma mudanca aprovada nao e' so' um cartao dizendo "custa 12 dias". Ela TRAZ
# escopo novo — e escopo novo tem pacote, criterio de aceitacao, risco, data e custo,
# exatamente como no plano original. Em vez de o aluno voltar aos Passos 2, 3 e 4 (e
# regerar tudo o que ja estava bom), a IA detalha a MUDANCA — e so' ela.
#
# COMO ISSO NAO VIRA UM SEGUNDO PARSER: cada pedaco do detalhamento volta no MESMO
# formato do passo dono dele — o do Passo 2 para escopo, o do Passo 3 para riscos, o do
# Passo 4 para cronograma/orcamento. Muda so' o ROTULO do bloco: [P9.2], [P9.3], [P9.4].
# O ponto e' o ponto de "Passo 9, parte do Passo 2" — e mantem os blocos separados dos
# [P2]/[P3]/[P4] "de verdade", que reescreveriam o plano inteiro se caissem na caixa.
#
# ONDE ENTRA NA EAP: o codigo posicional. "apos: 2.1" quer dizer "irmao seguinte de
# 2.1" — o pai vem junto, de graca, porque e' o pai do 2.1. Assim uma frase resolve as
# duas perguntas (dentro de quem, e em que posicao), e a renumeracao e' consequencia.
# ─────────────────────────────────────────────────────────────────────────────
PARTES_MUDANCA = ("escopo", "riscos", "cronograma", "orcamento")

_INSTRUCAO_MUDANCA_PT = {
    "escopo": (
        "ESCOPO: detalhe o escopo NOVO que esta mudanca traz, e SO' ele — nunca repita o "
        "escopo que ja esta no meu quadro. Cada pacote de trabalho novo com o seu criterio "
        "de aceitacao. Diga ONDE cada coisa entra na minha EAP pelo campo `apos:` (o codigo "
        "do irmao depois do qual ela entra — o pai e' o mesmo do irmao) ou `dentro de:` (o "
        "codigo do pai, quando ela vai ser o primeiro filho). Se a mudanca criar uma FASE "
        "nova, use a linha FASE:.\n"
        # AS TRES REGRAS ABAIXO NASCERAM DE UM CASO REAL (Eduardo, projeto Ativalog,
        # 2026-07-29). O pedido era "duas fases de entrega, e um bloco por filial"; a IA
        # nao sabia que a minha EAP tem um numero FIXO de niveis, entao improvisou: repetiu
        # a MESMA entrega duas vezes para representar os dois lotes e pendurou as 24
        # atividades das 6 filiais nela. Como o script casa entrega pelo NOME, as duas
        # viraram uma so' — e o resultado foi uma lista plana de 28 pacotes, sem lote e sem
        # filial. A IA nao errou por falta de capacidade: errou por falta destas 3 regras.
        "     REGRA 1 — RESPONDA EM TRES NIVEIS: FASE > ENTREGA > PACOTE DE TRABALHO. Uma "
        "EAP pode ter mais niveis quando o projeto e' complexo, mas o formato desta "
        "resposta tem tres — e tres atendem a quase todo projeto. Se voce sentir falta de "
        "um quarto nivel, quase sempre e' porque agrupou errado: releia a REGRA 3. (O "
        "detalhe abaixo do pacote de trabalho NAO e' EAP: sao as ATIVIDADES, e elas entram "
        "no cronograma, no Passo 7 — nao aqui.)\n"
        "     REGRA 2 — CADA NOME E' UNICO na EAP inteira. Repetir o nome de uma FASE ou de "
        "uma ENTREGA que ja existe quer dizer 'acrescente estes pacotes AQUI DENTRO', e "
        "nunca 'crie outra igual'. Se voce quer dois grupos parecidos, eles PRECISAM ter "
        "nomes diferentes (ex.: 'Dormitorios do Lote 1' e 'Dormitorios do Lote 2').\n"
        "     REGRA 3 — QUANDO A MUDANCA PEDE AGRUPAMENTO (por lote, por etapa, por "
        "unidade, por local, por cliente), use os tres niveis assim: o AGRUPAMENTO vira a "
        "FASE; o RESULTADO de cada unidade vira uma ENTREGA dentro dela (uma entrega por "
        "unidade, com nome proprio); e as ATIVIDADES daquela unidade viram os pacotes de "
        "trabalho dessa entrega. Um lote entregue numa data e' uma fase do ciclo de vida — "
        "e' o que o Guia PMBOK 8 chama de usar as fases como um nivel da decomposicao.\n"
        # UMA MUDANCA TIRA TANTO QUANTO POE (Eduardo, 2026-07-30). Sem esta secao, uma
        # repriorizacao deixava o escopo velho e o novo convivendo no mesmo plano.
        "     REGRA 4 — O QUE A MUDANCA ELIMINA sai numa secao REMOVER:, no inicio do "
        "[P9.2], com uma linha por item — o CODIGO da EAP primeiro e o nome depois "
        "('• 2.1.3 Obra civil das estruturas fisicas'). COPIE O NOME EXATAMENTE como ele "
        "esta no meu quadro, letra por letra: e' o NOME que identifica o cartao a remover, "
        "e o codigo e' so' conferencia (o codigo da EAP e' posicional e pode ter mudado "
        "desde que voce leu o meu quadro; o nome, nao). Liste so' o item de cima de cada "
        "ramo: remover um item remove tudo o que esta dentro dele. Se a mudanca substitui "
        "escopo (o novo faz o que o antigo fazia), diga aqui o que ficou obsoleto — um "
        "plano com o trabalho velho e o novo somados mente no prazo e no custo. Se ela nao "
        "tira nada, OMITA a secao REMOVER: inteira.\n"
        "     REGRA 5 — NAO DEVOLVA AS CHAVES DO MOLDE. O formato abaixo usa {assim} para "
        "marcar o que voce preenche. Escreva o valor puro: `apos: 2.1`, e nunca "
        "`apos: {2.1}`."),
    "riscos": (
        "RISCOS: os riscos que NASCEM ou CRESCEM por causa desta mudanca (e as premissas e "
        "restricoes novas, se houver). So' os novos — os que ja estao no meu quadro nao se "
        "repetem."),
    "cronograma": (
        "CRONOGRAMA: a duracao, as datas e o responsavel de cada pacote NOVO, e as "
        "dependencias dele com o que ja existe (pelo nome exato do pacote do meu quadro)."),
    "orcamento": (
        "ORCAMENTO: os itens de custo NOVOS que a mudanca traz (e, se ela ELIMINA um custo "
        "que ja existe, um item com valor negativo dizendo qual)."),
}

_FORMATO_MUDANCA_PT = {
    "escopo": (
        "[P9.2]\n"
        "REMOVER:\n"
        "• {codigo da EAP} {nome exato do item que sai — OMITA a secao inteira se a mudanca nao tira nada}\n"
        "FASE: {so' se a mudanca criar uma fase nova} | apos: {codigo da fase anterior, ou \"fim\"}\n"
        "ENTREGA: {nome da entrega nova — UNICO na EAP} | apos: {codigo da entrega irma depois da qual ela entra} \n"
        "• {pacote de trabalho novo} — aceitacao: {criterio verificavel}\n"
        "• {proximo pacote da MESMA entrega...}\n"
        "ENTREGA: {proxima entrega — outro nome} | apos: {...}\n"
        "• {pacotes dela...}\n"
        "{para acrescentar pacotes a uma entrega que JA existe, repita a linha ENTREGA: com "
        "o nome EXATO dela e use `apos:` com o codigo do pacote irmao}\n"
        "\n"
        "EXEMPLO de agrupamento (a REGRA 3), para um pedido do tipo \"dois lotes, e um bloco "
        "por filial\" — repare que cada nome e' unico e que tudo cabe em tres niveis:\n"
        "FASE: Lote 1 — dormitorios em operacao (Barueri, Sao Paulo, Ribeirao Preto) | apos: 1\n"
        "ENTREGA: Dormitorio de Barueri em operacao\n"
        "• Reforma estrutural da area de Barueri — aceitacao: {...}\n"
        "• Instalacoes eletricas e hidraulicas de Barueri — aceitacao: {...}\n"
        "ENTREGA: Dormitorio de Sao Paulo em operacao\n"
        "• {os pacotes de Sao Paulo...}\n"
        "FASE: Lote 2 — dormitorios em operacao (Curitiba, Uberlandia, Rio de Janeiro) | "
        "apos: Lote 1 — dormitorios em operacao (Barueri, Sao Paulo, Ribeirao Preto)\n"
        "ENTREGA: Dormitorio de Curitiba em operacao\n"
        "• {...}"),
    "riscos": (
        "[P9.3]\nRISCOS:\n"
        "• {a CAUSA leva a um EVENTO que gera um IMPACTO}\n"
        "    tipo: ameaca|oportunidade\n"
        "    probabilidade: muito baixa|baixa|media|alta|muito alta · impacto: muito baixo|baixo|medio|alto|muito alto\n"
        "    resposta: {acao concreta} · dono: {o nome EXATO de UM membro da lista A MINHA EQUIPE}\n"
        "PREMISSAS:\n• {so' as novas, se houver}\nRESTRICOES:\n• {so' as novas, se houver}"),
    "cronograma": (
        "CRONOGRAMA:\n"
        "• {o nome EXATO do pacote NOVO, igual ao que voce escreveu no [P9.2]}\n"
        "    duracao: {N} dias uteis · inicio: AAAA-MM-DD · fim: AAAA-MM-DD · depende de: "
        "{o nome EXATO do pacote que a condiciona, com o tipo entre parenteses — (TI) padrao, "
        "(II), (TT), (IT); ou \"-\"} · responsavel: {o nome EXATO de UM membro da lista A "
        "MINHA EQUIPE} · entrega: {o nome EXATO da entrega a que ele pertence}"),
    "orcamento": (
        "ORCAMENTO:\n"
        "• {item de custo novo}\n"
        "    tipo: pessoas|compra|servico|licenca|reserva · valor: {numero} · quando: {AAAA-MM} "
        "· pacote: {o nome EXATO do pacote que consome este custo; ou \"-\"}"),
}


def detalhamento_da_mudanca(partes):
    """O texto que entra no [INPUT DETALHAR] do Passo 9, montado a partir das partes que
    o aluno LIGOU (escopo/riscos/cronograma/orcamento).

    E' aqui que mora o "ajustar facilmente o prompt": ligar e desligar uma parte nao e'
    editar prompt nenhum — e' responder s/n no Passo 9, e o prompt sai sem aquele pedaco.
    Sem nenhuma parte ligada, devolve "" e o Passo 9 fica como sempre foi: so' a analise
    de impacto.

    Os blocos CRONOGRAMA e ORCAMENTO moram no MESMO rotulo [P9.4] (sao o Passo 4), entao
    saem juntos quando os dois estao ligados.
    """
    escolhidas = [p for p in PARTES_MUDANCA if p in set(partes or ())]
    if not escolhidas:
        return ""
    instrucoes = [f"  {i}. {_INSTRUCAO_MUDANCA[p]}" for i, p in enumerate(escolhidas, 1)]
    formatos = []
    for p in ("escopo", "riscos"):
        if p in escolhidas:
            formatos.append(_FORMATO_MUDANCA[p])
    p4 = [_FORMATO_MUDANCA[p] for p in ("cronograma", "orcamento") if p in escolhidas]
    if p4:
        formatos.append("[P9.4]\n" + "\n".join(p4))
    return (
        "SE A MUDANCA FOR APROVADA, ELA PRECISA VIRAR PLANO. Entao, ALEM da analise de "
        "impacto, DETALHE a mudanca nos pontos abaixo — e SOMENTE o que a mudanca "
        "acrescenta (nunca reescreva o plano que ja existe):\n"
        + "\n".join(instrucoes)
        + "\n\nDevolva CADA pedaco no seu proprio bloco, exatamente nestes formatos (eles "
          "sao lidos por um programa — mantenha os rotulos entre colchetes e os nomes das "
          "secoes):\n\n" + "\n\n".join(formatos))


def normalizar_formato_backlog(valor):
    """Valor do .env -> RESULTADO, HISTORIA ou MISTO (tolera acento, sinonimo, caixa)."""
    f = _SIN_FORMATO.get((valor or "").strip().lower())
    if f:
        return f
    up = (valor or "").strip().upper()
    return up if up in BACKLOG_FORMATOS else BACKLOG_FORMATO_PADRAO


def _formato_backlog_do_env():
    """Le BACKLOG_FORMATO do .env; se nao houver env acessivel, cai no padrao."""
    # (Exception, SystemExit): sem .env na pasta, env.cfg() levanta SystemExit — que NAO
    # e' subclasse de Exception. Sem os dois, importar prompts.py fora do pacote do aluno
    # (um teste, uma ferramenta do repo) morria no PROMPTS = {...} do fim do modulo.
    try:
        from env import cfg
        return normalizar_formato_backlog(cfg().get("BACKLOG_FORMATO"))
    except (Exception, SystemExit):
        return BACKLOG_FORMATO_PADRAO


# Passo -> chave do prompt. Quando o passo depende da abordagem, ha um par
# (chave_preditiva, chave_agil). O contexto.py usa este mapa para gerar o prompt
# do proximo passo JA na abordagem que o aluno escolheu no .env.
PASSO_PROMPT = {
    1: ("okr", "okr"),                 # a corrente do passo 1 tem 5 elos (ver CORRENTE_P1)
    2: ("escopo_preditiva", "escopo_agil"),
    3: ("riscos_preditiva", "riscos_agil"),
    4: ("cronograma_preditiva", "roadmap_agil"),
    5: (None, "revisar_plano_agil"),   # PREDITIVA: sem IA — o python audita (auditoria.py)
    6: ("engajamento", "engajamento"),
    7: ("execucao_preditiva", "execucao_agil"),
    8: ("status_report", "sprint_review"),
    9: ("mudanca_preditiva", "mudanca_agil"),
    10: ("encerramento", "retrospectiva_agil"),
}

# ─────────────────────────────────────────────────────────────────────────────
# O CICLO DA SPRINT — os eventos do Guia Scrum dentro dos 10 passos (so' no AGIL)
#
# Os 10 passos nao mudam de numero nem de nome: o que muda e' que, na abordagem
# adaptativa, os passos 5 a 10 sao CICLICOS — sao a Sprint. Cada evento do Scrum tem
# um passo, e o Passo 10 (a Retrospectiva) devolve o aluno ao Passo 5 (a Planning da
# Sprint seguinte) ate o produto entregar o valor prometido:
#
#     Passo 5   Sprint Planning ....... a Meta, os itens e as tarefas (e a DoD, uma vez)
#     Passo 7   Daily Scrum ........... o foco do dia, os impedimentos, o que apareceu
#     Passo 8   Sprint Review ......... o incremento pela DoD + o Status Report
#     Passo 9   Refinamento ........... continuo, sob demanda (nao e evento com hora)
#     Passo 10  Sprint Retrospective .. o COMO do time + as acoes -> volta ao Passo 5
#
# O contador da Sprint vive em SPRINT_ATUAL, no .env: o Passo 5 le, o Passo 10 avanca.
# ─────────────────────────────────────────────────────────────────────────────
_CICLO_SPRINT_PT = {5: "Sprint Planning", 7: "Daily Scrum", 8: "Sprint Review",
                9: "Refinamento do Product Backlog", 10: "Sprint Retrospective"}
SPRINT_PADRAO = 1


# ─────────────────────────────────────────────────────────────────────────────
# O NOME DE CADA PASSO — o numero e a espinha, o nome e o VOCABULARIO
#
# O numero do passo NUNCA muda: e' ele que amarra o curso inteiro (a trilha, os
# artigos, os e-mails, os cartoes "05 - Passo 5", o certificado). O NOME, sim, muda
# com a abordagem — pela mesma regra que ja vale para as listas do quadro
# (EAP | Product Backlog · Em execucao | Sprint Backlog · Entregue | Incremento):
# uma espinha so', dois vocabularios.
#
# Por que nao um nome neutro para os dois: o aluno preditivo precisa da palavra
# "linha de base"; o aluno agil precisa de "Sprint Review" — e' o nome do evento na
# agenda do time dele. Um nome generico ("inspecionar o resultado") nao ensina
# nenhum dos dois. E por que nao o nome hifenizado ("Aprovar o plano / Sprint
# Planning"): cada aluno leria um nome metade errado, justo onde ele precisa ter
# certeza do que fazer agora.
#
# Isto vale para o que o aluno ve RODANDO o curso (menu, cabecalho do passo, cartao
# da Referencia, cabecalho do prompt, trilha). O titulo e a URL dos artigos e o
# assunto dos e-mails NAO mudam: sao superficie publicada, uma so' para as duas
# abordagens — la' o nome do evento agil mora no corpo (a secao "Preditiva x Agil").
_ROTULO_PASSO_PT = {
    1: "Iniciar o projeto (5W2H)",
    2: "Revisar o escopo",
    3: "Analisar os riscos",
    4: "Cronograma e orçamento",
    5: "Revisar e aprovar o plano",
    6: "Engajar as partes interessadas",
    7: "Orientar e executar",
    8: "Monitorar e Status Report",
    9: "Controlar mudanças",
    10: "Encerrar o projeto ou a fase e verificar o valor",
}

# O nome AGIL = o evento do Guia Scrum (CICLO_SPRINT, a fonte unica) + o que ele faz.
# So' entra aqui o passo cujo SCRIPT realmente roda o evento — nome sem comportamento
# e' nome falso. Por isso o Passo 9 fica de fora: o CICLO_SPRINT ja o chama de
# "Refinamento do Product Backlog", mas o 09_mudancas.py ainda registra pedidos de
# mudanca sem ramo agil. Quando o refinamento existir no script, some a linha 9 aqui.
_GLOSA_AGIL_PT = {
    5: "planejar a Sprint",
    7: "executar e sincronizar",
    8: "inspecionar o incremento",
    10: "fechar a Sprint (ou o projeto)",
}


def abordagem_atual():
    """A abordagem do aluno (PREDITIVA | AGIL), lida do .env. None se ainda nao ha.

    Devolve None — e nao o padrao — quando a chave nao existe: quem ainda nao escolheu
    o COMO nao tem abordagem nenhuma, e o nome do passo tem de sair na forma neutra.
    Nunca levanta: sem .env acessivel (um teste, uma ferramenta do repo), o curso fala
    na forma neutra em vez de quebrar.
    """
    try:
        from env import cfg
        valor = (cfg().get("ABORDAGEM") or "").strip()
        return normalizar_abordagem(valor) if valor else None
    except (Exception, SystemExit):     # sem .env, cfg() levanta SystemExit
        return None


def rotulo(n, abordagem=None, base=None):
    """O nome do passo `n` na abordagem do aluno.

    `base` = o nome a usar quando a abordagem nao renomeia este passo. E' o que deixa
    cada tela manter a sua decoracao (o menu diz "Revisar o escopo (EAP ou Backlog)",
    a trilha diz "Revisar e aprovar o plano (baseline)") sem espalhar os nomes ageis
    por seis arquivos: eles moram so' aqui.

    `abordagem=None` -> le do .env. Passe a abordagem quando ja' a tiver em maos
    (todo passo tem) — e' uma leitura de arquivo a menos.
    """
    ab = normalizar_abordagem(abordagem) if abordagem else abordagem_atual()
    if ab == "AGIL" and n in _ROTULO_AGIL:
        return _ROTULO_AGIL[n]
    return base if base is not None else ROTULO_PASSO.get(n, "")


def sprint_atual():
    """O numero da Sprint em andamento (SPRINT_ATUAL no .env; 1 quando ainda nao ha).

    Nunca levanta excecao: sem .env acessivel (um teste, uma importacao solta), o curso
    continua falando da Sprint 1 em vez de quebrar o prompt.
    """
    try:
        from env import cfg, get_int
        return max(SPRINT_PADRAO, get_int(cfg(), "SPRINT_ATUAL", SPRINT_PADRAO))
    except (Exception, SystemExit):     # sem .env, cfg() levanta SystemExit (nao Exception)
        return SPRINT_PADRAO

# Os 6 elos encadeados do Passo 1 (na ordem em que o aluno os roda). Eles preenchem,
# um a um, as secoes do Termo de Abertura 5W2H — que sao os cartoes da lista
# "INPUTS (Projeto 5W2H)" do quadro E as secoes do documento que o passo 1 gera.
CORRENTE_P1 = ["okr", "entregas", "partes",
               "abordagem", "restricoes_premissas_riscos", "quando_quanto"]
#
# A ORDEM IMPORTA — e a ordem e a do proprio Termo de Abertura:
#   1 POR QUE · 2 O QUE · 3 QUEM · 4 COMO · 5 QUANDO · 6 QUANTO
#
# O elo 4 e a ABORDAGEM (o COMO) e ele e a FRONTEIRA do curso:
#   - vem DEPOIS de por que / o que / quem, porque sao esses os fatores que o Guia
#     PMBOK 8 (secao 4.3) manda usar para escolher a abordagem: os fatores da ENTREGA,
#     do PROJETO e da ORGANIZACAO. Escolher antes seria chute;
#   - vem ANTES de tudo o que sobra, porque o COMO e que define como se calcula o
#     QUANDO, o QUANTO e o ONDE. Perguntar "quando fica pronto?" antes de saber se o
#     projeto e preditivo ou agil e pedir uma data sem saber se ela e um marco de
#     entrega ou o fim de uma Sprint;
#   - e so depois dele da para montar as listas de trabalho do quadro (EAP ou Product
#     Backlog), que tem forma diferente em cada abordagem.
#
# O ONDE e parte do COMO (cartao 4.6, no fim do bloco): onde o trabalho acontece e ate
# onde ele vai depende da maneira de conduzi-lo. E a pergunta menos decisiva das sete —
# se o aluno nao souber, ele deixa em branco e decide no momento certo; o que vale nela
# e o que fica de FORA.


# O NOME da abordagem para o ALUNO. "PREDITIVA"/"AGIL" sao chaves internas (o valor
# do .env, o que o codigo compara) — mostrar a chave a quem le em ingles seria o mesmo
# que mostrar uma variavel. A chave nunca muda; o nome, sim.
_ABORDAGEM_ROTULO_PT = {"PREDITIVA": "PREDITIVA", "AGIL": "ÁGIL"}


def nome_abordagem(valor):
    """O nome da abordagem no idioma do aluno ('PREDICTIVE', 'AGILE')."""
    return ABORDAGEM_ROTULO.get(normalizar_abordagem(valor), valor or "")


def normalizar_abordagem(valor):
    """Valor do .env -> PREDITIVA ou AGIL (tolera acento, sinonimo e caixa)."""
    a = _SIN_ABORDAGEM.get((valor or "").strip().lower())
    if a:
        return a
    up = (valor or "").strip().upper()
    return up if up in ABORDAGENS else ABORDAGEM_PADRAO


def chave_do_passo(n, abordagem=ABORDAGEM_PADRAO):
    """Chave do prompt do passo n na abordagem escolhida."""
    par = PASSO_PROMPT.get(n)
    if not par:
        return None
    return par[0] if normalizar_abordagem(abordagem) == "PREDITIVA" else par[1]


def montar_prompt(chave):
    """Prompt completo de `chave`, pronto para colar em qualquer IA de chat.

    Todo prompt do curso tem FORMATO DA RESPOSTA — conferido em 2026-08-01: as 10
    chaves alcancaveis por PASSO_PROMPT, nas duas abordagens, estao em FORMATOS
    (o unico passo sem prompt e o 5 na preditiva, que e conferencia mecanica e
    nao pede IA). Por isso nao existe mais caminho alternativo: se algum dia
    entrar uma chave sem FORMATO, ela deve GANHAR um formato, nao um modo novo.
    """
    p = _CORPOS[chave]
    entrega = ENTREGAS["CHAT"].format(formato=FORMATOS[chave])
    texto = f"{PAPEL} {entrega} {p['corpo']}"
    # {FORMATO}: so' o prompt do backlog agil o tem — a forma de escrever cada item
    # e uma ESCOLHA do aluno (BACKLOG_FORMATO no .env, definida no 01a). Resolver aqui
    # garante que TODA renderizacao (area de transferencia, cartao de referencia,
    # regeneracao) obedece a escolha. Padrao = RESULTADO (historia de usuario nunca e
    # obrigatoria).
    if "{FORMATO}" in texto:
        texto = texto.replace("{FORMATO}", FORMA_BACKLOG[_formato_backlog_do_env()])
    # {SPRINT}: os passos do ciclo da Sprint (5, 7, 8 e 10 no agil) falam da Sprint
    # CORRENTE pelo numero — "a Sprint Planning da Sprint 2", nao "da Sprint atual". O
    # numero vem do .env (SPRINT_ATUAL) e e' resolvido aqui, no unico lugar por onde toda
    # renderizacao do prompt passa (area de transferencia, cartao de referencia, .txt).
    if "{SPRINT}" in texto:
        texto = texto.replace("{SPRINT}", str(sprint_atual()))
    # O VOCABULARIO DO CURSO, por ultimo. Os corpos dos prompts sao tabela paralela
    # (_CORPOS_PT/_CORPOS_EN), entao NAO passam pelo T() — e era por isso que o aluno
    # do PMBOK 8 Together colava na IA um prompt que mandava "rode o Passo 3". Aqui e'
    # o unico ponto por onde toda renderizacao passa (area de transferencia, cartao de
    # referencia, .txt), do mesmo jeito que o {SPRINT} acima.
    try:
        import catalogo_pmbok8
        texto = catalogo_pmbok8.reescrever_unidade(texto)
    except Exception:
        pass                       # sem catalogo em maos, o prompt sai como sempre saiu
    return texto


# ─────────────────────────────────────────────────────────────────────────────
# OS PARAMETROS [INPUT x] — de onde cada prompt come
#
# Ideia do Eduardo (2026-07-14): em vez de um slot cego («cole aqui...»), o prompt
# DECLARA os cartoes do quadro que ele consome. Ler prompts.py passou a ser suficiente
# para saber o que alimenta o que — nao ha mais uma tabela escondida em outro arquivo.
#
#   [INPUT 1.1] .. [INPUT 6]   um CARTAO do termo de abertura (lista INPUTS)
#   [INPUT ESCOPO]             a lista de escopo (EAP ou Product Backlog)
#   [INPUT RISCOS] [INPUT PARTES] [INPUT CRONOGRAMA] [INPUT ORCAMENTO]
#   [INPUT QUADRO]             a foto viva do quadro (o script monta na hora)
#   [INPUT DIAGNOSTICO]        as 5 notas da escolha da abordagem (script 01a)
#   [INPUT MUDANCA]            a mudanca que estao pedindo (o aluno escreve)
#
# Quem resolve os parametros e' o quadro.resolver_inputs(): ele le o cartao, limpa o
# HTML e devolve o prompt PRONTO. O aluno nunca copia cartao para dentro de prompt.
# ─────────────────────────────────────────────────────────────────────────────
_TOKEN = re.compile(r"\[INPUT ([A-Z0-9_.]+)\]")

_NOME_DO_INPUT_PT = {
    "1.1": "1.1 — a justificativa (POR QUÊ)",
    "1.2": "1.2 — os objetivos e Key Results (OKR)",
    "2.1": "2.1 — as entregas (O QUÊ)",
    "2.2": "2.2 — os requisitos das entregas",
    "3": "3 — as partes interessadas (QUEM)",
    "4.1": "4.1 — a abordagem de desenvolvimento (COMO)",
    "4.2": "4.2 — as restrições",
    "4.3": "4.3 — as premissas",
    "4.4": "4.4 — os riscos iniciais",
    "4.5": "4.5 — o escopo inicial",
    "4.6": "4.6 — o ONDE",
    "5": "5 — a linha do tempo (QUANDO)",
    "6": "6 — os custos (QUANTO)",
    "ESCOPO": "a lista de escopo (EAP ou Product Backlog) — passo 2",
    "RISCOS": "a lista de riscos — passo 3",
    "PARTES": "a lista de partes interessadas — passo 1",
    "EQUIPE": "só os membros da equipe (grupo \"EQUIPE — quem faz\") — os únicos responsáveis válidos",
    "CRONOGRAMA": "o cronograma — passo 4",
    "ORCAMENTO": "o orçamento — passo 4",
    "QUADRO": "a situação atual do seu quadro",
    "SITUACAO_EXECUCAO": ("a situação real da execução — o que atrasou, o que vence no "
                          "horizonte e a carga de cada pessoa (o Passo 7 calcula)"),
    "DIAGNOSTICO": "as suas 5 notas da escolha da abordagem (rode 01a)",
    "MUDANCA": "a mudança que estão pedindo",
    "DETALHAR": "o que você quer que a IA detalhe da mudança (escopo, riscos, cronograma, orçamento)",
    "DOD": "a sua Definição de Pronto (nasce no Passo 5, na primeira Sprint Planning)",
    "META_PRODUTO": ("a sua Meta do Produto — o compromisso do Product Backlog "
                     "(nasce no Passo 2, junto com o backlog)"),
}


def inputs_do_prompt(texto):
    """Os parametros [INPUT x] que este prompt consome, na ordem, sem repetir."""
    return list(dict.fromkeys(_TOKEN.findall(texto)))


def preencher_inputs(texto, valores):
    """Troca cada [INPUT x] pelo texto REAL do cartao x. O que faltar fica dito com
    todas as letras — um prompt nunca vai para a IA fingindo ter um dado que nao tem."""
    def _sub(m):
        k = m.group(1)
        v = (valores or {}).get(k)
        if v:
            return v.strip()
        return _VAZIO.format(NOME_DO_INPUT.get(k, k))
    return _TOKEN.sub(_sub, texto)


# Compatibilidade: prompt completo no tipo padrao (CHAT).


# ─────────────────────────────────────────────────────────────────────────────
# Prompts AVULSOS (nao ligados a um passo do curso)
# ─────────────────────────────────────────────────────────────────────────────
# O curso pede que VOCE escreva a justificativa — e a unica coisa que a IA nao
# pode fazer por voce, porque e a sua dor e o seu contexto. Este prompt e para
# quem TRAVOU na folha em branco: a IA faz PERGUNTAS, voce responde, e o texto
# final continua sendo seu.
_DESTRAVAR_JUSTIFICATIVA_PT = (
    "Eu preciso escrever a JUSTIFICATIVA do meu projeto — SO ela: a dor de hoje e o "
    "que muda quando o projeto entregar. Travei na folha em branco.\n\n"
    "Me faca 3 perguntas curtas, UMA DE CADA VEZ, esperando a minha resposta antes "
    "da proxima:\n"
    "1. O que te incomoda hoje?\n"
    "2. Quem sofre com isso — e o que acontece se nada mudar?\n"
    "3. O que fica diferente quando o projeto entregar?\n\n"
    "Depois da terceira, devolva as MINHAS respostas organizadas em 3 a 6 frases, na "
    "primeira pessoa, com as minhas palavras. So isso.\n\n"
    "NAO escreva a justificativa por mim e NAO saia do assunto: nao pergunte nem "
    "proponha objetivos, metas, indicadores, entregas, tarefas, prazos, custos, "
    "riscos ou partes interessadas — cada uma dessas coisas tem o seu proprio momento "
    "no curso, depois desta. Se eu comecar a falar de solucao, me traga de volta para "
    "a dor.\n\n"
    "Meu projeto e sobre: «uma frase sobre o que voce quer fazer»."
)

# Explicador de conceito: o curso promete que NENHUM termo aparece sem
# explicacao. Este prompt e o "pergunte ao professor" do aluno, em qualquer passo.
_EXPLICAR_CONCEITO_PT = (
    "Voce e um professor de gerenciamento de projetos, apoiado no Guia PMBOK 8a "
    "edicao. Explique o conceito «escreva aqui o termo que voce quer entender» "
    "para alguem que esta no primeiro projeto da vida. Em 4 partes, curtas: (1) o "
    "que e, em uma frase, sem jargao; (2) para que serve — que problema real ele "
    "resolve; (3) como ele aparece na abordagem PREDITIVA e como aparece na "
    "abordagem AGIL (a mesma pergunta, formas diferentes); (4) um exemplo do MEU "
    "projeto, que e: «uma frase sobre o seu projeto». Termine com o erro mais "
    "comum de quem esta comecando. Nao use nenhum termo novo sem explicar na hora."
)


# ─────────────────────────────────────────────────────────────────────────────
# O IDIOMA DO CURSO — as tabelas acima sao a versao PORTUGUESA
#
# O que este arquivo guarda nao sao frases soltas: sao os PROMPTS e os FORMATOS de
# resposta, o produto do curso. Por isso eles nao passam por T() (um catalogo de
# 3 mil palavras por prompt seria irrevisavel) e sim por uma TABELA PARALELA, em
# prompts_en.py — o mesmo dicionario, as mesmas chaves, revisavel lado a lado.
#
# `mesclar` faz a juncao CHAVE A CHAVE: prompt que ainda nao foi traduzido continua
# saindo em portugues, e o curso roda inteiro enquanto a traducao anda. Sem o
# arquivo (ou no pacote PT), nada disto tem custo — as tabelas PT passam direto.
#
# UM CUIDADO QUE NAO E' OBVIO: traduzir um FORMATO muda o que a IA responde, e quem
# le a resposta e' o entradas.py. Por isso o parser aprendeu os dois vocabularios
# (vocabulario.py) ANTES de esta tabela existir — 'probability:' e 'probabilidade:'
# caem no mesmo campo. Ao acrescentar um rotulo novo em prompts_en.py, confira se
# ele esta em vocabulario.CAMPOS/SECOES.
# ─────────────────────────────────────────────────────────────────────────────
from idioma import mesclar, escolher                                # noqa: E402

# O QUE A IA LE QUANDO O CARTAO ESTA VAZIO. Era f-string cru — o unico texto deste
# arquivo que ia PARAR DENTRO DO PROMPT, e ia em portugues nos dois pacotes. O aluno em
# ingles que rodava um passo com um cartao ainda em branco entregava a' IA
# "(ainda em branco no meu quadro: the risk list — step 3)": metade em cada lingua.
# Nao entra em T() porque prompts.py e' tabela, nao frase solta (ver idioma.py).
_VAZIO = escolher("(ainda em branco no meu quadro: {0})",
                  "(still blank on my board: {0})")

try:
    import prompts_en as _EN                                        # noqa: E402
except ImportError:                       # pacote PT: o arquivo nem viaja
    _EN = None


def _en(nome):
    return getattr(_EN, nome, None) if _EN else None


PAPEL = mesclar(PAPEL_PT, _en('PAPEL'))
_CORPOS = mesclar(_CORPOS_PT, _en('CORPOS'))
FORMATOS = mesclar(_FORMATOS_PT, _en('FORMATOS'))
ENTREGAS = mesclar(_ENTREGAS_PT, _en('ENTREGAS'))
FORMA_BACKLOG = mesclar(_FORMA_BACKLOG_PT, _en('FORMA_BACKLOG'))
_INSTRUCAO_MUDANCA = mesclar(_INSTRUCAO_MUDANCA_PT, _en('INSTRUCAO_MUDANCA'))
_FORMATO_MUDANCA = mesclar(_FORMATO_MUDANCA_PT, _en('FORMATO_MUDANCA'))
CICLO_SPRINT = mesclar(_CICLO_SPRINT_PT, _en('CICLO_SPRINT'))
ROTULO_PASSO = mesclar(_ROTULO_PASSO_PT, _en('ROTULO_PASSO'))
_GLOSA_AGIL = mesclar(_GLOSA_AGIL_PT, _en('GLOSA_AGIL'))
NOME_DO_INPUT = mesclar(_NOME_DO_INPUT_PT, _en('NOME_DO_INPUT'))
DESTRAVAR_JUSTIFICATIVA = mesclar(_DESTRAVAR_JUSTIFICATIVA_PT,
                                  _en('DESTRAVAR_JUSTIFICATIVA'))
EXPLICAR_CONCEITO = mesclar(_EXPLICAR_CONCEITO_PT, _en('EXPLICAR_CONCEITO'))
ABORDAGEM_ROTULO = mesclar(_ABORDAGEM_ROTULO_PT, _en('ABORDAGEM_ROTULO'))

# Derivadas — dependem das tabelas ja' no idioma do aluno.
# Separador " · " (e nao travessao): o nome ja entra numa linha que comeca com
# "Passo 7 — ", e dois travessoes na mesma linha viram sopa.
_ROTULO_AGIL = {n: f"{CICLO_SPRINT[n]} · {g}" for n, g in _GLOSA_AGIL.items()}
PROMPTS = {chave: montar_prompt(chave) for chave in _CORPOS}
