Communitygithub.com

Vérification-atterrissage

Vérification post-travail par un agent FRAIS : le changement a-t-il atterri là où il s'exécute, les affirmations correspondent-elles au disque, qu'est-ce qui aurait dû bouger et ne l'a pas fait, quelque chose de privé a-t-il atteint une copie publique. Invoqué uniquement, jamais en auto-déclenchement : 'vérification-atterrissage', 'est-ce que ça a atterri', 'vérifie mon travail'.

Qu'est-ce que Vérification-atterrissage ?

Cette compétence (skill) fournit un agent spécialisé pour exécuter une vérification de cohérence en trois parties après un travail de développement, comblant un vide laissé par les outils existants comme `/code-review`, `/audit` et `coding-conventions`. Elle vérifie d'abord si les modifications ont 'atterri' sur le fichier qui est réellement exécuté (en tenant compte des hooks, des chemins PATH, des jumeaux, de l'enregistrement et de l'activation). Ensuite, elle confronte chaque affirmation vérifiable dans les artefacts écrits (messages de commit, rapports) avec l'état réel du disque, en dérivant indépendamment les universaux, les comptages, les états et les nombres pour débusquer les fausses déclarations. Enfin, elle recherche les 'dommages collatéraux' — les copies soeurs, la propagation de correction, les fuites de publication et les sous-produits qui auraient dû être mis à jour mais ne l'ont pas été. L'agent est invoqué manuellement via `/landing-check` et doit être un agent frais unique avec un contexte limité aux changements et aux artefacts écrits, sans relecture des résumés de l'auteur pour éviter les angles morts. La compétence s'appuie sur un script `landing-probe.js` pour l'analyse mécanique et génère un rapport de sortie concis avec des verdicts, des tableaux de couverture, d'atterrissage et d'affirmations, ainsi que des listes de dommages collatéraux. L'outil a été affiné sur des scénarios réels et a détecté des plaintes fallacieuses, des corrections mal atterries et des gardes morts, mais pas de bugs de code. Il est spécifiquement conçu pour les flux de travail d'agents IA qui effectuent des modifications sur plusieurs dépôts ou des systèmes multi-arborescences où les vérifications standard peuvent ne pas suffire.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Evan-Daruwalla/claude-skill-suite/tree/HEAD/landing-check

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

vérification-atterrissage — le travail a-t-il atterri et les affirmations sont-elles vraies ?

Trois questions que rien d'autre dans la boîte à outils ne pose. /code-review lit le diff pour vérifier l'exactitude. /audit balaie l'ensemble du projet, à froid. coding-conventions force l'auteur à réexécuter son propre code. Les trois peuvent réussir alors que le changement est allé dans un fichier que rien n'exécute, que le rapport indique un nombre erroné et que la moitié des copies n'ont jamais été touchées.

La classe de défaillance pour laquelle cela existe, observée en pratique : un correctif de sécurité a été déployé en bouclant sur chaque fichier .git/hooks/pre-commit dans un ensemble de dépôts. Mais plusieurs de ces dépôts définissaient core.hooksPath, et git ignore alors entièrement .git/hooks — donc, dans certains d'entre eux, le correctif a atterri sur un fichier mort tandis que le hook actif conservait l'ancien chemin. La boucle a confirmé chaque écriture, et le rapport a affirmé que le correctif était universel pendant six jours. Le diff était correct. La vérification était réelle. Les deux concernaient le mauvais fichier.

Chaque vérification ci-dessous est une vérification dont une exécution réelle a eu besoin. Aucune n'est spéculative — voir Provenance à la fin. Dix exécutions plus tard : le balayage a trouvé zéro bug de code et environ quarante affirmations fallacieuses, correctifs mal atterris, gardes morts et corrections qui ne se sont pas propagées. C'est la forme de ce qu'il attrape.

Déclencheur

/landing-check, ou : "est-ce que ça a atterri", "balaie les changements", "vérifie ce que je viens de faire", "vérifie mon travail avant que je ne commit". Invoqué uniquement — cela coûte un agent, donc il ne se déclenche jamais tout seul.

Pas cette compétence

  • Exactitude du code dans le diff → /code-review (intégré ; a multi-agent et --fix). Ne pas réexaminer la logique ici.
  • Bala yage complet du projet → /audit (froid, coûteux).
  • Réexécuter ce que vous venez d'écrire → coding-conventions (même contexte, propres yeux de l'auteur, se déclenche depuis le hook PostToolUse). Si une constatation appartient à l'un de ceux-ci, nommez-la et transmettez-la — ne développez pas cette compétence en eux.

Comment l'exécuter

Générer UN agent frais (outil Agent, usage général). Contexte modéré : celui-ci est limité à ce qui a changé, pas au projet.

Ce que l'agent reçoit — artefacts uniquement :

  • les chemins de dépôt touchés, et une ligne sur ce qu'est le projet ;
  • git status + git diff (et git diff --stat par dépôt) — ou, pour les arborescences non-dépôt, la liste des chemins modifiés lors de cette session ;
  • le compte RENDU du travail : messages de commit, entrée du registre, texte du rapport final, tout doc édité pour décrire le changement ;
  • lesquelles des arborescences touchées sont PUBLIQUES (poussées quelque part), le cas échéant ;
  • les étapes 1–3 et le format de sortie ci-dessous, et l'instruction de marquer tout ce qu'il n'atteint pas comme PAS BALAYÉ.

Ce qu'il NE doit PAS recevoir : votre compte de ce que vous avez fait. Les affirmations sont le spécimen. Si vous remettez à l'agent votre résumé, vous lui remettez le même angle mort qui a produit l'erreur — vous devenez à la fois accusé et témoin. Il redérive chaque affirmation à partir des artefacts écrits et du disque. C'est la seule règle qui rend la compétence digne de son coût ; abandonnez-la et c'est de l'auto-notation dans une deuxième fenêtre.

L'agent relit l'état en direct. git status, avance/retard, ce qui est poussé : dérivé au moment du balayage, pas à partir de la capture qui lui a été remise — d'autres sessions commitent, poussent et éditent entre-temps (une session simultanée a commité un correctif à l'intérieur d'un commit sans rapport ; six dépôts ont été poussés quelques minutes avant un balayage à qui on a dit "zéro poussée"). ahead N ne prouve rien sans un fetch d'abord — interrogez le distant (git ls-remote, puis rev-list --left-right --count @{u}...HEAD).

1. ATTERRISSAGE — la modification a-t-elle atteint le fichier qui s'exécute ?

Pour chaque fichier modifié, demandez si une autre copie existe et si quelque chose choisit entre elles. La signature est : le fichier modifié et le fichier exécuté ont le même nom et des chemins différents.

  • Shadowing : git config core.hooksPath (défini ⇒ .git/hooks/* est du code mort ; résoudre avec git rev-parse --git-path hooks/<name>, le résolveur que git lui-même utilise), ordre du PATH pour les scripts, liens symboliques, copies vendues sous node_modules, une copie venv vs une copie dépôt.
  • Systèmes multi-arborescences : si un fichier existe dans plus d'une arborescence (installé / lab / public, dev / dist, src / build), laquelle l'exécution charge-t-elle ? Celle modifiée était-elle la bonne ?
  • Enregistrement : si le changement ajoute ou modifie quelque chose qui doit être câblé (un hook, une tâche planifiée, une route, un point d'entrée), lisez le fichier d'enregistrement et confirmez que le chemin qui y figure résout le fichier que vous avez modifié.
  • Activation — le bon fichier est nécessaire, pas suffisant. Pour tout ce qui est un contrôle — une garde, règle de refus, matcher de hook, regex, modèle de permission, assertion canari, règle d'ignorance — plantez le positif qu'il existe pour attraper et regardez-le se déclencher, puis un négatif et regardez-le rester silencieux. Un contrôle jamais observé comme se déclenchant est NON VÉRIFIÉ. Contrôles qui se lisaient comme une protection et ne pouvaient pas se déclencher, tous trouvés par les exécutions : règles de refus qui étaient des matchers de préfixe et ne pouvaient jamais bloquer un jeton au milieu d'une commande ; une regex de fuite dont le \R compilait en X:Repo et ne pouvait pas correspondre à un chemin réel ; un filtre de nom sensible à la casse qui laissait passer une orthographe en majuscules ; une assertion /findings/.test(src) qui était vraie pour toujours.
  • Verdict par fichier modifié : ATTERRI / MAL ATTERRI / INVÉRIFIABLE (dire pourquoi). Un fichier dont vous n'avez pas pu déterminer la copie d'exécution est INVÉRIFIABLE, pas ATTERRI. Une copie morte laissée derrière n'est pas en soi une constatation — dites quelle copie est active et que la modification s'y trouve.

2. AFFIRMATIONS — le compte écrit correspond-il au disque ?

Extrayez chaque assertion vérifiable des artefacts, puis redérivez chacune indépendamment — une commande différente de celle qui l'a produite, là où une commande différente existe. Ordre de priorité, rendement le plus élevé en premier :

  1. Universaux — "tous les 7", "chaque copie", "octet-identique", "aucun ne reste", "0 constatations", "rien n'a fui sur les 17 dépôts". Un seul manquant falsifie l'énoncé entier, et c'est la classe qui a produit l'erreur du 08-05. Énumérez l'ensemble complet et vérifiez chaque membre ; n'acceptez jamais un contrôle ponctuel comme preuve d'un universel. Un universel que vous n'avez pu que contrôler ponctuellement est NON VÉRIFIÉ.
  2. Comptages — "17 règles", "29 compétences", "21/21". Comptez à partir de la source de vérité, pas de la phrase. Surveillez le temps : un comptage d'entrées de registre écrites à l'intérieur de l'entrée en cours de comptage est décalé d'un au moment où il atterrit ; une affirmation "les seuls fichiers sales restants" faite depuis l'intérieur d'un fichier sale est auto-falsifiante ; une citation d'une entrée qui n'existe pas encore ne pointe sur rien jusqu'à ce qu'elle soit écrite.
  3. États — "réussit", "propre", "régénéré", "poussé". Exécutez-le, ou lisez l'artefact qui le prouve. La sortie citée est une affirmation sur le programme : si un artefact cite une ligne de sortie d'outil comme preuve, grepez l'outil pour ce littéral — une ligne imprimée uniquement sur la branche d'échec ne peut pas prouver une réussite, et une ligne que le programme n'émet jamais est une citation fabriquée.
  4. Nombres — une valeur avec plus de chiffres significatifs que la sortie à laquelle elle se rapporte est inventée (13 parts publiées à 4 décimales à partir d'un tableau à 2 décimales : 12 fausses). Une statistique provenant d'un corpus VIVANT (transcriptions, logs, un registre croissant) n'est pas reproductible sans son état de corpus figé (nombre de fichiers + horodatage) ; signalez-la comme NON VÉRIFIÉE-TELLE QUE DITE et nommez ce qui se reproduit. Vérifiez l'arithmétique à l'intérieur d'une phrase ("27 plus 3 … 29 aujourd'hui"). Pour les comparaisons : même échantillon dans chaque bras, estimateur nommé, n indiqué — un 2x2 dont les bras ne partagent pas des lots n'est pas une comparaison. Un champ absent n'est pas false. Un == sur un flottant qui fait un aller-retour via float32 n'a jamais correspondu, et le JSON commité contenait 0.0 pour un vrai 0.605.
  5. Contradiction interne — une phrase falsifiée par la mise en garde de son propre paragraphe cinq lignes plus loin ; une affirmation et sa réfutation toutes deux présentes sans frappe datée ; le même chiffre cité trois fois et faux dans les trois.

Une affirmation que vous ne pouvez pas vérifier est rapportée comme NON VÉRIFIÉE, jamais comme vraie. Une affirmation qui est vraie mais pour une raison différente de celle indiquée est une constatation.

3. DOMMAGES COLLATÉRAUX — qu'est-ce qui aurait dû bouger et ne l'a pas fait ?

Le diff montre ce qui a changé. Ceci demande ce que le changement obligeait et a laissé inachevé. Exécutez l'inverse du diff : pour chaque valeur ou concept modifié, grepez l'arborescence pour d'autres endroits affirmant encore l'ancien.

  • Copies soeurs — chaque autre arborescence/branche/package contenant le même fichier. Le correctif pour un mauvais atterrissage s'est lui-même mal atterri dans une des deux copies ; une copie en gros d'un fichier privé par-dessus son jumeau public a réintroduit ce qu'un commit antérieur avait délibérément supprimé — comparez la copie publique à son propre git show HEAD:, pas à la source privée.
  • Propagation de correction — si le travail corrige une affirmation, trouvez chaque autre copie de l'ANCIENNE affirmation : HANDOFF, PRD, bacs de mémoire, README, commentaires de code, le jumeau public, la propre description de la compétence. "Corrigé dans le registre, laissé HANDOFF et le bac indiquant les anciens nombres" et "la troisième copie de cette affirmation était toujours non barrée" sont les constatations les plus répétées de chaque exécution.
  • Docs citant la valeur modifiée — READMEs, descriptions de compétences, HANDOFF, PRD, commentaires, broches MUST print N/N. Un comptage modifié dans le code et inchangé dans la prose est une constatation.
  • Fuite de publication — atterri là où il ne doit PAS. Si une arborescence touchée est publique : balayez son diff (et les fichiers qu'il a touchés, par rapport à HEAD) pour des identifiants privés — noms, emails, chemins absolus, noms de projets privés — insensible à la casse. Dites si ce changement a introduit la chaîne ou l'a héritée ; les deux nécessitent des correctifs différents et l'auteur a déjà confondu le premier avec le second.
  • Jumeaux générés — HTML rendu d'un registre, lignes de TOC, bacs de mémoire, ancres : régénéré ? Une ancre qui résout mais atterrit un titre plus tôt n'est pas "cassée", donc broken: 0 ne le prouve pas.
  • Nouveaux types d'artefacts — le travail a-t-il créé un type de fichier qui n'existait pas auparavant (répertoires de cache, sortie de construction, logs) ? Y a-t-il une règle d'ignorance, et est-elle dans le bon dépôt ?
  • Sous-produits — fichiers créés et laissés derrière : fichiers non suivis, répertoires temporaires, __pycache__, .tmp, sauvegardes. Listez-les avec les chemins complets ; ne supprimez rien.
  • L'obligation que les docs indiquent — si les propres règles du projet disent qu'un changement de ce type nécessite quelque chose (une entrée de registre, un jumeau régénéré, un instantané synchronisé, une exécution de test, une augmentation de broche), vérifiez que cela s'est produit.

Sondage — la partie mécanique, exécutée avant que l'agent ne juge

landing-probe.js (Node portable, zéro dépendance, lecture seule) énumère ce que les étapes 1–3 redériveraient autrement à la main, afin que l'agent lise un recensement au lieu d'en deviner un. Donnez-lui chaque arborescence touchée ; remettez sa sortie à l'agent comme un artefact.

node landing-probe.js probe <root>... [--file <p>]... [--since <min>]
                           [--settings <json>] [--remote] [--all]
node landing-probe.js --canary
  • HOOK — par dépôt, par hook : le fichier que git va EXÉCUTER (git rev-parse --git-path, honore core.hooksPath) et toute copie MORTE dans l'autre endroit ; un chemin enregistré sans fichier est MANQUANT.
  • CHANGED — stagé / modifié / non suivi par dépôt ; --file nomme les fichiers en dehors de tout dépôt ; --since N ajoute les fichiers modifiés dans les N dernières minutes sous les racines NON-dépôt (une arborescence installée n'est pas un dépôt).
  • TWIN — pour chaque fichier modifié, chaque fichier de même nom sous toute racine, SAME ou DIFF (sha256, normalisé CRLF). Les noms conventionnels (SKILL.md, README.md — tout nom de base avec plus de 6 copies) correspondent sur le répertoire parent/nom, pas sur le nom seul. --all liste chaque groupe de jumeaux, pas seulement ceux modifiés.
  • REG — --settings <json> : chaque chaîne en forme de chemin (après expansion de ~/$HOME/%USERPROFILE%) et si elle RÉSOUT.
  • REMOTE — avance/retard par dépôt, étiqueté ref EN CACHE sauf si --remote a d'abord récupéré. ahead N sur une ref en cache ne prouve rien.

Quitte avec 1 quand il y a quelque chose à regarder (un hook MORT, un jumeau DIFF d'un fichier modifié, un enregistrement MANQUANT) ; 0 pour un recensement propre. Il ne juge de rien — DIFF entre un privé et sa copie publique générique est attendu, et l'agent le dit. --canary construit des dépôts jetables (hooksPath défini / non défini / pointant vers rien, un distant nu et un clone un commit en avance, jumeaux CRLF, une forêt de noms conventionnels, un fichier de paramètres avec un chemin manquant) et DOIT imprimer CANARY PASS 23/23 avant que vous ne puissiez faire confiance à un recensement.

Sortie

Courte. C'est un balayage de santé pré-commit, pas un rapport d'audit.

  • Ligne de verdict : SÛR À COMMITTER / CORRIGER D'ABORD / INVÉRIFIABLE, une phrase.
  • Ligne de couverture : quels artefacts ont été lus, quelles arborescences balayées, et ce qui n'a PAS ÉTÉ BALAYÉ — un rapport court ne doit jamais se lire comme un rapport propre.
  • Tableau d'atterrissage : fichier | copies trouvées | laquelle s'exécute | déclenché sur un positif planté ? | verdict. Seules les lignes qui sont MAL ATTERRI ou INVÉRIFIABLE ont besoin de détails.
  • Tableau d'affirmations : affirmation (citée) | artefact source | résultat redérivé | VRAI / FAUX / NON VÉRIFIÉ.
  • Liste des dommages collatéraux : ce qui aurait dû bouger et ne l'a pas fait, chacun avec un chemin.
  • Confirmé : les négatifs porteurs et les nombres qui se sont redérivés exactement (pas de mauvais atterrissage, pas de fuite, 25/25 reproduits) — un balayage qui ne rapporte que des défauts n'enseigne rien sur ce qui est solide, et le registre de l'auteur en a besoin.
  • Transmissions : tout ce qui appartient à /code-review, /audit, ou coding-conventions, nommé et transmis plutôt que fait à moitié ici.

Après le rapport

  • Re-vérifiez chaque constatation à la main avant d'agir. Les affirmations du vérificateur sont des affirmations : les entiers redérivés d'une exécution étaient erronés parce que le corpus avait grandi en dessous ; les invariants tenaient. Acceptez ce qui se reproduit.
  • Le correctif est soumis aux mêmes trois questions. Les correctifs aux constatations CORRIGER D'ABORD vont à chaque copie et chaque doc citant l'ancienne valeur — l'exécution qui a corrigé un mauvais atterrissage d'une copie sur deux a livré le correctif à une copie sur deux.
  • Écrivez l'entrée du registre à partir des valeurs redérivées, après la dernière exécution de vérification, pas avant : une entrée écrite en premier enregistre l'état que vous attendiez, et le registre en annexe uniquement rend cela permanent.

Règles

  • **Constatations uniquement. Chang

Skills associés