@roomi-fields/grillhouse 0.0.0-stage → 0.23.0

package/cadre/templates/projet/tests/unit/types.spec.ts

@@ -0,0 +1,73 @@
+/**
+ * Types module tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { success, failure, type Result } from '../../src/types/index.js';
+
+describe('Types', () => {
+  describe('Result type', () => {
+    describe('success', () => {
+      it('should create a success result', () => {
+        const result = success(42);
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.data).toBe(42);
+        }
+      });
+
+      it('should work with objects', () => {
+        const data = { id: 1, name: 'Test' };
+        const result = success(data);
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.data).toEqual(data);
+        }
+      });
+
+      it('should work with arrays', () => {
+        const data = [1, 2, 3];
+        const result = success(data);
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.data).toEqual(data);
+        }
+      });
+    });
+
+    describe('failure', () => {
+      it('should create a failure result', () => {
+        const error = new Error('Something went wrong');
+        const result = failure(error);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBe(error);
+        }
+      });
+
+      it('should work with custom error types', () => {
+        const customError = { code: 'CUSTOM', message: 'Custom error' };
+        const result = failure(customError);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toEqual(customError);
+        }
+      });
+    });
+
+    describe('type narrowing', () => {
+      it('should narrow types correctly', () => {
+        function processResult(result: Result<number, string>): string {
+          if (result.success) {
+            return `Value: ${result.data}`;
+          } else {
+            return `Error: ${result.error}`;
+          }
+        }
+
+        expect(processResult(success(42))).toBe('Value: 42');
+        expect(processResult(failure('oops'))).toBe('Error: oops');
+      });
+    });
+  });
+});

package/cadre/templates/projet/tsconfig.eslint.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": "."
+  },
+  "include": ["src/**/*", "tests/**/*", "*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/cadre/templates/projet/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    /* Language and Environment */
+    "target": "ES2022",
+    "lib": ["ES2022"],
+
+    /* Modules */
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "resolveJsonModule": true,
+
+    /* JavaScript — a JS project, or one migrating to TS, compiles as is */
+    "allowJs": true,
+    "checkJs": false,
+
+    /* Emit */
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+
+    /* Interop Constraints */
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+
+    /* Type Checking */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    /* Completeness */
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.{test,spec}.{ts,js,mjs}"]
+}

package/cadre/templates/projet/tsdoc.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+  "extends": ["@microsoft/api-extractor/extends/tsdoc-base.json"],
+  "tagDefinitions": [{ "tagName": "@faute", "syntaxKind": "block", "allowMultiple": true }],
+  "supportForTags": { "@faute": true }
+}

package/cadre/templates/projet/vitest.config.ts

@@ -0,0 +1,44 @@
+import { defineConfig, mergeConfig } from 'vitest/config';
+import base from '@roomi-fields/grillhouse/vitest-config';
+
+// The day's tests of the project: the frame's base configuration (its exclusions of the night
+// tests and the time budget benches, its common environment), by its name, the frame's package's,
+// extended with what is the root's own.
+export default mergeConfig(
+  base,
+  defineConfig({
+    test: {
+      // Global test configuration
+      globals: true,
+
+      // Include patterns
+      include: ['src/**/*.{test,spec}.{ts,js,mjs}', 'tests/**/*.{test,spec}.{ts,js,mjs}'],
+
+      // Coverage configuration
+      coverage: {
+        provider: 'v8',
+        reporter: ['text', 'json', 'html'],
+        reportsDirectory: './coverage',
+        include: ['src/**/*.{ts,js,mjs}'],
+        exclude: ['src/**/*.{test,spec}.{ts,js,mjs}', 'src/**/types.ts', 'src/**/index.{ts,js}'],
+        thresholds: {
+          lines: 80,
+          functions: 80,
+          branches: 80,
+          statements: 80,
+        },
+      },
+
+      // Test timeout
+      testTimeout: 10000,
+
+      // Pool options for parallel execution
+      pool: 'threads',
+      poolOptions: {
+        threads: {
+          singleThread: false,
+        },
+      },
+    },
+  })
+);

package/cadre/templates/turbo/paquets.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://turborepo.com/schema.json",
+  "ui": "stream",
+  "globalPassThroughEnv": [
+    "GRILLHOUSE_RESULTATS",
+    "GRILLHOUSE_CHANGEMENTS",
+    "GRILLHOUSE_AVANCEMENT",
+    "TMPDIR"
+  ],
+  "tasks": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist/**"]
+    },
+    "test:vitest": {
+      "dependsOn": ["build", "^build"],
+      "env": ["GRILLHOUSE_TESTS"],
+      "outputs": []
+    },
+    "//#grillhouse:gardes": {
+      "dependsOn": [],
+      "outputs": []
+    },
+    "//#gardes": {
+      "dependsOn": [],
+      "outputs": []
+    }
+  }
+}

package/cadre/templates/turbo/sans-paquets.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://turborepo.com/schema.json",
+  "ui": "stream",
+  "globalPassThroughEnv": [
+    "GRILLHOUSE_RESULTATS",
+    "GRILLHOUSE_CHANGEMENTS",
+    "GRILLHOUSE_AVANCEMENT",
+    "TMPDIR"
+  ],
+  "tasks": {
+    "build": {
+      "outputs": ["dist/**"]
+    },
+    "grillhouse:gardes": {
+      "dependsOn": ["build"],
+      "outputs": []
+    },
+    "gardes": {
+      "dependsOn": ["build"],
+      "outputs": []
+    },
+    "test:vitest": {
+      "dependsOn": ["build"],
+      "env": ["GRILLHOUSE_TESTS"],
+      "outputs": []
+    }
+  }
+}

package/charte.md

@@ -0,0 +1,107 @@
+# La charte commune de Roomi's Grillhouse
+
+Les règles que tout agent applique, identiques dans chaque projet qui installe le cadre. La charte
+du projet (`CLAUDE.md`) l'importe depuis le paquet installé et porte ce qui lui est propre : son
+nom, son responsable, ce qui décide chez lui, ses critères d'arbitrage, ses commandes. Le détail
+d'un rôle vit dans sa compétence, celui d'un outil dans l'architecture du paquet
+(`node_modules/@roomi-fields/grillhouse/docs/ARCHITECTURE.md`). Ce fichier ne se modifie pas
+dans un projet : un écart se propose à Grillhouse. Ainsi les projets suivent un seul cadre, et
+chaque séance ne charge que ce qu'elle applique.
+
+## Ce qui décide
+
+Une décision vit dans le document qu'elle règle. Ainsi on la trouve là où on la cherche.
+
+Une règle s'écrit selon le métacadre (`METACADRE.md`, à côté de cette charte, §2).
+
+## Comment on arbitre
+
+Une décision ou une question se tranche par les questions de la charte du projet (« Comment on
+arbitre »), dans leur ordre : la première qui s'applique l'emporte, et le choix la nomme ; deux
+réponses de même rang vont au responsable. Ainsi chaque choix construit un produit mature et
+professionnel.
+
+## Le flux d'une tâche
+
+1. `bd ready`, `bd update <id> --claim`, lis le ticket et le cadre de chaque composant touché.
+2. Un défaut remonté est d'abord une question d'architecture : le ticket s'ouvre sur sa section
+   « Architecture » (le modèle mûr nommé, l'adresse dans l'architecture, le mécanisme commun), et
+   le correctif va dans ce mécanisme. Ainsi tout correctif passe par l'architecture.
+3. Une décision reste à prendre : `mattpocock-skills:grilling` avant d'écrire, ses questions dans
+   le ticket. Ainsi la décision est prise et écrite avant le code.
+4. Le plan va dans le ticket (`bd update <id> -d`). Un travail qui change un comportement est un
+   seul ticket : les tests d'abord (agent `testwriter`), puis le code qui les rend verts (agent
+   `developpeur`). Ainsi le code se mesure à des tests qu'il n'a pas écrits. Un critère répond à
+   un besoin réel de l'usage actuel. Ainsi le ticket garde la taille du besoin.
+5. Le ticket se ferme sur ses tests ciblés, le verdict du `relecteur` sur le lot et le commit du
+   circuit, seul à commiter, entré sur main par la file. Ainsi ce qui est déclaré fini l'est
+   vraiment.
+6. Chaque agent laisse sa passation en commentaire au ticket (`bd comments add`), avec ce qui
+   n'est pas fait et pourquoi ; une séance que le circuit mène finit sur sa fiche, la sortie
+   structurée de son rôle, sur laquelle le circuit décide. Ainsi la passation sert l'humain, et
+   la fiche le circuit.
+
+Un ticket parcourt les étapes de son circuit (`etapes.mjs`, la seule liste), chacune tenue par un
+rôle, agent du cadre, sous ses droits. Ainsi chaque agent travaille dans son cadre, et le numéro
+d'une étape dit où en est chaque ticket.
+
+**Tous les agents jugent sur le plan** : une décision du responsable entre dans la description du
+ticket, comme une RFC amendée ; les commentaires restent l'historique. Ainsi chaque agent lit la
+même décision.
+
+**Un ticket de réalisation nomme ses composants** dans son titre (« numéro — sujet — composant,
+composant ») et sa section « Architecture », le fournisseur d'abord ; il fait une seule livraison,
+en un seul commit, et se crée sous sa mère (`docs/agents/issue-tracker.md`). Un objectif dont le
+découpage n'est pas connu commence par une exploration, sans code. Ainsi l'avancement se lit
+ticket par ticket.
+
+**Un ticket ouvert naît du mot du responsable**, ou d'un défaut qu'un projet du cadre rencontre.
+Une découverte d'agent se consigne dans un ticket fermé, sous le ticket qui l'a trouvée, étiqueté
+`decouverte`. Ainsi chaque découverte est gardée, et le backlog reste le plan du responsable.
+
+## Ce qui tient le dépôt droit
+
+- **Une matière, une adresse** : ce qu'un document décrit déjà s'y verse. Ainsi l'architecture
+  écrite reste une, et le code suit une seule version.
+- **Un changement de comportement corrige ses textes** dans le même commit. Ainsi les documents
+  restent vrais.
+- **Une décision de structure passe par le grill** (compétence `grill`) : découpage, paquets,
+  modules, interfaces, frontières. Ainsi l'architecture décide de la structure, et le code la suit.
+- **Un geste transverse, un seul ticket** : un même changement sur plusieurs composants se décide
+  une fois, en gabarit dans la section « Architecture », et se mène dans une seule copie. Ainsi le
+  geste reste le même partout.
+- **Les composants suivent un modèle commun** : chacun étend les configurations de base du cadre ;
+  un écart passe seulement inscrit, avec sa raison, dans la liste que le superviseur valide.
+  Ainsi le cadre ne maintient aucune spécificité par composant.
+- **Une dette connue s'inscrit et se gèle** (`grillhouse-dette.json`) : une garde refuse tout
+  constat neuf, et le compte ne remonte jamais. Ainsi la dette ne fait que baisser.
+- **Un remplacement supprime le remplacé** dans le même commit, avec ses consommateurs et ses
+  gardes. Ainsi le produit garde une seule façon de faire chaque chose.
+- **Un commentaire dit ce que la chose est**, au présent. Ainsi il reste vrai tant que le code ne
+  change pas.
+
+## Outils
+
+- ⛔ **Des commandes sans invite** : tout fichier temporaire dans le scratchpad de session ;
+  `env -C <dossier>` ou `git -C` à la place de `cd` ; une suppression passe par un script node du
+  scratchpad (`rmSync` de `node:fs`) sur un chemin nommé et lu ; un signal vise seulement un
+  processus que la séance a lancé. Une commande dont on doute s'écrit dans le compte rendu, sans
+  se lancer. Ainsi la séance avance seule.
+- **Les tests se lancent par `npm test`** : `npm test -- <chemins>` pour un lancement ciblé,
+  chaque chemin écrit depuis la racine du dépôt ; `npm run test:forcer -- <chemins>` pour rejouer
+  pour de vrai un test soupçonné instable. `npm run verifier` joue les gardes et les tests ;
+  `npm run verifier -- --gardes`, les gardes seules. Aucun agent ne lance l'outil de test
+  directement. Ainsi chaque test tourne avec ce dont il dépend, et une seule fois tant que rien ne
+  change.
+- **Main reste vert** : l'intégration exige un `npm run verifier` vert. Un test connu rouge se met
+  en quarantaine dans le test lui-même (`it.skip` ou `it.fails`), avec le ticket qui le corrige.
+  Ainsi chaque rouge a son ticket.
+- **L'index d'abord** : toute recherche commence par `rtfm_search` (mode `hybrid`) pour le quoi, et
+  par `codegraph explore` (ou l'outil `codegraph_explore`) pour l'appel ; le shell lit un fichier
+  déjà nommé. Dans son enveloppe, un agent lit son paquet, les interfaces de ses voisins, la
+  matière de test partagée et ce que ses tests déclarent lire (`grillhouse.lit`). Ainsi une
+  affirmation sur le code repose sur ce que le code contient.
+- Tickets : Beads (`bd`), sous le préfixe du projet, voir `docs/agents/issue-tracker.md`.
+- Le greffon `mattpocock-skills` s'appelle avec son préfixe ; un document pour un agent s'écrit
+  avec `mattpocock-skills:writing-for-agents`.
+- Réponses en français ; le code et les noms d'API restent en anglais.

package/docs/ARCHITECTURE.md

@@ -0,0 +1,90 @@
+# Les outils du cadre
+
+Ce que font les outils du paquet `@roomi-fields/grillhouse`, que la charte commune résume pour
+les agents. Chaque règle dit le comportement, et le modèle mûr qu’il suit.
+
+**Les tests se lancent par `npm test`** (Turborepo : la construction, puis les tests) :
+`npm test -- <chemins>` pour un lancement ciblé, chaque chemin écrit depuis la racine du dépôt
+et joué dans son paquet avec ce dont ses tests dépendent (un autre jeu de chemins relit les
+constructions du cache ; un changement de ce qu'ils importent les rejoue),
+`npm run test:forcer -- <chemins>` pour rejouer pour de vrai un test soupçonné instable ; un
+lancement qui ne joue aucun test échoue ; un banc de temps ou un test de nuit se joue quand son
+propre fichier est nommé, au repos (un dossier ou un paquet nommé les laisse hors, comme le
+jour) ; aucun agent ne lance l'outil de test directement. `npm run verifier` joue, après la
+construction : les gardes du cadre,
+celles du projet (son script racine `gardes`, un nom que le cadre réserve ; une garde juge les
+fichiers de l'arbre de travail, que le cache de Turborepo compte, jamais l'index de git ; elle
+écrit ses constats en SARIF, chacun avec son fichier et sa ligne, par `ecrireSarif` de
+`packages/grillhouse/scripts/resultats.mjs`, dans le dossier que nomme `GRILLHOUSE_RESULTATS`, et sans eux son rouge
+ne revient à aucun composant) et les tests, côte à côte ; un rouge n'arrête pas la passe, qui joue tout ce que ses tâches
+préalables permettent et nomme chaque rouge ; `npm run verifier -- --gardes` joue les gardes
+seules, ce que le relecteur joue sur la copie du ticket. Une tâche dont
+rien n'a bougé n'est pas rejouée : Turborepo relit sa sortie consignée dans son cache (« cache
+hit, replaying logs »), et cette relecture vaut un lancement. Une passe se mesure contre le
+dernier vert, l'arbre de la dernière passe verte de sa branche, celle de main pour une copie
+qui n'en a pas encore, comme `vitest --changed` : un paquet que Turborepo rejoue joue les seuls tests que Vitest relie aux fichiers changés depuis,
+et tous ses tests quand un changement sort du graphe de Vitest (un fichier supprimé, une
+configuration, un fichier qu'aucun module n'importe, le code d'un paquet dont il dépend, un
+chemin que ses tests déclarent lire, `grillhouse.lit`) ; sans vert connu, la passe est
+complète, et `npm run verifier -- --tout` la joue pour de vrai, comme la nuit. Ainsi un test ne
+tourne qu'une fois tant que rien ne change, et corriger un test ne rejoue que lui.
+
+**Une passe écrit sous sa base** : chaque lancement de Vitest, `npm test`, `npm run verifier`,
+un circuit, une intégration et une enveloppe ouvrent leur base dans le dossier temporaire, la
+nomment dans `TMPDIR` à ce qu'ils lancent (les dossiers d'essai des tests, celui de Vitest, celui
+de Claude Code) et l'effacent à leur fin, verte ou rouge ; la base d'une passe tuée, la suivante
+la balaie, comme Bazel donne à chaque test son `TEST_TMPDIR` et nettoie ses bacs à sable
+(`packages/grillhouse/scripts/vitest-config/base-de-passe.mjs`). Ainsi un essai oublié ne remplit jamais le dossier
+temporaire de la machine.
+
+**Le dossier du circuit appartient au ticket** : `.claude/worktrees/<ticket>.travail` vit autant
+que le ticket, comme l'espace de travail d'un pipeline ; aucun balayage n'y touche, la file
+l'efface à la clôture, `npx grillhouse retirer-copie` avec la copie d'un ticket fermé sans
+intégration. Ainsi une séance qui survit à son circuit garde ce qu'il lui a remis.
+
+**Main reste vert** : l'intégration exige un `npm run verifier` vert, sans rouge admis, mesuré
+contre le dernier vert ; la nuit rejoue la passe complète. Un test connu
+rouge se met en quarantaine dans le test lui-même (`it.skip` ou `it.fails`), avec le ticket qui
+le corrige, comme le fait une intégration continue mature. Ainsi chaque rouge a son ticket, et
+main ne porte aucun rouge.
+
+**Une mesure lourde à la fois sur la machine** : chaque `npm run verifier` et chaque passe
+lourde du circuit (preuve du rouge, contrôles, passe finale) prennent le verrou de la machine,
+partagé par tous ses dépôts (`~/.cache/grillhouse/mesure-lourde.lock`) ; une seconde mesure
+attend la fin de la première et le redit toutes les 30 s, en nommant qui tient le verrou (le
+processus, son dossier, sa commande, depuis quand) ; un verrou dont le processus est mort se
+reprend, comme le serveur de tâches de GNU make. L'attente a une borne, 60 min
+(`GRILLHOUSE_ATTENTE_MACHINE_MS`), plus longue que la plus longue passe complète mesurée : au-delà,
+la mesure s'arrête « à repasser » (code 75), comme `flock -w`. Un verrou tenu par un ancêtre de
+celui qui attend est un blocage : l'attente le dit tout de suite et s'arrête, rouge. La passe
+borne ses tâches côte à côte à la moitié des cœurs. Ainsi une mesure rend le résultat du code, et
+non celui d'une autre mesure à côté, et aucune passe ne reste figée sans le dire.
+
+**Une passe automatique montre son avancement** : chaque passe automatique écrit ses fichiers
+de tests faits sur prévus (la file, les étapes de sa CI), que le panneau affiche avec le temps
+depuis son dernier signe, « ⚠ figée » au-delà de 5 min, comme le compteur d'actions de Bazel.
+Ainsi une passe qui fige se voit.
+
+**Un témoin de temps joue seul** : un fichier de test qui importe `mesurerAuRepos` est un
+témoin de temps ; `npm run verifier` joue tous les autres tests, puis les témoins dans une passe
+à eux, une tâche après l'autre, comme Bazel joue un test `exclusive`. Un échec qui dépend d'une
+durée (un délai dépassé, un banc `*.budget.test.*`, un test marqué `mesurerAuRepos`) survenu sous
+charge (la pression CPU du noyau, `/proc/pressure/cpu`, à 25 % ou plus) est « à repasser » (code
+75), ni vert ni rouge : `npm run verifier` rejoue sa tâche seule une fois la machine au repos ;
+sans repos en 15 min, la livraison reste en attente et se représente, comme Bazel classe un
+délai dépassé et CTest le rejoue. Ainsi un témoin ne se mesure jamais sous la charge de sa
+propre passe, et un rouge au repos reste un rouge.
+
+**Le cadre arrive en un seul morceau** : le paquet npm `@roomi-fields/grillhouse` porte les
+scripts, appelés par `npx grillhouse <sous-commande>`, et il est le greffon `grillhouse`, qui
+porte les compétences, les agents, les crochets de Claude Code, cette charte et le métacadre,
+comme un paquet d'ESLint porte son greffon. La place de marché `roomi-fields`
+(`roomi-fields/claude-plugins`) le désigne par sa source npm ; le projet la déclare et active
+`grillhouse@roomi-fields` (`npx grillhouse maj`). Ce qui est propre à un projet (sa charte, ses
+réglages, sa version du paquet) vit dans le projet, jamais dans ce qui se publie. Une version de
+npm vaut pour les deux ; l'ouverture de séance nomme un greffon chargé à une autre version que
+le paquet du projet, avec la commande qui les remet d'accord. Un projet n'en garde aucune copie ; sans le paquet installé, l'ouverture de séance dit « lance `npm install` », et les autres crochets
+sortent sans effet. Les crochets git du cadre suivent le modèle de Husky : le `prepare` du
+projet lance `grillhouse hooks`, qui les pose à côté des sections de Beads, et chacun appelle
+`grillhouse hook <nom>`, sans effet sans le paquet. Ainsi chaque projet suit la version du cadre qu'il installe, sans fichier à
+recopier.

package/hooks/crochet.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// The hooks of Claude Code the frame's plugin declares (hooks.json): each runs
+//
+//   node "${CLAUDE_PLUGIN_ROOT}/hooks/crochet.mjs" <sous-commande>
+//
+// with Node alone, before any installation, as Husky's hooks run before the project's tools.
+//
+// - The project is `CLAUDE_PROJECT_DIR`, else the working directory; its command is
+//   `node_modules/.bin/grillhouse`, which the project's `npm install` links (the package
+//   @roomi-fields/grillhouse).
+// - The common charter reaches each session, a subagent's included, by the import of the
+//   project's CLAUDE.md, from the package installed, which Claude Code loads whole; no hook writes it, since Claude Code caps a hook's output (10,000 characters).
+// - Each subcommand runs `grillhouse <sous-commande>`; without the command, `session-start` writes
+//   a section that says to run `npm install`, and any other subcommand exits 0 and writes nothing.
+// - The command receives the hook's input on its standard input, writes on the hook's outputs, and
+//   its exit code is the hook's (2 blocks, as Claude Code reads it).
+import { spawnSync } from 'node:child_process';
+import { existsSync, writeSync } from 'node:fs';
+import path from 'node:path';
+
+const sous = process.argv[2] ?? '';
+const projet = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const commande = path.join(projet, 'node_modules', '.bin', 'grillhouse');
+
+if (existsSync(commande)) {
+  const r = spawnSync(commande, [sous], { stdio: 'inherit', cwd: projet });
+  process.exitCode = r.status ?? 1;
+} else if (sous === 'session-start') {
+  writeSync(
+    1,
+    "## Paquet Roomi's Grillhouse absent\nLe projet n'a pas encore installé le paquet du cadre (`node_modules/.bin/grillhouse`, @roomi-fields/grillhouse) : lance `npm install` à la racine du projet, puis rouvre la séance. La charte commune, que CLAUDE.md importe du paquet, arrive avec lui.\n"
+  );
+}

package/hooks/hooks.json

@@ -0,0 +1,58 @@
+{
+  "modules": [
+    "./register.tsx"
+  ],
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/crochet.mjs\" session-start"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/crochet.mjs\" structure-guard"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Agent|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/crochet.mjs\" ticket-du-sous-agent"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/crochet.mjs\" registre"
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/crochet.mjs\" registre"
+          }
+        ]
+      }
+    ]
+  }
+}