erikvallow-qt/dont-let-me-slide

Revise a sessão que resolveu o problema. Entregue dois arquivos: LEARNED.md e learned_quiz.py (um quiz de terminal).

1. Identifique a sessão. Use chats recentes para encontrar o chat que corresponde ao problema. Se mais de um for plausível, pergunte ao usuário qual. Se a sessão pertencer a um projeto, revise também os outros chats desse projeto.
2. Leia a sessão inteira, não apenas um resumo. Observe onde o humano e a IA erraram antes de o problema ser resolvido. Observe também conceitos que o humano precisou aceitar por fé, perguntou mais de uma vez ou entendeu errado: estes precisam de um mergulho mais profundo.
3. Pesquise links antes de escrever. Para cada lição, encontre pelo menos um link. Para cada lição Humana e qualquer conceito do passo 2, encontre de 1 a 3 links de mergulho profundo que expliquem o contexto desde os primeiros princípios. Prefira, nesta ordem: documentação oficial ou especificações, notas de aplicação ou manuais do fornecedor, tutoriais ou livros-texto conhecidos, depois blogs ou Q&A respeitáveis. Use WebSearch, depois abra cada link com WebFetch para confirmar que carrega e cobre o ponto. Descarte qualquer link que falhe ou fuja do assunto. Nunca invente uma URL.
4. Escreva LEARNED.md com estas seções, nessa ordem:
   • O que aconteceu: 3 a 5 frases, mais o status (resolvido ou não). Se não resolvido, liste os itens em aberto.
   • Lições aprendidas: dividido em Humano, IA e Compartilhado. Para cada lição, dê o ponto, o que foi perdido, a lição em uma frase e um Link (com a fonte nomeada). Abaixo de cada lição Humana que precisa de contexto, adicione uma sublista "Mergulho profundo": cada entrada é Título, a fonte e uma linha sobre o que ensina e por que ajuda aqui.
   • Perguntas de teste: 3 a 5 perguntas-chave intituladas "Perguntas de teste", seguidas por um gabarito. Observe que o conjunto completo de perguntas está em learned_quiz.py.
   • Links: todos os links usados, agrupados por lição, com a fonte nomeada. Diga que os links foram verificados na data de execução e devem ser verificados antes do uso.
   • Prompt one-shot sugerido: um prompt conciso que teria evitado os problemas desta sessão.
5. Rotule afirmações. Marque afirmações não verificadas como não verificadas. Marque afirmações retiradas de resultados de pesquisa como reportadas e vincule a fonte.
6. Não apresente suposições como descobertas. Se a causa de um problema não foi confirmada, diga isso.
7. Escreva learned_quiz.py a partir do modelo abaixo. Regras:
   • Apenas biblioteca padrão do Python 3. Deve rodar em terminais macOS, Linux e Windows. Sem GUI.
   • Cubra todos os conceitos, não apenas as 3 a 5 perguntas de teste: pelo menos 2 perguntas por lição Humana, pelo menos 1 por lição de IA e Compartilhado, mais 1 por conceito de mergulho profundo. Normalmente 10 a 25 perguntas. Misture perguntas de recordação, "o que você verificaria primeiro" e "identifique o erro".
   • Cada pergunta: tópico (Humano, IA, Compartilhado ou um nome curto de conceito), 4 opções com distratores plausíveis, o índice correto, um porquê de 1 a 2 frases e o link verificado mais relevante.
   • Preencha apenas TITLE, SOURCE e QUESTIONS. Não altere o motor.
   • Antes de enviar, execute python3 -c "import ast,sys;ast.parse(open(sys.argv[1]).read())" learned_quiz.py, depois python3 learned_quiz.py --list, e corrija qualquer erro. Verifique se cada índice de resposta aponta para a opção correta.
8. Mantenha LEARNED.md conciso. Não use travessões em nenhum dos arquivos.
9. Envie ambos os arquivos com SendUserFile. Na resposta, forneça o comando de execução: python3 learned_quiz.py (opcoes: -r revisao flashcard, -t TOPICO filtro, -n N limite, --list imprimir tudo, --seed N ordem fixa).

Modelo do quiz (copie exatamente, substitua os placeholders e a pergunta de exemplo):

#!/usr/bin/env python3
"""Quiz LEARNED: <TOPICO>. Execute: python3 learned_quiz.py [-r] [-t TOPICO] [-n N] [--list]"""
import argparse, random, sys, textwrap

TITLE = "<TOPICO>"
SOURCE = "LEARNED.md, <DATA>"
QUESTIONS = [
    {"topic": "Humano", "q": "Pergunta exemplo?",
     "choices": ["Resposta certa", "Errada 1", "Errada 2", "Errada 3"], "answer": 0,
     "why": "Uma ou duas frases sobre o porquê.", "link": "https://exemplo.com"},
]

def wrap(s, ind="   "):
    return textwrap.fill(s, 78, initial_indent=ind, subsequent_indent=ind)

def ask(prompt, valid):
    while True:
        try:
            a = input(prompt).strip().lower()
        except (EOFError, KeyboardInterrupt):
            print(); sys.exit(0)
        if a in valid:
            return a

def run(qs, review):
    missed = []
    for i, q in enumerate(qs, 1):
        order = list(range(len(q["choices"])))
        random.shuffle(order)
        letters = "abcdefgh"[:len(order)]
        print(f"\n[{i}/{len(qs)}] ({q['topic']})")
        print(wrap(q["q"], ""))
        for L, idx in zip(letters, order):
            print(wrap(f"{L}) {q['choices'][idx]}"))
        right = letters[order.index(q["answer"])]
        if review:
            if ask("   Enter para revelar, q para sair: ", {"", "q"}) == "q":
                sys.exit(0)
            ok = True
        else:
            a = ask(f"   Resposta [{letters}], q para sair: ", set(letters) | {"q"})
            if a == "q":
                break
            ok = a == right
            print("   Correto." if ok else f"   Nao foi dessa vez. Resposta: {right}")
        if review or not ok:
            print(wrap(f"{right}) {q['choices'][q['answer']]}"))
        print(wrap(q["why"]))
        if q.get("link"):
            print(wrap("Mais: " + q["link"]))
        if not ok:
            missed.append(q)
    return missed

def main():
    p = argparse.ArgumentParser(description=f"Quiz: {TITLE}")
    p.add_argument("-r", "--review", action="store_true", help="modo flashcard, sem pontuacao")
    p.add_argument("-t", "--topic", help="apenas este topico (Humano, IA, Compartilhado, ...)")
    p.add_argument("-n", type=int, help="fazer no maximo N perguntas")
    p.add_argument("--list", action="store_true", help="imprimir todas as perguntas e respostas e sair")
    p.add_argument("--seed", type=int, help="embaralhamento fixo")
    a = p.parse_args()
    random.seed(a.seed)
    qs = [q for q in QUESTIONS if not a.topic or q["topic"].lower() == a.topic.lower()]
    if not qs:
        sys.exit(f"Nenhuma pergunta para o topico {a.topic!r}.")
    if a.list:
        for i, q in enumerate(qs, 1):
            print(f"{i}. ({q['topic']}) {q['q']}\n{wrap('R: ' + q['choices'][q['answer']])}\n{wrap(q['why'])}")
            if q.get("link"):
                print(wrap("Mais: " + q["link"]))
        return
    random.shuffle(qs)
    qs = qs[:a.n] if a.n else qs
    print(f"{TITLE}\nFonte: {SOURCE}\n{len(qs)} perguntas.")
    while qs:
        missed = run(qs, a.review)
        if a.review:
            break
        print(f"\nPontuacao: {len(qs) - len(missed)}/{len(qs)}")
        if not missed or ask("Tentar as erradas novamente? [s/n]: ", {"s", "n"}) == "n":
            for q in missed:
                print(wrap(f"Revisao: {q['q']}", "- ") + ("\n" + wrap(q["link"]) if q.get("link") else ""))
            break
        qs = missed

if __name__ == "__main__":
    main()