create-go-plate 0.0.0-stage → 0.1.1

package/modules/claude/.claude/hooks/format.mjs

@@ -0,0 +1,37 @@
+// PostToolUse : formate automatiquement chaque fichier modifié par l'agent.
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { projectDir, readStdinJson, relativeToProject } from "./lib.mjs";
+
+// À RENSEIGNER pendant /cadrage, une fois la stack choisie. Le chemin du fichier est ajouté à la fin.
+// Exemples :
+//   "npx prettier --write --ignore-unknown"   (JS/TS, CSS, Markdown…)
+//   "npx @biomejs/biome format --write"        (JS/TS)
+//   "ruff format"                              (Python)
+//   "gofmt -w"                                 (Go)
+// Laisser vide désactive le formatage.
+const FORMAT_COMMAND = "";
+
+if (!FORMAT_COMMAND) process.exit(0);
+
+const input = readStdinJson();
+const filePath = input.tool_input?.file_path;
+if (!filePath) process.exit(0);
+
+const absolute = path.resolve(projectDir, filePath);
+const rel = relativeToProject(absolute);
+// Uniquement les fichiers du projet, hors dépendances.
+if (rel.startsWith("..") || /(^|\/)node_modules\//.test(rel) || !existsSync(absolute)) process.exit(0);
+
+const result = spawnSync(`${FORMAT_COMMAND} ${JSON.stringify(absolute)}`, {
+  cwd: projectDir,
+  shell: true,
+  encoding: "utf8",
+});
+
+if (result.status !== 0) {
+  // Code 1 = erreur non bloquante : affichée à l'utilisateur, l'agent continue.
+  process.stderr.write(`Formatage échoué pour ${rel} :\n${result.stderr || result.stdout || ""}`);
+  process.exit(1);
+}

package/modules/claude/.claude/hooks/lib.mjs

@@ -0,0 +1,32 @@
+// Utilitaires partagés par les hooks. Aucune dépendance : seulement Node.
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+export const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+export function readStdinJson() {
+  try {
+    const raw = readFileSync(0, "utf8");
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+export function readProjectFile(relativePath) {
+  try {
+    return readFileSync(path.join(projectDir, relativePath), "utf8");
+  } catch {
+    return null;
+  }
+}
+
+export function stripHtmlComments(text) {
+  return text.replace(/<!--[\s\S]*?-->/g, "");
+}
+
+// Chemin relatif au projet, avec des "/" quel que soit l'OS.
+export function relativeToProject(filePath) {
+  const absolute = path.resolve(projectDir, filePath);
+  return path.relative(projectDir, absolute).split(path.sep).join("/");
+}

package/modules/claude/.claude/hooks/protect-files.mjs

@@ -0,0 +1,69 @@
+// PreToolUse : bloque l'accès aux fichiers sensibles et les commandes git destructrices.
+// Sortie code 2 = action refusée ; le message sur stderr est renvoyé à l'agent.
+import path from "node:path";
+import { readStdinJson, relativeToProject } from "./lib.mjs";
+
+// Fichiers dont le contenu ne doit jamais être lu ni modifié par l'agent.
+const SECRET_FILE = /(^|\/)\.env(\.(?!example$)[^/]+)?$|\.(pem|key|p12|pfx)$/i;
+// Fichiers que l'agent peut lire mais ne doit modifier qu'avec les outils dédiés.
+const GENERATED_FILE =
+  /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|poetry\.lock|uv\.lock|Cargo\.lock)$/;
+const GIT_DIR = /(^|\/)\.git\//;
+
+// Commandes shell qui mentionnent un fichier .env réel (pas .env.example).
+const BASH_SECRET = /(^|[\s'"=<>|;&(/])\.env(\.(?!example\b)[\w.-]+)?(?![\w.-])/;
+const BASH_FORCE_PUSH = /\bgit\s+push\b[^;&|]*\s(--force(?!-with-lease)|-f)(\s|$)/;
+const BASH_RESET_HARD = /\bgit\s+reset\b[^;&|]*\s--hard\b/;
+
+function deny(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(2);
+}
+
+const input = readStdinJson();
+const tool = input.tool_name;
+const toolInput = input.tool_input || {};
+
+if (tool === "Bash") {
+  const command = String(toolInput.command || "");
+  if (BASH_SECRET.test(command)) {
+    deny(
+      "Bloqué par .claude/hooks/protect-files.mjs : la commande touche un fichier .env réel. " +
+        "Les secrets ne sont pas accessibles à l'agent ; demande à l'utilisateur de faire cette action lui-même " +
+        "(ou utilise .env.example pour documenter une variable)."
+    );
+  }
+  if (BASH_FORCE_PUSH.test(command) || BASH_RESET_HARD.test(command)) {
+    deny(
+      "Bloqué par .claude/hooks/protect-files.mjs : commande git destructrice (push --force / reset --hard). " +
+        "Voir docs/RULES.md. Si c'est vraiment nécessaire, l'utilisateur doit la lancer lui-même."
+    );
+  }
+  process.exit(0);
+}
+
+const filePath = toolInput.file_path || toolInput.notebook_path;
+if (!filePath) process.exit(0);
+
+const rel = relativeToProject(filePath);
+const name = path.posix.basename(rel);
+
+if (SECRET_FILE.test(rel)) {
+  deny(
+    `Bloqué par .claude/hooks/protect-files.mjs : ${name} peut contenir des secrets. ` +
+      "Documente les variables dans .env.example et demande à l'utilisateur de remplir le vrai fichier."
+  );
+}
+
+if (tool !== "Read" && GIT_DIR.test(`${rel}/`)) {
+  deny("Bloqué par .claude/hooks/protect-files.mjs : ne modifie pas le dossier .git directement, utilise les commandes git.");
+}
+
+if (tool !== "Read" && GENERATED_FILE.test(rel)) {
+  deny(
+    `Bloqué par .claude/hooks/protect-files.mjs : ${name} est généré. ` +
+      "Modifie-le via le gestionnaire de paquets (install / add / remove), pas à la main."
+  );
+}
+
+process.exit(0);

package/modules/claude/.claude/hooks/session-start.mjs

@@ -0,0 +1,50 @@
+// SessionStart : redonne à l'agent le contexte de reprise (statut du cadrage, tâches en cours,
+// dernière entrée du journal). Ce qui est écrit sur stdout est ajouté au contexte de la session.
+import { readProjectFile, stripHtmlComments } from "./lib.mjs";
+
+const MAX_CHARS = 3000;
+
+function section(markdown, title) {
+  const lines = stripHtmlComments(markdown).split("\n");
+  const start = lines.findIndex((l) => l.trim().toLowerCase() === `## ${title}`.toLowerCase());
+  if (start === -1) return "";
+  const end = lines.findIndex((l, i) => i > start && /^##\s/.test(l));
+  return lines
+    .slice(start + 1, end === -1 ? undefined : end)
+    .join("\n")
+    .trim();
+}
+
+function lastLogEntry(markdown) {
+  const text = stripHtmlComments(markdown);
+  const match = text.match(/^###\s[\s\S]*?(?=^###\s|(?![\s\S]))/m);
+  return match ? match[0].trim() : "";
+}
+
+const out = [];
+
+const agents = readProjectFile("AGENTS.md");
+if (agents) {
+  const status = section(agents, "Statut du cadrage").split("\n")[0].replace(/\*/g, "").trim();
+  if (status) out.push(`Statut du cadrage : ${status}`);
+  if (/NON FAIT/.test(status)) {
+    out.push("Le cadrage n'est pas fait : avant de coder une fonctionnalité, propose /cadrage.");
+  }
+}
+
+const tasks = readProjectFile("TASKS.md");
+if (tasks) {
+  const current = section(tasks, "En cours");
+  out.push(`Tâches en cours (TASKS.md) :\n${current || "(aucune)"}`);
+}
+
+const log = readProjectFile("docs/SESSION-LOG.md");
+if (log) {
+  const entry = lastLogEntry(log);
+  if (entry) out.push(`Dernière session (docs/SESSION-LOG.md) :\n${entry}`);
+}
+
+if (out.length) {
+  const text = `Contexte de reprise du projet\n\n${out.join("\n\n")}`;
+  process.stdout.write(text.length > MAX_CHARS ? `${text.slice(0, MAX_CHARS)}\n…(tronqué)` : text);
+}

package/modules/claude/.claude/settings.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "permissions": {
+    "deny": [
+      "Read(./.env)",
+      "Read(./.env.local)",
+      "Read(./.env.*.local)",
+      "Read(./.env.production)",
+      "Edit(./.env)",
+      "Edit(./.env.local)",
+      "Edit(./.env.*.local)",
+      "Edit(./.env.production)",
+      "Bash(git push --force *)",
+      "Bash(git push -f *)",
+      "Bash(git reset --hard *)"
+    ],
+    "ask": [
+      "Bash(git push *)",
+      "Bash(rm -rf *)",
+      "Bash(git clean *)",
+      "Bash(npm publish *)"
+    ]
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Read|Edit|Write|MultiEdit|NotebookEdit|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/protect-files.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/format.mjs\"",
+            "timeout": 60
+          }
+        ]
+      }
+    ]
+  }
+}

package/modules/claude/.mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "context7": {
+      "type": "http",
+      "url": "https://mcp.context7.com/mcp"
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"]
+    }
+  }
+}

package/modules/claude/CLAUDE.md

@@ -0,0 +1,13 @@
+@AGENTS.md
+
+<!--
+Les instructions du projet vivent dans AGENTS.md (lu par tous les agents).
+N'ajoute ici que ce qui est spécifique à Claude Code.
+-->
+
+## Spécifique à Claude Code
+
+- Pour une tâche complexe, utilise le mode plan avant d'éditer.
+- Délègue la relecture au sous-agent `reviewer` avant de déclarer une fonctionnalité terminée.
+- Les hooks de `.claude/settings.json` bloquent l'écriture des fichiers sensibles et formatent
+  le code après chaque modification : ne cherche pas à les contourner.

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "create-go-plate",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Cadrage prêt à l'emploi pour développer une application avec un agent de code (Claude Code, Codex, Cursor…) : PRD, architecture, specs, ADR, skills, hooks, CI.",
+  "type": "module",
+  "bin": {
+    "create-go-plate": "bin/create.mjs"
+  },
+  "files": [
+    "bin",
+    "template",
+    "modules",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "npm test"
+  },
+  "engines": {
+    "node": ">=20.16"
+  },
+  "keywords": [
+    "create",
+    "template",
+    "scaffold",
+    "vibecoding",
+    "ai-agent",
+    "claude-code",
+    "agents-md",
+    "spec-driven-development"
+  ],
+  "author": "Jeanpierregaba",
+  "homepage": "https://github.com/Jeanpierregaba/create-go-plate#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jeanpierregaba/create-go-plate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Jeanpierregaba/create-go-plate/issues"
+  },
+  "license": "MIT"
+}

package/template/.claude/agents/reviewer.md

@@ -0,0 +1,25 @@
+---
+name: reviewer
+description: Relecteur de code critique et indépendant. À utiliser après l'implémentation d'une fonctionnalité ou d'une tâche importante, avant de la déclarer terminée. Ne modifie pas le code.
+tools: Read, Grep, Glob, Bash
+---
+
+Tu es un développeur senior qui relit le travail d'un collègue. Tu n'écris pas de code : tu
+signales les problèmes, preuves à l'appui.
+
+Avant de commencer, lis `AGENTS.md`, `docs/RULES.md` et, si elle existe, la spec de la
+fonctionnalité dans `docs/specs/`. Regarde les changements avec `git diff` (et `git diff --staged`).
+
+Vérifie, par ordre de priorité :
+1. **Exactitude** : le code fait-il ce que demande la spec ? Les critères d'acceptation sont-ils
+   tous couverts ? Bugs, cas limites et cas d'erreur non gérés.
+2. **Sécurité** : contrôle d'accès côté serveur, validation des entrées, secrets, données exposées
+   (voir `docs/SECURITY.md`).
+3. **Respect des règles** : `docs/RULES.md`, règles d'architecture d'`AGENTS.md`, ADR.
+4. **Tests** : les tests vérifient-ils vraiment le comportement (et pas seulement qu'aucune erreur
+   n'est levée) ? Lance-les.
+5. **Simplicité** : code dupliqué, abstraction inutile, dépendance superflue, code mort.
+
+Rends une liste de constats classés (bloquant / à corriger / suggestion), chacun avec le fichier,
+la ligne, le problème concret et la correction proposée. Si tout est bon, dis-le clairement.
+N'invente pas de problème pour avoir quelque chose à dire.

package/template/.claude/agents/test-writer.md

@@ -0,0 +1,19 @@
+---
+name: test-writer
+description: Écrit des tests à partir d'une spec ou d'un comportement attendu, notamment AVANT l'implémentation pour les parties critiques (TDD). À utiliser pour les fonctionnalités listées comme critiques dans docs/TESTING.md, ou pour combler un manque de tests.
+tools: Read, Grep, Glob, Bash, Write, Edit
+---
+
+Tu écris des tests, pas le code de production.
+
+1. Lis `docs/TESTING.md` (outils et conventions), `AGENTS.md` (commandes) et la spec concernée
+   dans `docs/specs/`.
+2. Pour chaque critère d'acceptation, écris au moins un test, plus les cas limites et d'erreur
+   listés dans la spec.
+3. Les tests vérifient le comportement observable (entrées → sorties, effets), pas les détails
+   d'implémentation. Un test = un comportement, avec un nom qui le décrit en clair.
+4. Pas de mock de ce que tu peux tester pour de vrai à moindre coût (base de test, serveur local).
+5. Lance les tests :
+   - en mode TDD (code pas encore écrit), ils doivent **échouer pour la bonne raison** ;
+   - sinon, ils doivent passer. S'ils révèlent un bug, signale-le sans corriger le code de production.
+6. Rends la liste des tests écrits, leur résultat, et les cas que tu n'as pas pu couvrir.

package/template/.claude/skills/audit-securite/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: audit-securite
+description: Audit de sécurité de l'application à partir de docs/SECURITY.md - vérifie le code réel, pas seulement la doc. À utiliser avant une mise en production, après une fonctionnalité touchant l'auth, les paiements ou les données personnelles, ou sur demande.
+argument-hint: "[périmètre, optionnel : dossier, fonctionnalité ou 'tout']"
+---
+
+# Audit de sécurité
+
+Périmètre : $ARGUMENTS (par défaut : tout le projet).
+
+1. Lis `docs/SECURITY.md`, `docs/RULES.md` et la partie auth / données de `docs/ARCHITECTURE.md`.
+2. Pour **chaque point** de la checklist, vérifie dans le code (pas dans la doc) s'il est respecté.
+   Cite le fichier et la ligne comme preuve. Statut : OK / À corriger / Non applicable / Non vérifiable.
+3. Cherche en plus :
+   - secrets en dur (clés, tokens, mots de passe, URL avec identifiants), y compris dans l'historique git
+   - variables d'environnement secrètes exposées au client
+   - routes / actions serveur sans contrôle d'accès, ou qui ne vérifient pas la propriété de la ressource
+   - entrées non validées, SQL concaténé, HTML non échappé
+   - dépendances vulnérables (lance l'outil d'audit de la stack)
+   - si l'app utilise un LLM : contenu externe injecté dans les prompts sans séparation, outils trop permissifs
+4. Rends un rapport classé par gravité (critique / haute / moyenne / basse), avec pour chaque
+   problème : où, risque concret, correction proposée.
+5. Ne corrige qu'après validation. Mets à jour les cases de `docs/SECURITY.md` en fonction du résultat.

package/template/.claude/skills/cadrage/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: cadrage
+description: Cadrage complet d'un nouveau projet avant tout développement. Interroge l'utilisateur et remplit PRD, architecture, design, règles, sécurité, tests, backlog et outillage. À utiliser au démarrage d'un projet, ou quand AGENTS.md indique "Statut du cadrage : NON FAIT" et que l'utilisateur veut commencer à coder.
+argument-hint: "[étape à reprendre, optionnel]"
+---
+
+# Cadrage du projet
+
+Tu mènes un entretien de cadrage puis tu remplis les fichiers du projet. L'utilisateur n'est pas
+forcément développeur : explique tes propositions simplement et justifie chaque choix technique.
+
+## Règles de l'entretien
+
+- Pose **au plus 4 questions à la fois**, regroupées par thème. Propose des réponses par défaut
+  raisonnables pour que l'utilisateur puisse simplement valider.
+- Après chaque étape : écris le fichier, montre un résumé en 3-5 lignes, demande validation avant
+  de passer à la suivante.
+- Remplace les commentaires `<!-- ... -->` d'instruction par le vrai contenu. Garde la structure
+  des titres. Si une section ne s'applique pas, écris « Sans objet — <raison> ».
+- **Reprise** : commence par regarder quels fichiers sont déjà remplis et reprends à la première
+  étape non terminée (ou à celle indiquée en argument : $ARGUMENTS). Annonce où tu reprends.
+- Ne code aucune fonctionnalité pendant le cadrage.
+
+## Étapes
+
+### 1. Produit → `docs/PRD.md`
+Problème, utilisateurs, parcours principaux, fonctionnalités du MVP (une ligne testable chacune),
+hors scope, vocabulaire du domaine, critères de succès, contraintes (budget, délai, RGPD, appareils).
+Pousse l'utilisateur à **réduire** le MVP : ce qui n'est pas indispensable va dans « Hors scope ».
+
+### 2. Architecture → `docs/ARCHITECTURE.md` + ADR
+- Propose une stack adaptée au PRD et au niveau de l'utilisateur, avec 1 alternative et les compromis.
+  Privilégie des technologies répandues et bien documentées (l'agent les maîtrise mieux).
+- **Vérifie les versions actuelles** et les commandes d'installation dans la doc officielle
+  (MCP Context7 ou recherche web) : ne te fie pas à ta mémoire.
+- Une fois validée : remplis ARCHITECTURE.md et crée `docs/decisions/0001-choix-de-la-stack.md`
+  à partir de `docs/decisions/0000-template.md`. Un ADR par autre décision structurante
+  (base de données, auth, hébergement…).
+
+### 3. Design → `docs/DESIGN.md`
+Intention, design system, écrans principaux, accessibilité, responsive, ton.
+Si le projet n'a pas d'interface : supprime DESIGN.md et sa ligne dans AGENTS.md.
+
+### 4. Stress-test
+Applique la skill `stress-test` sur PRD + ARCHITECTURE + DESIGN. Intègre les corrections validées
+et résume les risques restants dans « Points d'attention » d'ARCHITECTURE.md.
+
+### 5. Instructions de l'agent → `AGENTS.md`
+Remplis : le projet en une phrase, stack, structure du dépôt, commandes, règles d'architecture non
+négociables (avec liens ADR), conventions de code. Reste concis : ce fichier est lu à chaque session.
+
+### 6. Garde-fous → `docs/RULES.md`, `docs/SECURITY.md`, `docs/TESTING.md`
+- RULES : ajoute les interdits spécifiques au projet.
+- SECURITY : adapte la checklist à la stack (ex : RLS si Supabase), supprime l'inapplicable en
+  justifiant.
+- TESTING : outils de test, fonctionnalités critiques en TDD, ce que la CI vérifie.
+
+### 7. Backlog → `TASKS.md`
+Une ligne par fonctionnalité du MVP, ordonnées par dépendance puis valeur. La première doit
+être petite et livrable rapidement (souvent : squelette déployable + auth).
+
+### 8. Outillage
+- `.claude/hooks/format.mjs` (s'il existe) : renseigne `FORMAT_COMMAND` avec le formateur de la stack.
+- `.github/workflows/ci.yml` (s'il existe) : remplace l'étape d'avertissement par les vraies étapes
+  install / lint / typecheck / test / build, avec les versions vérifiées.
+- `.env.example` : les variables nécessaires, sans valeur, commentées.
+- `.mcp.json` : propose les serveurs MCP utiles à cette stack (base de données, hébergeur…).
+  N'ajoute que des serveurs officiels ou largement reconnus, et explique à quoi chacun sert.
+- `README.md` : section « Démarrer ».
+
+### 9. Squelette → `src/` (ou l'emplacement prévu par la stack)
+Initialise le projet avec l'outil officiel de la stack, crée la structure de dossiers décrite
+dans ARCHITECTURE.md avec des fichiers quasi vides. Vérifie que lint, typecheck, tests et build
+passent sur ce squelette vide. Supprime `src/README.md` s'il n'est plus utile.
+
+## Fin du cadrage
+
+1. Dans AGENTS.md, remplace « **NON FAIT** » par « **FAIT (AAAA-MM-JJ)** ».
+2. Ajoute une entrée dans `docs/SESSION-LOG.md`.
+3. Propose un commit : `chore: cadrage initial du projet`.
+4. Indique la prochaine étape : `/spec` sur la première fonctionnalité de TASKS.md.

package/template/.claude/skills/fin-de-session/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: fin-de-session
+description: Clôture une session de travail - met à jour TASKS.md, les tasks.md des specs en cours et ajoute une entrée en haut de docs/SESSION-LOG.md. À utiliser quand l'utilisateur dit qu'il s'arrête, ou en fin de journée.
+---
+
+# Fin de session
+
+1. **Faire le point** : liste ce qui a été fait pendant la session (conversation + `git log` /
+   `git status` depuis le début de la session) et ce qui n'est pas commité.
+2. **`TASKS.md`** : déplace ce qui est terminé, mets à jour « En cours », ajoute les nouvelles
+   tâches découvertes.
+3. **Specs en cours** : coche les tâches faites dans `docs/specs/*/tasks.md`.
+4. **Décisions** : si une décision technique a été prise sans ADR, crée-le dans `docs/decisions/`.
+5. **`docs/SESSION-LOG.md`** : ajoute en HAUT (sous le commentaire) une entrée au format :
+
+   ```
+   ### AAAA-MM-JJ — titre court
+   - Fait :
+   - Pièges rencontrés :
+   - Décisions : (liens vers les ADR)
+   - Prochaine étape :
+   ```
+
+   « Prochaine étape » doit être assez précise pour qu'une nouvelle session démarre sans question.
+6. **Commit** : s'il reste des changements, propose un message de commit (ne committe qu'avec
+   l'accord de l'utilisateur).
+7. Si une règle ou convention a été découverte pendant la session, propose de l'ajouter à
+   `AGENTS.md` ou `docs/RULES.md`.

package/template/.claude/skills/spec/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: spec
+description: Démarre une nouvelle fonctionnalité en spec-driven development - crée docs/specs/NNN-nom/ avec spec, plan technique et liste de tâches, à valider avant tout code. À utiliser dès que l'utilisateur veut ajouter une fonctionnalité non triviale.
+argument-hint: "<description de la fonctionnalité>"
+---
+
+# Nouvelle fonctionnalité : $ARGUMENTS
+
+Ne code rien tant que les trois étapes ci-dessous ne sont pas validées par l'utilisateur.
+
+## 0. Préparer
+- Numéro : le plus grand `NNN` existant dans `docs/specs/` + 1 (commence à `001`).
+- Copie `docs/specs/_template/` vers `docs/specs/NNN-nom-court/` (nom en kebab-case).
+- Relis `docs/PRD.md`, `AGENTS.md` et les ADR concernés pour rester cohérent.
+
+## 1. Spec → `spec.md` (le QUOI)
+Remplis le fichier. Pose les questions nécessaires (4 max à la fois) pour lever les ambiguïtés.
+Les critères d'acceptation doivent être vérifiables par un test. Fais valider.
+
+## 2. Plan → `plan.md` (le COMMENT)
+Fichiers touchés, modèle de données, API, composants, dépendances éventuelles (vérifiées : elles
+existent, sont maintenues, doc à jour). Si une décision est structurante, crée un ADR.
+Pour une fonctionnalité risquée, applique la skill `stress-test` sur la spec et le plan.
+Fais valider.
+
+## 3. Tâches → `tasks.md`
+Découpe en tâches de quelques dizaines de minutes, chacune testable et committable seule, dans
+l'ordre d'exécution. Pour les parties critiques (voir `docs/TESTING.md`), la tâche « écrire le
+test » précède la tâche d'implémentation.
+
+## 4. Lancer
+- Ajoute la fonctionnalité dans « En cours » de `TASKS.md` avec un lien vers la spec.
+- Implémente tâche par tâche : après chacune, lance lint / typecheck / tests, coche la tâche,
+  propose un commit.
+- À la fin : vérifie chaque critère d'acceptation, fais relire par le sous-agent `reviewer`,
+  puis déplace la ligne dans « Terminé ».

package/template/.claude/skills/stress-test/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: stress-test
+description: Relecture critique des documents de cadrage ou d'une spec pour trouver ce qui va casser, les cas limites oubliés et le sur-engineering. À utiliser après avoir rédigé PRD/ARCHITECTURE, ou sur une spec avant de l'implémenter.
+argument-hint: "[fichier(s) à challenger, par défaut PRD + ARCHITECTURE + DESIGN]"
+---
+
+# Stress-test
+
+Cible : $ARGUMENTS (par défaut `docs/PRD.md`, `docs/ARCHITECTURE.md`, `docs/DESIGN.md`).
+
+Lis la cible en entier, puis réponds en jouant l'avocat du diable — un développeur senior qui doit
+maintenir ce projet pendant 2 ans. Classe chaque point par gravité (bloquant / important / mineur).
+
+1. **Ce qui va casser** : points de défaillance, dépendances fragiles, limites de services tiers
+   (quotas, coûts, verrouillage), montée en charge.
+2. **Cas limites oubliés** : données vides, doublons, accès concurrents, utilisateur supprimé,
+   paiement échoué, fuseau horaire, hors ligne, gros volumes, caractères spéciaux.
+3. **Sécurité** : passe en revue `docs/SECURITY.md` au regard de cette architecture.
+4. **Sur-engineering** : ce qui est trop complexe pour un MVP et peut être simplifié ou reporté.
+5. **Contradictions** entre les documents (PRD ↔ architecture ↔ design).
+6. **Questions ouvertes** que l'utilisateur doit trancher.
+
+Ensuite, propose les modifications concrètes à apporter aux fichiers. **N'applique qu'après
+validation**, puis résume les risques acceptés dans « Points d'attention » d'ARCHITECTURE.md
+(ou dans la spec si la cible est une spec).

package/template/.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.py]
+indent_size = 4
+
+[Makefile]
+indent_style = tab

package/template/.env.example

@@ -0,0 +1,7 @@
+# Variables d'environnement attendues par le projet.
+# Copier vers .env et compléter avec les vraies valeurs. Ne jamais committer .env.
+# Chaque variable ajoutée au code doit apparaître ici, sans valeur, avec un commentaire.
+# Rappel : les variables préfixées NEXT_PUBLIC_, VITE_, EXPO_PUBLIC_… sont visibles dans le navigateur.
+
+# Exemple :
+# DATABASE_URL=        # chaîne de connexion à la base (local)