0x6869726f6b69/claude-skills

Boucle de relecture d'article : Relecture → Révision → Re-relecture

Analyser l'article (PDF) en tant qu'expert, le réviser en fonction des retours, régénérer le PDF, puis le soumettre à une nouvelle relecture. Ce cycle est répété autant de fois que possible dans le temps imparti fixé par l'utilisateur. Ce qui est remis à l'utilisateur à la fin :

• Le PDF révisé (version finale) et les PDF de chaque tour.
• Les rapports de relecture de chaque tour (7 rubriques) et l'évolution des évaluations et des points soulevés.
• La liste des tâches réservées à l'auteur (expériences supplémentaires, etc. – déplacées ici depuis le corps du texte pour éviter la falsification).

Ci-dessous, <skill_dir> désigne le répertoire contenant ce SKILL.md, <ws> le dossier de travail. Les noms de scripts comme loop_state.py sont abrégés pour python <skill_dir>/scripts/loop_state.py. Si python n'est pas disponible, utiliser python3.

0. Au départ : demander la limite de temps

1. Identifier le PDF cible. S'il n'est pas mentionné dans le message, le demander. Vérifier également si des sources LaTeX (dossier, .zip, .tar.gz d'arXiv, .tex) se trouvent au même endroit que le PDF ou en pièce jointe. La présence des sources améliore considérablement la qualité et la rapidité de la révision.
2. Demander la limite de temps. Utiliser un outil de question (AskUserQuestion) si disponible, sinon demander par chat et attendre la réponse. Si le message de lancement mentionne déjà le temps, l'utiliser sans redemander.
   • Question 1 « Limite de temps » : Relecture uniquement (pas de boucle de révision) / 1 heure / 2 heures / 3 heures (possible de répondre « 30 minutes », « 5 heures », etc.)
   • Question 2 « Destination de soumission / critères d'évaluation » (à regrouper dans la même boîte de dialogue, omettre si déjà connu) : Non spécifié (standard conférence internationale de premier plan) / NeurIPS, ICML, ICLR / Revue (Accept / Minor / Major / Reject)
3. Dès réception de la réponse, démarrer le chronomètre. Le temps de configuration est inclus dans le budget.

   python <skill_dir>/scripts/loop_state.py init <ws> --hours 2 --paper <pdf> --venue "<destination>"
   

   (Options possibles : --minutes 90 ou --review-only)
4. Si un outil anti-sommeil (ex. keep-awake pour le bureau Claude) est disponible, l'activer pour la durée du budget. Un PC qui se met en veille stoppe la boucle longue.
5. Communiquer à l'utilisateur en 2-3 lignes : l'heure limite, le dossier de travail, le fait que la suite se déroulera de manière autonome sans demander de confirmation, et la possibilité d'interrompre à tout moment.

1. Configuration

Le dossier de travail est <dossier_contenant_le_PDF>/<nom_du_PDF>_review_loop/ (si accessible en écriture, sinon sous le répertoire de travail).

<ws>/
├── state.json          Enregistrement du chronomètre et des phases (géré par loop_state.py)
├── original/           PDF et sources reçus. Non modifiés.
├── src/                Sources pour l'édition (main.tex, figures/, *.bib)
├── work/               Fichiers temporaires (images de pages, etc.)
├── rounds/
│   ├── r01/            paper.pdf (= PDF original) paper.txt review.md issues.json response.md src/
│   ├── r02/            paper.pdf (1ère révision) paper.txt review.md issues.json response.md src/ changes.diff
│   └── ...
├── issue_tracker.md    Suivi des évaluations et des points soulevés (généré par loop_state.py summary)
├── author_todo.md      Tâches que seul l'auteur peut résoudre (expériences supplémentaires, etc.)
└── final_report.md

1. loop_state.py start <ws> --round 0 --phase setup
2. Copier le PDF dans original/ et rounds/r01/paper.pdf, puis en extraire le texte : python <skill_dir>/scripts/pdf_tools.py text <ws>/rounds/r01/paper.pdf -o <ws>/rounds/r01/paper.txt
3. Préparer les sources pour l'édition dans src/ (ignorer en mode relecture uniquement).
   • Si des sources LaTeX sont disponibles : les copier / décompresser dans src/ (le fichier contenant \documentclass et \begin{document} est le fichier principal). Builder une fois avec build_pdf.py pour vérifier que tout est correct.
   • Si seul le PDF est disponible : reconstituer les sources LaTeX en suivant la procédure de references/pdf_to_latex.md. C'est l'étape la plus lourde (20 à 40 minutes pour 10 pages), donc informer l'utilisateur de la consommation du budget.
4. python <skill_dir>/scripts/snapshot.py <ws>/src <ws>/rounds/r01
5. loop_state.py end <ws> --round 0 --phase setup

La relecture du tour 1 porte sur le PDF original, elle peut donc être exécutée en parallèle de la reconstruction des sources. Si des sous-agents sont disponibles, lancer simultanément le relecteur et le reconstructeur.

2. Boucle

Répartition des rôles et justification

• La relecture est confiée à un nouveau sous-agent (outil Agent) à chaque tour. Un relecteur qui n'a pas le contexte de l'auteur des révisions ne peut juger que ce qui est réellement écrit dans le PDF, et non ce que l'auteur avait l'intention de corriger. L'auto-évaluation dans le même contexte biaiserait les notes à la hausse.
• La révision est également confiée à un sous-agent, tandis que le processus principal se concentre sur l'orchestration (chronomètre, lancement, vérification, agrégation). Ainsi, même après plusieurs heures, le contexte principal ne gonfle pas, et tout l'état est conservé dans les fichiers.
• Dans un environnement sans sous-agents, tout est effectué séquentiellement par l'agent principal. Dans ce cas, avant chaque relecture, le texte est extrait du nouveau PDF et relu, basé sur le document et non sur la mémoire.

Tour r (r = 1, 2, …)

(a) Relecture

1. loop_state.py start <ws> --round r --phase review
2. Lancer le sous-agent avec le « Message de mission pour le relecteur » ci-dessous et attendre qu'il termine.
3. Valider la sortie : vérifier que review.md contient les sections requises (la section 0 également pour r≥2), et que issues.json est un JSON valide. Si des éléments manquent, demander au même relecteur de les corriger.
4. loop_state.py end <ws> --round r --phase review, puis loop_state.py summary <ws> (met à jour issue_tracker.md).
5. Envoyer une seule ligne de progression à l'utilisateur. Ex. : r02 relecture terminée : score 3→4, Majeur non résolu 5→2, temps restant 1h12m

(b) Décision de continuer

1. Exécuter loop_state.py status <ws>. Comme Claude ne peut pas ressentir le temps écoulé, la décision temporelle doit impérativement se baser sur cette sortie.
2. Si NEXT: STOP, aller à §3. Cette décision étant prise juste après la relecture, le PDF final est toujours relu.
3. Même si CONTINUE est indiqué, si issues.json ne contient plus de points avec status open ou partially_resolved (tous sont resolved ou needs_author mis en attente par [AUTHOR TODO]), on peut terminer. Tout ce qui pouvait être corrigé dans le texte l'a été, et continuer ne ferait que polir la rédaction. La raison est consignée dans le rapport final.

(c) Révision (correspondant à la relecture du tour r, pour produire le PDF du tour r+1)

1. loop_state.py start <ws> --round r --phase revise. Noter l'heure revise by indiquée dans le status.
2. Lancer le sous-agent avec le « Message de mission pour le réviseur » ci-dessous et attendre qu'il termine.
3. Valider : vérifier que rounds/r{r+1}/paper.pdf et paper.txt existent, que la construction a réussi (aucune référence non définie), et que rounds/r{r}/response.md existe. Si la construction échoue, restaurer le fichier cassé depuis rounds/r{r}/src/ et recommencer les modifications. Ne jamais soumettre l'ancien PDF comme version révisée à la relecture.
4. loop_state.py end <ws> --round r --phase revise → passer au tour r+1 en (a).

Le réviseur arrête toute nouvelle modification passé l'heure revise by et se contente de finaliser la construction. Cela permet de laisser du temps pour la relecture suivante.

Message de mission pour le relecteur

Vous êtes le relecteur de cet article. Lisez d'abord <skill_dir>/references/reviewer_guide.md et
<skill_dir>/references/review_template.md jusqu'au bout, puis suivez le profil de relecteur, les critères et le format de sortie.

- Objet de la relecture : <ws>/rounds/rNN/paper.pdf (texte extrait : <ws>/rounds/rNN/paper.txt)
- Tour : NN
- Points soulevés au tour précédent : <ws>/rounds/r(NN-1)/issues.json   ← uniquement pour les tours 2 et suivants
- Destination de soumission / échelle d'évaluation : <venue ou "Non spécifié">
- Langue du rapport de relecture : français
- Sortie : <ws>/rounds/rNN/review.md et <ws>/rounds/rNN/issues.json
- Aide : python <skill_dir>/scripts/pdf_tools.py (render peut générer des images des pages avec figures/tableaux pour vérification)

L'évaluation se base uniquement sur le contenu de ce PDF. Les intentions du réviseur ou les réponses ne vous sont pas fournies.
Les passages marqués [AUTHOR TODO] ne sont que des promesses ; traitez-les comme non résolus.
Enfin, retournez 4 lignes : « Évaluation globale / Confiance / Nombre de problèmes majeurs non résolus / Nombre de nouveaux points soulevés ».

Message de mission pour le réviseur

Vous êtes l'auteur de cet article et vous révisez le manuscrit en fonction de la relecture. Lisez d'abord
<skill_dir>/references/revision_guide.md jusqu'au bout, en particulier la règle « ne pas falsifier ».

- Sources à éditer : <ws>/src/ (fichier principal : <main>.tex)
- Relecture actuelle : <ws>/rounds/rNN/review.md, <ws>/rounds/rNN/issues.json
- Suivi : <ws>/issue_tracker.md (généré automatiquement, lecture seule. Ne pas modifier)
- TODO auteur : <ws>/author_todo.md (créer s'il n'existe pas, ajouter et mettre à jour)
- Temps : terminer la construction avant <revise_by>. Le temps restant peut être consulté via
  python <skill_dir>/scripts/loop_state.py status <ws>.
- Une fois terminé :
  1. python <skill_dir>/scripts/build_pdf.py <ws>/src/<main>.tex --out <ws>/rounds/r(NN+1)/paper.pdf
     (corriger jusqu'à ce qu'il n'y ait plus d'erreurs ni de références non définies)
  2. python <skill_dir>/scripts/pdf_tools.py text <ws>/rounds/r(NN+1)/paper.pdf -o <ws>/rounds/r(NN+1)/paper.txt
  3. python <skill_dir>/scripts/snapshot.py <ws>/src <ws>/rounds/r(NN+1) --prev <ws>/rounds/rNN
  4. Rédiger <ws>/rounds/rNN/response.md (format dans revision_guide.md)
Enfin, retournez « ID des points traités / ID des points délégués à l'auteur / résultat de la construction (nombre de pages, références non définies, nombre de [AUTHOR TODO]) ».

Si la reconstruction à partir du PDF est confiée, demander : « Lisez <skill_dir>/references/pdf_to_latex.md, reconstruisez <ws>/original/<name>.pdf dans <ws>/src/, enregistrez le PDF construit dans <ws>/rounds/r01/reconstructed.pdf, et rédigez les différences dans <ws>/src/RECONSTRUCTION_NOTES.md ».

3. Finalisation

1. loop_state.py finish <ws> --reason "<limite de temps / plus aucun point à corriger dans le texte / relecture uniquement>" → loop_state.py summary <ws>
2. Si au moins une révision a été effectuée, copier le dernier PDF sous <ws>/<nom_du_PDF>_revised.pdf.
3. Rédiger <ws>/final_report.md :

# Rapport de relecture et révision : <Titre de l'article>
- Temps alloué / Temps utilisé / Nombre de tours / Raison de la fin
## Évolution des évaluations            (tableau de issue_tracker.md)
## Points essentiels de la relecture du manuscrit original (r01)   (résumé de la Justification et principales Faiblesses)
## Principaux points résolus par la révision
## Problèmes restants
### Ceux qui pouvaient être corrigés dans le texte mais n'ont pas été terminés dans le temps imparti
### Ceux qui nécessitent le travail de l'auteur (priorité haute dans author_todo.md)
## Évaluation du dernier tour et conditions pour faire pencher la balance vers l'acceptation
## Liste des fichiers

4. La réponse à l'utilisateur est brève : nombre de tours, évolution des évaluations, principaux points résolus, problèmes importants restants et top 3 des TODO auteur, emplacement des fichiers. Ne pas coller la relecture complète, indiquer le fichier. En mode relecture uniquement, inclure les points essentiels du review.md du r01 (Justification, Note, principales Faiblesses, questions pour la réponse).

Reprise après interruption

Si <ws>/state.json existe et que le status est running, consulter loop_state.py status <ws> et le contenu de rounds/ pour reprendre à partir de la phase suivante la dernière phase terminée. Ne pas relancer init car cela réinitialise le chronomètre ; le faire avec --force uniquement si l'utilisateur souhaite un nouveau budget.

Principes et justification

• Ne pas falsifier : ne pas inventer de résultats expérimentaux, de chiffres, de données, de citations ou de preuves. Il s'agit d'un manuscrit de recherche réel ; une seule valeur inventée constituerait une fraude scientifique et causerait un grave préjudice à l'utilisateur. Les points nécessitant de nouveaux résultats sont traités en adaptant les affirmations du texte aux preuves disponibles, et en déléguant les expériences nécessaires à [AUTHOR TODO] et author_todo.md.
• Ne pas assouplir les critères de relecture : mêmes critères d'évaluation à tous les tours. [AUTHOR TODO] est considéré comme non résolu ; une simple reformulation n'apporte pas de nouvelle preuve. L'évaluation n'augmente que lorsque le problème est résolu sur le papier. Sinon, cette boucle ne ferait qu'augmenter artificiellement le score.
• Confier la gestion du temps aux scripts : ne pas estimer le temps écoulé. Vérifier status à chaque tour.
• Ne pas demander de confirmation à l'utilisateur entre les tours : l'acceptation de la boucle entière est acquise dès la réception de la limite de temps. Les communications se limitent à une ligne de progression, sauf en cas de blocage (construction impossible à corriger, PDF illisible, etc.).
• Ne pas modifier les fichiers originaux : original/ est traité en lecture seule, les modifications sont effectuées sur les copies dans src/.