0x6869726f6b69/claude-skills

Academic Writing Loop: Revisão de Inglês Acadêmico (Única / Loop)

Revisa PDFs de artigos acadêmicos em inglês como um revisor profissional especializado em textos acadêmicos. A referência é o guia Guide to Academic and Scientific Publication de Linda Olson (Proof-Reading-Service.com, 2014), organizado em uma checklist de revisão em references/proofreading_checklist.md. O princípio central do guia é "seguir as diretrizes de submissão, ser preciso e consistente". Muitas variações de notação são ambas corretas, mas a oscilação dentro de um mesmo artigo constitui erro. Portanto, as decisões de notação são registradas em style_sheet.md e seguidas em todas as rodadas.

Modo	O que faz	O que entrega ao usuário
Revisão única	Revisa o PDF especificado uma vez	PDF anotado (destaques e comentários com sugestões de correção), relatório de revisão, folha de estilo
Loop	Revisão → reflete no manuscrito (LaTeX) e gera novo PDF → novo revisor revisa o novo PDF, repetindo até que não haja mais sugestões ou até o limite de rodadas	PDF corrigido, versão anotada do PDF original, relatórios por rodada e progressão, histórico de alterações, consultas ao autor

Abaixo, <skill_dir> é o diretório onde este SKILL.md está localizado, <ws> é a pasta de trabalho, e AWL é a abreviação de python <skill_dir>/scripts/awl.py. Em ambientes sem python, use python3.

0. Inicialização: Determinar Modo e PDF

Uso:

/academic-writing-loop revisão_unica paper.pdf
/academic-writing-loop loop paper.pdf
/academic-writing-loop loop 3 paper.pdf      ← Especifica o número máximo de rodadas (padrão: 5)

loop N significa "revisar no máximo N vezes, aplicar correções (regenerar PDF) no máximo N−1 vezes". A última etapa é sempre uma revisão, então você saberá o que permanece na versão final do PDF.

Tempo estimado (teste: artigo de 2 páginas, 640 palavras): revisão única leva cerca de 15 minutos. O loop tem a revisão da primeira rodada como a mais longa, totalizando cerca de 45 minutos (3 revisões, 2 aplicações). O tempo escala aproximadamente de forma linear com o número de páginas.

1. Leia o modo e o PDF a partir dos argumentos da skill (mensagem). Os separadores podem ser espaço, '、' ou ','.
   • Revisão única: 1回校正 1回 一回 once single 1
   • Loop: loop ループ 繰り返し. O número imediatamente após é o número máximo de rodadas (revisões; padrão 5)
   • PDF: qualquer argumento que termine em .pdf. Caminhos relativos são resolvidos a partir do diretório de trabalho; se não encontrado, busca pelo nome do arquivo.
   • Se o modo não estiver presente, use uma ferramenta de perguntas (AskUserQuestion, etc.; se não disponível, use o chat) para perguntar: Revisão única / Loop (revisar → corrigir → re-revisar). Se o PDF não estiver presente, pergunte também.
2. Se o nome do periódico de destino, URL das diretrizes de submissão ou especificação US/UK estiver na mensagem, use-os. Caso contrário, não pergunte (sem destino = convenções gerais de inglês acadêmico; ortografia = a maioria usada no manuscrito).
3. Verifique o PyMuPDF: python -c "import fitz". Se não estiver instalado, execute python -m pip install pymupdf (necessário para PDF anotado e informações de posição). Se não puder ser instalado, continue sem o PDF anotado e informe o usuário.

1. Configuração (comum a ambos os modos)

A pasta de trabalho será <pasta do PDF>/<nome do PDF>_awl/ (se não for gravável, use o diretório de trabalho).

AWL init    <ws> --pdf <pdf> --mode once|loop [--max-rounds 5] [--journal "<periódico de destino>"]
AWL extract <ws>/rounds/r01/paper.pdf -o <ws>/rounds/r01/paper.txt
AWL scan    <ws>/rounds/r01/paper.txt -o <ws>/rounds/r01/scan.md

<ws>/
├── state.json         Modo, limite de rodadas, motivo de parada (gerenciado pelo awl.py)
├── style_sheet.md     Decisões de notação (comum a todas as rodadas)
├── original/          PDF recebido. Não modificar
├── src/               Fonte para edição (apenas loop)
├── rounds/rNN/        paper.pdf paper.txt scan.md corrections.json report.md annotated.pdf
│                      revision_log.json (loop) src/ changes.diff (loop)
├── author_queries.md  Consultas ao autor (loop)
└── work/              Imagens de páginas, etc.

• Se extract avisar "very little text per page", é um PDF escaneado. Informe que OCR (skill pdf) é necessária. Se o texto não estiver em inglês, informe que esta skill não se aplica e pare.
• Se o periódico de destino for conhecido e acessível na web, leia as diretrizes oficiais de submissão (Author guidelines / Instructions for authors) e registre as regras de idioma e formatação (US/UK, contagem de palavras, estrutura do resumo, títulos, formato de citação, figuras/tabelas, abreviações, número de palavras-chave) em style_sheet.md na seção "Periódico de destino / Diretrizes" e em cada linha relevante. As diretrizes têm prioridade máxima (guia §3).
• No modo loop, informe o usuário em 2-3 linhas: pasta de trabalho, número máximo de rodadas, e que o processo prosseguirá sem confirmações adicionais. No modo revisão única, como é mais curto, pode ser resumido na resposta final.

2. Uma Rodada de Revisão (procedimento comum a ambos os modos)

O conteúdo da revisão segue references/proofreader_brief.md (procedimento, como escrever as sugestões, formato JSON) e references/proofreading_checklist.md (categorias e gravidade).

Quem revisa

• Modo revisão única: Você mesmo pode fazer.
• Modo loop: Cada rodada deve ser atribuída a um novo subagente (ferramenta Agent). Um revisor sem o contexto da pessoa que fez as correções anteriores pode julgar com base apenas no que está realmente escrito no PDF, não no que "foi corrigido intencionalmente". Revisar suas próprias alterações no mesmo contexto aumenta a chance de passar despercebido.
• Artigos longos (corpo principal com mais de aproximadamente 12 páginas / 7.000 palavras): Divida em intervalos de páginas (6-8 páginas cada, nos limites de seção) e atribua a múltiplos subagentes em paralelo. Depois, use AWL merge para combinar e, em seguida, verifique a consistência geral do artigo (ortografia, terminologia, abreviações, citações e referências, numeração de figuras/tabelas, títulos) você mesmo ou o responsável pela integração, usando o resumo do scan.md.
• Em ambientes onde subagentes não estão disponíveis, faça tudo sequencialmente você mesmo. A partir da segunda rodada do loop, leia sempre o texto extraído do novo PDF (não julgue com base na memória).

Instruções para o revisor (escreva todos os caminhos como absolutos; o shell do subagente pode redefinir o diretório de trabalho a cada chamada)

Você é um revisor profissional de inglês acadêmico. Primeiro, leia <skill_dir>/references/proofreader_brief.md e
<skill_dir>/references/proofreading_checklist.md até o final e siga seus procedimentos, critérios e formato de saída.

- PDF a revisar: <ws>/rounds/rNN/paper.pdf (texto extraído: <ws>/rounds/rNN/paper.txt)
- Candidatos a verificação mecânica: <ws>/rounds/rNN/scan.md
- Decisões de notação: <ws>/style_sheet.md (na rodada 1, preencha configurações básicas, terminologia, abreviações)
- Sugestões da rodada anterior: <ws>/rounds/r(NN-1)/corrections.json   ← apenas para rodada 2 em diante
- Páginas de responsabilidade: todas   ← quando houver divisão: "p.1–8", etc.
- Saída: <ws>/rounds/rNN/corrections.json (quando dividido: corrections.partK.json)
- Ferramentas: python <skill_dir>/scripts/awl.py (validate / report / annotate),
          python <skill_dir>/scripts/pdf_tools.py render (para visualizar páginas de figuras/tabelas como imagem)
- Observações do ambiente: <exemplo: Windows. Caminhos podem conter japonês/espaços, portanto use aspas. Não escreva fora de <ws> e <skill_dir>>

Não altere o significado do autor. Não corrija números, fórmulas matemáticas, citações literais ou títulos de referências. Se houver dúvida, coloque como query.
No final, retorne a contagem (erros/clareza/estilo/consulta ao autor), a tendência dos erros mais comuns e o resultado do validate.

Após a revisão, sempre verifique (mesmo se tiver delegado a um subagente, execute pessoalmente)

AWL validate <ws>/rounds/rNN/corrections.json        # Até que retorne VALID, faça o revisor corrigir
AWL report   <ws>/rounds/rNN/corrections.json        # → report.md
AWL annotate <ws>/rounds/rNN/paper.pdf <ws>/rounds/rNN/corrections.json -o <ws>/rounds/rNN/annotated.pdf

validate verifica se o original de cada sugestão existe realmente no texto do PDF. Sugestões não encontradas são ou erros de transcrição ou sugestões sobre texto inexistente, e ambas não podem ser usadas para anotação ou correção.

3. Modo Revisão Única

1. Execute a seção §2 para a rodada r01.
2. AWL finalize <ws> → gera <ws>/<nome do PDF>_proofread.pdf (versão anotada) e <ws>/report.md.
3. Resuma a resposta ao usuário de forma concisa:
   • Contagem (erros / clareza / estilo / consulta ao autor) e impressão geral (2-3 frases)
   • As 3-5 tendências de erros mais comuns, cada uma com um exemplo real (original → sugestão) e o nome da regra
   • Lista de consultas ao autor (resumida)
   • Localização dos arquivos (no PDF anotado, é possível ver sugestões e justificativas passando o mouse sobre os destaques ou na lista de comentários)
   • Não cole o relatório completo. Finalmente, acrescente uma frase mencionando que, se estivesse no modo loop, seria possível refletir as correções e regenerar o PDF.

4. Modo Loop

4.1 Preparação da Fonte para Edição (pode ser paralelo à revisão r01)

init exibe candidatos a fonte adjacente ao PDF.

• Se houver fonte LaTeX (.tex, pasta, .zip / .tar.gz do Overleaf ou arXiv): Copie/extraia para <ws>/src/ (o arquivo que contém \documentclass e \begin{document} é o principal). Compile uma vez e verifique se a fonte corresponde à mesma versão do PDF:

  python <skill_dir>/scripts/build_pdf.py <ws>/src/<main>.tex --out <ws>/work/source_build.pdf
  AWL extract <ws>/work/source_build.pdf -o <ws>/work/source_build.txt
  AWL compare <ws>/rounds/r01/paper.txt <ws>/work/source_build.txt
  

  Se a similaridade for menor que 0.95, é provável que as versões sejam diferentes. Pergunte ao usuário qual usar.
• Se nenhum candidato for encontrado: Pergunte uma vez se há fonte (LaTeX / zip do Overleaf). Com a fonte, a aplicação das correções é precisa e rápida.
• Se não houver fonte: Reconstrua o LaTeX a partir do PDF seguindo o procedimento em references/pdf_to_latex.md (delegue a um subagente, paralelo à revisão r01. 10 páginas levam 20-40 minutos). Garanta que o layout seja aproximado e que o texto em inglês seja copiado literalmente, incluindo erros.
• Se o manuscrito for Word (.docx): Este loop edita LaTeX. Se você deseja preservar o layout, é mais confiável usar o PDF anotado da revisão única e aplicar as correções manualmente no Word. Pergunte ao usuário qual caminho seguir.
• Quando estiver pronto, execute python <skill_dir>/scripts/snapshot.py <ws>/src <ws>/rounds/r01.

4.2 Rodada r (r = 1, 2, …)

(a) Revisão: §2. Quando terminar, envie ao usuário uma única linha de progresso. Exemplo: r02 revisão concluída: erros 9 / clareza 4 (anterior 41 / 17), sugestões anteriores resolvidas 52/58

(b) Decidir se continua: Execute AWL status <ws> e siga o NEXT: na última linha. As condições para parar são determinadas pelo script (não por impressão momentânea):

• O número de sugestões de erro + clareza chegou a 0 (convergência)
• O número máximo de rodadas foi atingido
• O número de sugestões de erro + clareza não diminuiu em relação à rodada anterior (a reescrita está apenas oscilando) Se NEXT: STOP, vá para §4.3. A decisão é tomada imediatamente após a revisão, então a versão final do PDF estará sempre revisada.

(c) Aplicação (aplicar as sugestões da rodada r e gerar o PDF para r+1): Inicie um subagente de revisão com as instruções abaixo e aguarde a conclusão. Quando terminar, verifique pessoalmente:

• Existem rounds/r{r+1}/paper.pdf, paper.txt, scan.md. A compilação foi bem-sucedida e não há referências indefinidas
• Existe rounds/r{r}/revision_log.json e AWL verify <ws> --round r é bem-sucedido (itens que falharam devido à extração podem ser verificados com imagem da página e marcados como verified_manually)
• Se a compilação falhar, restaure os arquivos danificados de rounds/r{r}/src/ e refaça a aplicação. Nunca use um PDF antigo como nova versão para revisão.

→ Prossiga para (a) como r+1.

Instruções para o revisor de aplicação (caminhos absolutos)

Você é um editor do lado do autor, responsável por refletir as sugestões de revisão de inglês no manuscrito. Primeiro, leia
<skill_dir>/references/reviser_brief.md até o final e siga suas regras (não alterar significado e dados, queries não alteram o texto, ordem local → global).

- Fonte a editar: <ws>/src/ (principal: <main>.tex)
- Sugestões desta rodada: <ws>/rounds/rNN/corrections.json (consulte também o report.md)
- Decisões de notação: <ws>/style_sheet.md (se a razão para não aplicar for a intenção do autor ou convenção da área, adicione à seção "Itens não alterados")
- Consultas ao autor: <ws>/author_queries.md (adicione queries)
- Novo PDF: <ws>/rounds/rMM/paper.pdf (MM = NN+1). O procedimento de compilação, extração, scan, snapshot, revision_log.json e verify segue a seção §4 do reviser_brief.md.
- Observações do ambiente: <mesmo que para o revisor>

No final, retorne a contagem (aplicadas/não aplicadas/consultas ao autor), resultado da compilação, resultado do verify e o que foi adicionado à style sheet.

4.3 Finalização

1. AWL finalize <ws> (se parar por motivo diferente da decisão do script, como interrupção do usuário, use --reason "<motivo>"). Isso gera <nome do PDF>_corrected.pdf (versão final), <nome do PDF>_proofread_r01.pdf (versão anotada do PDF original), se houver sugestões restantes, <nome do PDF>_corrected_remaining.pdf, changelog.md e progress.md. As consultas ao autor da última rodada não passam pelo revisor de aplicação, então finalize as adiciona a author_queries.md.
2. PDF com alterações destacadas (opcional): Copie <ws>/src para <ws>/work/diff_src/ para não poluir src/.

   cp -r <ws>/src <ws>/work/diff_src
   latexdiff <ws>/rounds/r01/src/<main>.tex <ws>/src/<main>.tex > <ws>/work/diff_src/diff.tex
   

   Se latexdiff falhar (código de saída diferente de 0) ou diff.tex estiver vazio (pode falhar no MiKTeX por falta de módulos Perl), não crie o PDF e mencione isso na resposta. Se bem-sucedido, execute build_pdf.py <ws>/work/diff_src/diff.tex --out <ws>/<nome do PDF>_diff.pdf.
3. Escreva <ws>/final_report.md:

   # Relatório de Revisão de Inglês Acadêmico: <Título do Artigo>
   - Modo / Número de rodadas / Motivo de parada / Periódico de destino, ortografia, formato de citação (style sheet)
   ## Progressão                       (tabela do progress.md)
   ## Tendências do Inglês Original      (resumo da r01 e contagens por categoria. Exemplos reais de erros comuns e regras)
   ## Principais Correções Aplicadas     (exemplos representativos do changelog.md)
   ## Consultas ao Autor                 (author_queries.md, em ordem de prioridade)
   ## Sugestões Restantes                (resumo do report.md da última rodada)
   ## Lista de Arquivos
   

4. Resposta ao usuário de forma concisa: número de rodadas e progressão (contagem de erros + clareza), tendências dos erros mais comuns, principais consultas ao autor, sugestões restantes, localização dos arquivos. Não cole o relatório completo.

Retomada Após Interrupção

Se <ws>/state.json existir, use AWL status <ws> para ver o estado e retome a partir da etapa indicada em NEXT:. init não sobrescreve pastas de trabalho existentes (use --force apenas para recomeçar).

Princípios e Justificativas

• Não alterar significado / não criar conteúdo: O alvo da revisão são as palavras, não o conteúdo da pesquisa. Não altere números, dados, fórmulas matemáticas, citações literais, títulos de referências ou a força das afirmações. Pontos que o revisor não pode decidir sozinho devem ser retornados como consulta ao autor. Como o manuscrito é real, alterações especulativas distorcem a argumentação do autor.
• Consistência garantida pela style sheet: Como diferentes revisores leem a cada rodada, sem registrar decisões, pode haver oscilação entre "corrigir para UK" e "voltar para US". As decisões são tomadas na ordem: diretrizes do periódico → artigos publicados → maioria do manuscrito, e não são alteradas no meio do processo.
• Separar revisão e aplicação: O revisor vê apenas o PDF e faz sugestões; o revisor de aplicação verifica a validade das sugestões antes de aplicá-las, e o próximo revisor verifica independentemente o resultado. Isso detecta mais facilmente erros que passariam despercebidos se o mesmo contexto revisasse suas próprias correções.
• Inserir verificações mecânicas: validate (se as sugestões correspondem a texto real), verify (se a aplicação chegou ao PDF) e compare (se a reconstrução é igual ao original) são para verificar numericamente os vieses do modelo de linguagem. Não pule essas etapas.
• Delegar a decisão de parar ao script: Siga o NEXT: do status. Como um revisor sempre encontrará algo para sugerir, continuar com base na impressão pode levar a oscilações apenas de estilo.
• Não consultar o usuário entre as rodadas: Uma vez selecionado o modo loop, a execução até o limite de rodadas está aprovada. Apenas uma linha de progresso é necessária; pare para consultar apenas em caso de bloqueio (falha de compilação não solucionável, versão diferente entre fonte e PDF, PDF ilegível).
• Não modificar os arquivos originais: Não escreva em original/ nem no PDF/fonte original na pasta do usuário. A edição é feita na cópia em <ws>/src/.
• Regras antigas do guia são tratadas como preferência de estilo: O guia (2014) evita o split infinitive e o singular they, mas muitos guias de estilo atuais os permitem. A menos que as diretrizes do periódico exijam o contrário, essas não são consideradas erros.