Le plugin pour agents de code : Claude Code, Codex, GitHub Copilot
Le dépôt ddd-ts-kit est la marketplace du plugin pour trois agents de code :
| Agent | Installation | Une skill s'appelle |
|---|---|---|
| Claude Code | /plugin marketplace add ddd-ts-kit/ddd-ts-kit, puis /plugin install ddd-ts-kit@ddd-ts-kit |
/ddd-ts-kit:start |
| Codex | codex plugin marketplace add ddd-ts-kit/ddd-ts-kit, puis installer ddd-ts-kit depuis /plugins et approuver ses hooks dans /hooks |
$start |
| Copilot CLI | copilot plugin marketplace add ddd-ts-kit/ddd-ts-kit, puis copilot plugin install ddd-ts-kit@ddd-ts-kit |
par son nom, start |
| Agent cloud de Copilot, VS Code | déclaré par le .github/copilot/settings.json qu'écrit init : l'agent cloud l'installe, VS Code le recommande |
par son nom, start |
Vingt-six skills, dans l'ordre où un projet les rencontre :
| Skill | Usage |
|---|---|
start |
conduire un projet d'une expression des besoins jusqu'à des contextes qui fonctionnent (lancée par l'utilisateur) |
discover-domain |
un event storming léger, par écrit |
bounded-contexts |
trouver les contextes et les classer cœur, de soutien ou génériques |
glossary |
le langage omniprésent d'un contexte et son CONTEXT.md, avant tout code |
context-map |
amont, aval et patron de relation pour chaque paire de contextes |
bootstrap |
choisir la stack et créer le projet (lancée par l'utilisateur) |
plan-slices |
le travail en tranches verticales par contexte, ordonnées, avec leurs commandes de génération |
parallel-work |
répartir les tranches entre plusieurs agents ou personnes sans collision |
intent |
saisir une idée comme une intention avant toute story, dans les mots de celui qui l'a, pour que le responsable du produit l'accepte dans une pull request (lancée par l'utilisateur ; parcours d'une story) |
story |
mener une user story de ses questions à une pull request verte en une session, une story par terminal (lancée par l'utilisateur ; parcours d'une story) |
fix |
réparer un défaut dans son propre worktree, sa spec de régression écrite et verrouillée avant tout code (lancée par l'utilisateur ; un correctif) |
pull-request |
mener la pull request d'une story au vert : balayer ses commentaires de revue et ses vérifications en échec sous les règles de la story, pousser, attendre, recommencer ; puis rendre compte de ce qui a changé et de ce qui a été refusé (lancée par l'utilisateur) |
scaffold |
un fichier de n'importe quel rôle, à partir d'un template |
use-case |
une fonctionnalité de bout en bout, test d'abord |
integration-event |
faire collaborer deux contextes par un événement versionné |
wiring |
les ports comme classes abstraites, les déclarations, la racine de composition, les fakes dans les tests |
persistence |
repositories, unité de travail, outbox, modèles de lecture, migrations, quel que soit l'ORM |
access-control |
authentification, permissions par cas d'usage, acteur explicite, politiques |
cross-cutting |
journalisation, métriques, traçage, remontée des erreurs, journal d'audit, résilience et cache appliqués de l'extérieur |
testing |
des fakes au lieu de mocks, des builders, étant donné / quand / alors, de bout en bout |
clean-code |
nommage, ordre des fonctions, commentaires, testabilité |
document |
contrat OpenAPI et ses clients typés, catalogue d'événements, AsyncAPI, listes générées, enregistrements de décision |
extract-service |
garder chaque contexte prêt à tourner comme son propre service, et l'extraire |
deviation |
que faire quand on vous demande de contourner une règle |
quality-gate |
lancer les contrôles à la bonne portée et corriger à la cause racine |
commit-discipline |
une tranche par commit, les fichiers générés avec ce qui les a générés |
Six agents : domain-explorer (réponses en lecture seule sur ce qui existe et où),
context-builder (construit les tranches d'un contexte dans son propre worktree),
domain-test-writer (transforme les entrées it.todo en specs), architecture-reviewer
(revue en lecture seule d'un diff, d'une branche ou d'un contexte, sous le REVIEW.md du projet
quand il en a un : les passes de l'équipe par-dessus la méthode de l'agent, chaque constat
étiqueté de sa passe), acceptance-judge (juge un
changement d'un test d'acceptation verrouillé, indépendamment de la session qui l'a fait, et écrit
son verdict) et story-verifier (vérification en lecture seule d'une story à sa clôture, dans
un contexte neuf : il démarre l'application comme le font les tests de bout en bout, exerce les
routes de la story et les deux flux les plus proches, et rend compte de ce qui ne correspond pas
à la conception ou à une décision).
La description de chaque skill dit quand s'en servir en 320 caractères au plus, et les
vingt-six en prennent 6 500 au plus ensemble ; celle d'un agent, 400 au plus. Claude Code charge
la liste des skills dans chaque session dans la limite de 1 % de la fenêtre de contexte, comptés en
caractères et non en tokens : 8 000 caractères sur une fenêtre de 200k, partagés avec toutes les
autres skills de la session, celles de Claude Code et des autres plugins comprises. Au-delà, la
liste raccourcit les descriptions des skills les moins invoquées, qui ne se déclenchent alors plus
sur leurs mots-clés. bootstrap, fix, intent, pull-request, start et story, lancées par
l'utilisateur seul (disable-model-invocation), ne sont pas listées ; les vingt autres prennent
environ 5 600 caractères avec le ddd-ts-kit:<nom> que porte chaque entrée, soit environ 70 % des
8 000 pour le kit seul. Elles tiennent seules ; à côté de beaucoup d'autres skills, les moins
invoquées du kit perdent leur description, et se lancent encore par leur nom. Une part de 2 400
caractères, qui les ferait toutes survivre dans une session chargée, réduirait chaque description
au tiers de ce qu'il lui faut pour se déclencher : le kit accepte la perte. Un test du plugin (node --test plugin/skills/descriptions.test.mjs) tient ces limites.
Le corps d'une skill est lu en entier dès qu'elle se charge : ce qu'une seule option de stack
demande est donc rangé à côté. Le corps garde chaque règle et une ligne, « sous
stack.<clé>: <valeur>, lire d'abord <fichier>.md », et le fichier, lu sur cette stack
seulement, s'ouvre sur le moment où on le lit et renvoie à la page de docs/ qu'il paraphrase
(sous concepts/, tools/ ou guides/). wiring garde le style déclaré et lit explicit.md,
nest.md et earlier-layouts.md ; access-control lit relationships.md sous rebac ;
persistence lit tenancy.md, event-sourcing.md, personal-data.md et migrations.md ;
use-case lit factories.md, function-routes.md et file-upload.md. Un test du plugin
(node --test plugin/skills/bodies.test.mjs) tient ces quatre corps sous un plafond de mots,
comptés comme wc -w les compte : wiring 1 200, access-control 1 900, persistence 1 200,
use-case 2 200.
Le hook est la partie qui rend le reste contraignant. Dans un projet qui a un
ddd-ts-kit.config.json, il rappelle la démarche et la carte des contextes au début de la
session, signale quand les packages installés ne sont pas la version que décrivent les skills, refuse un fichier écrit à la main là où un générateur existe, toute
modification d'un contrat généré et l'écriture de la baseline des erreurs (check --baseline write, quelle que soit la façon de lancer le kit, script de paquet compris, ou une modification
de ddd-ts-kit-baseline.json : le propriétaire du projet l'écrit,
dans un terminal), refuse une commande git qui saute les hooks du projet (--no-verify, -n sur un
commit, -c ou --config-env de core.hooksPath ou son réglage dans l'environnement,
LEFTHOOK=0, HUSKY=0, LEFTHOOK_EXCLUDE, git commit-tree : les hooks sont la barrière locale du
pipeline ; les mots d'une commande sont lus tels que le shell les donne, guillemets ôtés) et, à un sous-agent, un git config qui fixe une valeur ou un git -c d'une clé qui
lance une commande dans chaque checkout (core.fsmonitor, core.pager, core.editor,
core.sshCommand, un alias.*, un pilote diff, merge ou filter, diff.external, un
include.path, un assistant d'identifiants, un pager, un outil de mergetool ou difftool, un
programme gpg, un protocol.*), donnée par -c ou --config-env, ou une variable
d'environnement qui confie à git un programme ou des réglages (GIT_EXTERNAL_DIFF, GIT_PAGER,
GIT_EDITOR, GIT_SSH_COMMAND, GIT_CONFIG_*...), demande l'avis du propriétaire du projet avant qu'une
désactivation ou un test sauté soit écrit dans un source, un test ou un script (un document qui
ne fait que le nommer est de la prose), ou qu'un changement des règles soit écrit par les outils
d'édition, vérifie chaque fichier
écrit et renvoie les violations avec leur correction (les cinq premiers d'un patch de Codex,
les autres nommés comme non vérifiés ; avec "dependenciesBeforeWrite": true, à
l'essai, il refuse avant l'écriture un nouvel import qui enfreint une règle de dépendance), et
refuse de terminer tant que des
erreurs d'architecture restent dans un arbre aux changements non committés (un arbre propre est
laissé au hook de pre-commit et au pipeline ; une vérification qui ne finit pas à temps, ou qui répond plus que
les 64 Mio que la garde lit, laisse la session terminer et le dit ; un début de session qui passe dix secondes d'appels à la CLI saute ceux qui
restent et dit qu'il a été écourté). Avec "formatOnWrite": true dans la configuration (écrite par init pour un nouveau projet), et hors du profil réglementé, il lance
d'abord le Biome que le projet a installé sur le fichier écrit (le bin de son paquet
@biomejs/biome, format --write, un fichier, jamais un autre formateur), pour que la mise en page soit réglée à
l'écriture et que les constats du lint qui suivent une ligne repliée reviennent dans la même
sortie ; une exécution qui échoue ne change rien. Il rappelle, sans bloquer, quand les changements non commités
dépassent la taille conseillée d'un commit, et dans le worktree d'un worker
(.ddd-ts-kit/worker.json), il refuse une écriture hors du contexte du worker, par les outils
d'édition ou par le shell. Les outils d'édition d'un builder sont tenus où que soit le fichier,
dès son premier appel : un chemin qui a oublié son worktree est refusé dans le checkout du chef
d'orchestre, dans un autre worktree et hors de tout projet sauf le répertoire temporaire, avec la
consigne de nommer le fichier sous son worktree. Il lit toute la ligne de commande, chacune de ses commandes, pas
seulement celle qui commence par cd <worktree> && : un worker lance chaque commande ainsi, et
celle qui écrit sans entrer dans son worktree est refusée avec cette consigne : depuis un autre
checkout, un worker ne fait que lire (cat, ls, grep, git qui lit, git add et git commit
dans son propre worktree, le kit interrogé pour lister, décrire, rendre compte ou lire un
briefing, et ses contrôles qui n'écrivent rien : check sans --baseline, lint sans --fix,
rules, docs --check sans --stored-events, verify-merge, cited, affected sans --run),
quel que soit le programme. Une session ouverte au-dessus du projet tient son worker au
projet que nomme sa commande, et un worker qui se tient dans son worktree y reste épinglé quand une
commande commence dans un autre projet. Il ne suit un cd
que lorsqu'il est certain (après &&, vers un répertoire qui existe, et qu'aucun dossier de
CDPATH n'envoie ailleurs), refuse à un worker les variables qui déplacent l'endroit où le
shell ou git trouvent leurs chemins (TMPDIR, CDPATH, HOME, GIT_DIR, GIT_WORK_TREE,
PATH, données à une commande ou exportées), de sorte qu'une écriture
après cd dir; ou un cd qui échoue est refusée plutôt que mal placée ; il lit un nom que le
shell calcule (une variable, une substitution, une liste d'accolades), un lanceur (nice,
ionice, setsid, flock, busybox, su -c, env -S), un exécuteur de paquet (npx,
npm exec) et la commande qu'il lance ; et il connaît les écritures que les tables de fichiers
manquent (>&, un script sed ou awk qui écrit, vim/ed, rsync, curl -o, wget -O,
tar -x, git stash/reset --hard/worktree add/checkout -f, eslint --fix, biome --write). Les seuls endroits libres d'un worker hors de son périmètre sont /dev/null, les
périphériques standard et le répertoire temporaire ($TMPDIR) hors de tout projet (un projet cloné là garde ses règles) ; tout autre chemin absolu est
refusé. Un fichier est jugé là où il aboutit : un lien du périmètre, ou un dossier de son chemin qui en
est un, est l'endroit qu'il atteint, un lien du répertoire temporaire vers un projet est cet
endroit, et un fichier du périmètre qui porte un autre nom ailleurs (un lien physique) est refusé. Une commande imbriquée plus profond que le lecteur ne suit (plus de 32 lanceurs et affectations
avant son programme, qui ne nomme alors aucun programme qu'il connaisse, ou plus de cinq shells ou
eval) est refusée plutôt que laissée passer sans lecture ; de même, à un worker, une ligne qui
finit dans une citation ou sur un here-document jamais fermé, et une commande sur laquelle le
lecteur échoue. Le code qu'il ne peut pas lire (du code
en ligne comme node -e, un script, un shell nourri par son entrée, make, un script ou un
exécuteur de paquet comme npm test ou npx) s'exécute, mais avant chaque commande d'un worker
qui en lance (toute commande sauf les pures lectures : cat, ls, grep, git log,
git status... nommées par leur nom, git sans réglage donné à la commande ni option qui confie
les fichiers à un programme comme grep -O ou --ext-diff ; le kit compte comme le programme, ou
comme premier opérande de node ou d'un exécuteur de paquet), la garde note l'état hors du périmètre (le git status et le HEAD du
worktree, du checkout de la session quand c'en est un autre, et le manifeste et le bin de la
CLI du kit et de Biome dans node_modules), et le compare à l'appel suivant du worker. Une lecture
laisse en place la note du worktree, pour ce que la commande a laissé tourner en arrière-plan,
jusqu'à un changement ou une nouvelle note. L'arrêt du worker la compare une dernière fois, avec ce que sa branche contient hors du
périmètre depuis la base que note son fichier de périmètre (baseCommit : les commits depuis,
ce que le tronc a apporté mis à part, et les fichiers non committés ; un fichier de périmètre
sans base laisse les commits non comparés, la garde laissant passer) : le
worker continue une fois pour remettre un fichier en état, et ce qui reste est dit au chef
d'orchestre dans lastStop.outside de agent.json, dans son rapport, dans status --workers et
dans worker-scope --resume. Un git status qui ne répond pas en entier ne compare rien, et la
garde le dit. Un fichier
du worktree changé hors du périmètre, supprimé ou commité compris, arrête le worker jusqu'à ce
qu'il soit remis en état par la commande que la garde nomme : son contenu commité (git checkout <commit> -- <path>, puis git commit quand un commit l'a changé), le contenu qu'il avait avant la
commande quand il était déjà modifié (gardé sous .ddd-ts-kit/guard/held/), git mv en retour
pour un renommage, rm pour un nouveau fichier. Un fichier de plus de 16 Mio est comparé par sa
taille et sa date, sans être lu, et aucune copie n'en est gardée : déjà modifié avant la commande, il
est dit, sans retenir le worker, qui le nomme dans son rapport. Un fichier laissé modifié dans l'arbre de travail
du checkout de la session (pas celui que le chef d'orchestre commite ou fusionne entre-temps) est
dit une fois au worker et ne refuse rien : le worker n'y remet rien en état et le nomme dans son
rapport, pour le chef d'orchestre, qui seul sait s'il a fait ce changement. Un changement de ces
paquets refuse une fois l'appel suivant, pour le chef d'orchestre aussi, tout comme un changement
de ce sur quoi la garde s'appuie là : la config du kit, les réglages, hooks et plugins d'un
agent de code, un fichier de périmètre.
Ce que les scripts du projet lui-même (npm run format, lint:fix, regenerate, docs:generate,
openapi:generate, events:generate, sans être lancés dans un autre dossier par --prefix, -C,
--dir ou --filter), seuls sur la ligne, réécrivent hors du périmètre parmi les
fichiers que leurs outils réécrivent (code, JSON, docs/) est dit avec le script qui l'a réécrit,
sans retenir le worker : il le laisse hors de ses commits. Le
périmètre est fixé au premier appel du worker, et cette marque suit le worker : elle est gardée
sous le répertoire git que les worktrees du dépôt partagent (ddd-ts-kit/guard/ là), si bien
qu'un appel qui part d'un autre checkout est jugé d'après le worktree fixé, et se voit dire de
se lancer comme cd <worktree> && .... Là où plusieurs workers ont un worktree, une première
commande qui n'en nomme aucun ne fixe rien : elle lit, et ce qu'elle écrit est refusé jusqu'à ce
qu'une commande nomme son worktree, ou un outil d'édition un fichier dedans. Une marque qui ne
peut pas être lue retient chaque appel jusqu'à ce que le chef d'orchestre relance le worker. Un fichier de périmètre supprimé ou changé (son contexte, sa base, son commit de base ou sa branche)
arrête le worker jusqu'à ce que le chef d'orchestre le rétablisse, et le mode de la garde est fixé avec lui :
une config qui éteint la garde, dans le worktree ou dans un autre checkout du dépôt, ou qui dépasse ce que la garde lit, ne libère pas un
worker, son changement étant comparé comme tout autre. Une branche que le worker fusionne dans la
sienne est son travail : seul ce que le tronc contient est au tronc. Le tronc est la base que
notait son fichier de périmètre quand le worker a été fixé (une branche du dépôt, une branche
d'intégration aussi bien que la principale), la branche que nomme origin/HEAD, main ou
master, chacune telle qu'elle était avant la commande qui a fusionné : un tronc récupéré et
fusionné par une seule commande n'est pas encore connu, si bien que le fetch va dans une commande
à part, ou merge-trunk fait les deux. Une fusion de toute autre branche est retenue sans
commande pour la défaire, et le worker la signale au chef d'orchestre. Le merge-trunk du kit n'est pas noté, sauf si --trunk nomme une autre référence que cette base,
et une installation du lockfile laisse les paquets hors de la note. Il refuse un changement de
dépendance et un autre formateur que npm run format. L'architecture-reviewer, le
domain-explorer et le story-verifier ne changent aucun fichier d'un projet par le shell, ni
son arbre de travail par git (ils lisent avec git show et git diff). Un sous-agent ne peut ni supprimer, ni
déplacer, ni réinitialiser une branche extraite dans un autre worktree (celle d'un autre
worker, ou le tronc), options courtes groupées ou longues abrégées comprises. Le git d'un worker
ne change que son propre worktree : depuis tout autre checkout il lit (status, log, diff,
worktree list, fetch vers aucune référence...), de sorte que seul le chef d'orchestre pose une
branche ou déplace son checkout, et qu'aucun worker ne retire un worktree ni n'écrit une
référence par update-ref ou symbolic-ref. Dans son worktree, son git s'en tient à sa propre
branche, celle que note son fichier de périmètre (sinon celle qui y est extraite) : il pousse cette
branche seule (git push, git push -u origin <branche>, HEAD:<branche>), sans --force, -f,
--force-with-lease, refspec en +, suppression (:<ref>, --delete, -d) ni --all,
--tags ou --mirror ; il ne récupère vers aucune référence (git fetch origin main:main), ne
crée aucune étiquette, et n'extrait ni ne bascule vers une autre branche, ni n'en crée une (-b,
-c, --orphan, --detach). La même lecture
du shell tient le domain-test-writer aux chemins d'un test (une spec, le test/ de la racine
ou les dossiers de test d'un contexte, et un fichier qu'il nomme : un endroit que seul le shell
connaît lui est refusé), le code d'une story à sa barrière
de construction, et toute écriture à la main d'un fichier généré ou de la baseline par n'importe
quelle session, chacune par les endroits qu'une commande écrit plutôt que par son texte, dans le
projet qui possède l'endroit, quel que soit le checkout où se tient la session. Ce qu'une
redirection, sed -i ou tee tape dans un fichier est tenu comme par les outils d'édition : le code
d'un contexte dans le checkout principal du tronc, un nouveau fichier d'un rôle généré. Un fichier
généré remis en état ou supprimé (git checkout, git restore, git rm, rm) reste libre, puisqu'il
est reconstruit ensuite ; de même ce qu'une session autre qu'un worker ou le domain-test-writer
écrit là où seul le shell sait. Un
apply_patch de Codex envoyé par le shell est lu comme un patch, chaque patch de la ligne,
dans un here-document ou un argument ; celui que la commande ne contient pas (un fichier, un
pipe) est refusé. Un fichier qu'un patch supprime, ou quitte par un déplacement, est tenu comme
rm le tient (la baseline, le périmètre d'un worker).
Pour un context-builder (l'agent du plugin, ddd-ts-kit:context-builder : un agent du projet
nommé context-builder sans ce préfixe est tenu à la portée de son worktree, mais ni compté ni
enregistré), il compte les appels d'outils dans ces mêmes hooks et avertit
l'agent deux fois avant sa limite de tours, enregistre ses exécutions dans son worktree
(.ddd-ts-kit/agent.json), et écoute deux événements rares de Claude Code, filtrés sur cet agent :
SubagentStart (un lancement ou une reprise démarre un nouveau compte) et SubagentStop (quand il
finit de lui-même, il est relancé une fois pour commiter une tranche que verify-slice a validée,
réécrire un rapport périmé ou remettre en état ce que sa dernière commande a changé hors de son
périmètre). Au démarrage de session, il nomme les workers à reprendre
(travail en parallèle). Dans un projet créé par
init ("worktrees": "required"), il refuse le code d'un contexte et les générateurs qui
l'écrivent dans le checkout principal du tronc, et dans un worktree de .worktrees/ sans son
propre node_modules : npx ddd-ts-kit worktree <name> ouvre l'endroit où l'écrire ; un projet
démarré avant en est seulement averti au démarrage de session. Dans le worktree d'une
story (.ddd-ts-kit/story.json, que la session qui s'y tient et tout sous-agent ne changent
d'aucune façon, pas plus que .ddd-ts-kit/worker.json dans le worktree d'un worker, y compris
en supprimant un dossier au-dessus : rm -r, un find -delete ou -exec rm dont les tests
-name peuvent le trouver, git clean -x ou -X, git stash --all, et git clean -d ou
git stash --include-untracked quand git ne l'ignore pas), il refuse tout code d'un contexte tant que chaque ligne n'a
pas sa revue de conception et que l'acceptation n'est pas écrite et verrouillée, dit la phase de
la story au démarrage de session avec ses croisements avec les autres stories ouvertes, dit
une fois par fichier quand la session écrit un fichier qu'une autre story ouverte change, et
refuse une fois de finir la session avant son rapport
(parcours d'une story). Dans le worktree d'un correctif
("kind": "fix" dans ce fichier), il ouvre le code dès que la spec de régression est
verrouillée, et refuse toute modification d'une spec verrouillée, par les outils d'édition
comme par le shell, à ses sous-agents : un dossier qui contient la spec compte comme la spec,
de même qu'une écriture dont seul le shell connaît l'endroit (xargs sed -i, cd dir; sed -i),
tandis qu'un find -exec est jugé sur les dossiers d'où il part, et que les lectures par l'un ou
l'autre restent libres. La session elle-même peut en écrire une nouvelle version,
que acceptance signale et sur laquelle l'agent acceptance-judge se prononce. Une commande qui
écrit le verrou d'une acceptation ou un verdict (jugée par les endroits qu'elle écrit, un glob
étendu, et non par son texte ; un dossier qui les contient, test/acceptance ou test, compte
comme eux, et de même un endroit que seul le shell connaît sur une ligne qui nomme l'acceptation)
est refusée : une commande peut changer de répertoire ou tester un chemin (cd, pushd, popd,
pwd, test), lire le fichier (cat, grep, rg sans --pre, sed sans -i, awk, less,
jq), le versionner (git add, commit sans -a, log, show, status, aucun avec
--output) ou lancer le kit (ddd-ts-kit, npx ddd-ts-kit) ; tout autre programme (un npx ou
pnpm nu, git checkout/stash), ou une redirection vers un fichier, est une écriture, que seuls
la CLI et cet agent font. Le juge lui-même lit git sans ajouter ni committer, et ne lance le kit
que pour lire (acceptance sans --lock, list, describe, explain, status, story,
stories, story-check). Aucun hook ne tourne sur
chaque appel d'outil : une session ordinaire ne lance pas plus de processus qu'avant. En cas de
panne, il laisse passer : une garde cassée ne bloque jamais le travail, ce qui en fait un guide, pas une frontière de sécurité : il lance la CLI ddd-ts-kit et le Biome du projet lui-même depuis node_modules (le bin que nomme chaque paquet, avec Node, jamais un paquet installé au-dessus du sommet du dépôt, ni une config ou une CLI dans un dossier qu'un autre utilisateur peut écrire, le répertoire temporaire partagé avant tout ; sous le profil réglementé, il ne lance ni l'une ni l'autre, donc aucune vérification à l'écriture ni à l'arrêt), et de ce qu'écrit un code qu'il ne peut pas lire, il ne compare que ce qui est noté plus haut : les autres fichiers ignorés par git et les endroits hors de ces checkouts ne sont pas énumérés, et l'état qu'il garde entre deux appels se trouve dans le projet, à portée d'un code qui vise la garde ; pour isoler un agent, voir Isoler les agents de code. Mettez "guard": "advise" dans la
configuration pour être consulté au lieu d'essuyer un refus, "off" pour le faire taire.
Chaque agent reçoit ce que son hôte exécute. Les skills fonctionnent dans les trois. Les six
agents sont des sous-agents de Claude Code ; Codex ne charge aucun agent depuis un plugin, et une
session par worktree tient le rôle de context-builder. Le hook tourne partout où l'hôte exécute
les hooks d'un plugin : il lit les patchs de Codex, les appels d'outils de Copilot et les outils
d'édition de VS Code aussi bien que ceux de Claude Code. VS Code ne garde aucun matcher : chaque
hook d'un événement y tourne sur chaque outil : un outil que la garde nomme lecteur (read_file,
list_dir, les recherches, memory quand il consulte) n'écrit rien, et un outil qu'elle ne nomme
pas qui donne un path est jugé comme une écriture
(ADR-0007). Codex ne sait pas
poser de question à l'utilisateur : ce que Claude Code
soumet au propriétaire du projet y est signalé à l'utilisateur, et laissé aux vérifications du
pipeline.
Même sans plugin, un projet guide chaque agent : init écrit AGENTS.md, le guide que lisent
Codex, Copilot et la plupart des agents (CLAUDE.md l'importe ; sa section ## Verifying your work donne chaque commande de vérification avec les lignes qu'elle affiche quand elle passe, à
lancer avant de se dire fini et à coller, une vérification qui échoue corrigée dans le code et
jamais dans la vérification, et sa section ## Mistakes seen here est celle de l'équipe : un
constat de revue ou un TODO(review) fait deux fois y devient une ligne, ou une règle de la
configuration, la règle de deux qu'appliquent l'agent architecture-reviewer et le skill
quality-gate, d'après le playbook AI-native SDLC d'Anthropic,
PDF),
les règles par couche pour
Claude Code dans .claude/rules/ et les mêmes règles pour Copilot dans .github/instructions/,
ciblées par applyTo, REVIEW.md, la politique de revue que lit chaque relecteur, écrite une
fois et possédée par l'équipe (Travailler en équipe),
.claude/settings.json, les permissions de Claude Code (les vérifications et les générateurs
s'exécutent sans demander ; .env et les contrats générés ne sont jamais lus ni modifiés ;
generate et init avec --force, git push, npm publish, les fichiers qui portent les règles et le pipeline, les migrations de
l'ORM, Dockerfile, docker-compose.yml et docker/ demandent d'abord : la liste est dans le
README de la CLI, et ddd-ts-kit doctor dit ce qu'un
projet en manque ; init --agent-profile regulated ajoute le bloc de bac à sable et les deux
hooks d'une organisation réglementée,
Mettre les agents de code en bac à sable), et, avec le
pipeline GitHub, copilot-setup-steps.yml, qui installe le
projet avant le démarrage de l'agent cloud de Copilot. npm run verify et le pipeline tiennent
chaque agent aux mêmes règles.
Ce qui tient chaque skill
Section intitulée « Ce qui tient chaque skill »Une skill est un conseil : elle dit à un agent quoi lancer et quoi décider, et un agent peut
l'ignorer. Le playbook du cycle de vie AI-native d'Anthropic
dit ce qu'une équipe soumise à une réglementation demande avant d'accepter la moindre skill :
une politique qui doit toujours tenir a besoin de quelque chose de déterministe derrière elle, un
hook qui bloque l'action ou un contrôle qui l'attrape ensuite. Cette table nomme ce contrôle
pour chaque skill du plugin : les identifiants de règle de ddd-ts-kit rules (tenus par le
checker, le plugin ESLint ou dependency-cruiser, voir
qui vérifie quoi), les gardes du hook, et les
contrôles du pipeline. Un test du plugin (node --test plugin/skills/controls.test.mjs) échoue
quand un identifiant de règle nommé ici est inconnu de la CLI, ou quand une skill n'a pas de
ligne.
| Skill | Contrôle déterministe derrière elle | Manque |
|---|---|---|
start |
ddd-ts-kit status lit docs/architecture/plan.md et slices.md et nomme la prochaine étape ; la garde rappelle la démarche au démarrage de session |
la forme de plan.md est lue, pas vérifiée |
discover-domain |
aucun en propre : docs/architecture/discovery.md est lu par les étapes suivantes, pas vérifié |
la vérité stratégique ne se vérifie pas, comme le dit la méthodologie |
bounded-contexts |
context/no-cycle, context/extractable, tree/context-doc (chaque contexte a son CONTEXT.md), docs --check |
la classification d'un contexte est lue, pas jugée |
glossary |
le générateur refuse un nom que le glossaire ne tient pas ; language/glossary-term, language/declared-vocabulary, language/no-technical-name |
|
context-map |
context/no-cycle, context/declared-relationship, context/published-language-only, context/published-language-is-a-contract, la carte des contextes régénérée et comparée par docs --check |
|
bootstrap |
init écrit un projet vert sous npm run verify ; config/valid ; doctor --strict |
|
plan-slices |
status, story-check et worker-scope --rows lisent les lignes de slices.md et refusent une ligne inconnue ; plan-waves rejoue les commandes de génération des lignes et refuse un nom dont le glossaire ne définit pas les mots, toute commande que le générateur refuse, avec son refus sous la ligne, et une ligne qui s'appuie sur ce que génère une ligne qu'elle n'attend pas ; verify-slice |
l'ordre des lignes est conseillé (plan-waves), jamais refusé |
parallel-work |
la garde du worker (.ddd-ts-kit/worker.json : une écriture hors du contexte est refusée, par les outils d'édition et par le shell), verify-merge, merge-trunk, status --workers |
|
intent |
story-scope --from refuse une intention dont le statut n'est pas accepted ; le bloc ## Origin de la story, que story --gate close exige |
le contenu d'une intention est lu par des personnes, pas vérifié |
story |
story --gate build et --gate close, la garde dans le worktree d'une story (pas de code avant la revue de conception et le verrou), acceptance --lock, test/acceptance-black-box, l'agent acceptance-judge |
la passe de conception de story-check tient les noms, pas le comportement |
fix |
story-scope --kind fix, acceptance <code> --gate written et --lock sur les specs de régression de ## Regression, la garde dans le worktree d'un correctif (pas de code avant le verrou, aucune édition d'une spec verrouillée par un sous-agent), l'agent acceptance-judge |
la spec verrouillée est tenue inchangée ; qu'elle passe est prouvé par le lanceur de tests, pas par acceptance |
pull-request |
les vérifications de la pull request et la protection de branche (un code owner approuve) ; la garde du worktree de la story pendant qu'il travaille | rien du kit ne lit les fils de revue : le skill le fait |
scaffold |
la garde refuse un fichier de rôle écrit à la main ; tree/closed, tree/documented-paths, naming/suffix, naming/one-concept-per-file, naming/business-name, naming/search-not-list, test/spec-required, test/builder-required, lifecycle/status-through-machine, process/sends-commands-only, scheduling/job-name, scheduling/job-registered, scheduling/job-triggers-use-case |
|
use-case |
les contrôles de scaffold, puis application/handler-shape, application/command-query-separation, domain/aggregate-encapsulation, domain/value-object-class, domain/value-object-immutability, domain/no-generic-error, domain-events/dispatched-on-save, domain-events/transactional-before-commit, errors/code-listed, errors/code-unique, errors/through-factory, files/upload-content-rule, presentation/controller-shape, presentation/controller-delegates, schema/presentation-only, schema/no-duplicate-shape, les tests du contexte lancés par verify-slice |
|
integration-event |
events/defined-in-published-language, events/name-declared-once, events/name-format, events/outbox-required, events/consumer-idempotent, event-sourcing/upcaster-required (le verrou des événements stockés), le catalogue d'événements et le document AsyncAPI comparés par docs --check |
|
wiring |
ports/abstract-class, ports/no-token-constant, ports/no-concrete-dependency, ports/implements-never-extends, ports/value-import, declarations/role-declared, declarations/constructor-injection, declarations/barrel-current, declarations/port-adapter-wired, composition/only-in-module, le barrel régénéré par docs |
|
persistence |
layer/domain-purity, layer/application-inward, files/port-not-connector, search/store-from-platform, persistence/migration-history, persistence/primary-key-order, persistence/no-file-content, persistence/read-model-listed, tenancy/scoped-statement, les suites de contrat, le seuil de couverture de infrastructure/ (test/coverage-governed) |
un adaptateur sans sa suite de contrat n'est signalé par test/spec-required que quand son fichier de spec manque |
access-control |
authz/declared, authz/granted, authz/in-application, authz/actor-explicit, authz/policy-asked, authz/scope-narrows, authz/resource-modelled, authz/system-actor-granted, authz/fields-by-schema, presentation/guard-at-the-edge |
|
cross-cutting |
aspects/outside-in, aspects/timeout-covers-delegate, tracing/platform-only, standard/no-parallel-interface, purity/no-system-clock, purity/no-ambient-randomness, purity/no-environment, presentation/shared-cache-varies |
|
testing |
test/no-mocks, test/spec-required, test/builder-required, test/helper-placed, test/coverage-governed, test/acceptance-black-box, la forme d'un test (test/no-only-no-skip, test/title-states-a-rule, test/no-logic, test/assertion-present, test/refusal-by-code, test/no-snapshot), le verrou de l'acceptation |
une spec de régression n'est verrouillée que dans une story de correctif |
clean-code |
clean/stepdown, clean/function-size, clean/file-size, clean/blank-lines, clean/braces, clean/one-export-per-file, clean/no-escape-hatch, clean/no-commented-out-code, clean/no-noise-comment, clean/no-flag-argument, clean/no-hash-private, clean/no-magic-number, clean/formatted (Biome dans le hook de commit et dans le pipeline), language/no-technical-name |
le formateur tourne au commit et en CI, pas à l'écriture |
document |
docs --check (npm run docs:check, la porte docs du pipeline), declarations/barrel-current, tree/context-doc, sdk --check |
|
extract-service |
context/extractable, context/published-language-only, imports/alias-only, le point d'entrée par contexte qu'écrit generate service et son test de démarrage |
|
deviation |
governance/recorded-deviation, config/suppression-needs-reason, config/rule-off-everywhere, la garde demande l'avis du propriétaire avant une désactivation, un test sauté ou un changement des règles |
|
quality-gate |
npm run verify, le hook Stop de la garde (il refuse de terminer tant que des erreurs d'architecture restent dans les changements non committés), le job gate du pipeline |
|
commit-discipline |
check --commit-size (un conseil), commitlint dans le hook commit-msg et le contrôle du titre du pipeline |
la taille est conseillée, jamais refusée : un choix du kit, conservé |
Deux manques n'appartiennent à aucune skill : un secret dans un diff n'est attrapé que par gitleaks dans le pipeline, et la mise en page d'un fichier est réglée au commit, pas à l'écriture.
Évaluer vos propres skills
Section intitulée « Évaluer vos propres skills »Un projet qui écrit ses propres skills (une politique de l'organisation, une convention d'une
équipe) peut les tenir au même test : un répertoire evals/ à côté d'elles, lancé par
claude plugin eval, un cas par promesse, avec les vraies tâches du projet comme prompts et
des évaluateurs qui lisent le résultat. Le kit ne génère rien pour cela : la suite du playbook se
construit à partir des tâches du projet, qu'aucun template ne connaît. La suite du plugin
lui-même, sous plugin/evals/ du dépôt, est un exemple travaillé, et
CONTRIBUTING.fr.md dit comment un cas
s'écrit, quand on en ajoute un et ce qu'il coûte.