living-documentation 7.58.0 → 7.59.0

package/dist/starter-doc/ADRS/2026_01_01_[ADR]_example_architecture_decision.md

@@ -29,6 +29,7 @@ Be specific enough that another developer or AI assistant can apply the same rul
 Example:
 
 - store project-level AI instructions in `AI/PROJECT-INSTRUCTIONS.md`;
+- document the stack and commands in `AI/PROJECT-STACK.md` and `AI/PROJECT-USEFUL-COMMANDS.md`;
 - expose tool-specific entry points through `AGENTS.md` and `CLAUDE.md`;
 - keep reusable AI rules in `AI/rules/*.md`;
 - use symbolic links when a document must appear in Living Documentation without duplicating the source of truth.

package/dist/starter-doc/AI/2026_01_01_how_to.md

@@ -36,6 +36,10 @@ The internal `AI/default/` template folder is removed from the initialized docum
 
 `AI/PROJECT-INSTRUCTIONS.md` is the shared operating guide for every AI assistant working on the project.
 
+`AI/PROJECT-STACK.md` describes the stack, useful source tree, core concepts, and structural conventions of the project.
+
+`AI/PROJECT-USEFUL-COMMANDS.md` lists the commands that are actually useful to install, run, test, verify, and maintain the project.
+
 `AI/rules/*.md` contains reusable rules that AI assistants must apply when they touch matching files.
 
 `ADRS/*.md` contains durable decisions. ADRs explain why the project works a certain way.
@@ -47,6 +51,7 @@ Open the **AI Context** page from the main navigation.
 This page should let you verify:
 
 - that `AGENTS.md`, `CLAUDE.md`, and `memory/MEMORY.md` appear as documents under `AI/`;
+- that `PROJECT-INSTRUCTIONS.md`, `PROJECT-STACK.md`, and `PROJECT-USEFUL-COMMANDS.md` are visible and adapted to your project;
 - that AI rules are visible under `AI/rules/`;
 - that the MCP explorer shows the `living-documentation` server, the `/mcp` endpoint, the available tools, and the prompts.
 
@@ -58,12 +63,15 @@ An AI assistant should:
 
 1. Read its entry point: `AGENTS.md` or `CLAUDE.md`.
 2. Follow the link to `AI/PROJECT-INSTRUCTIONS.md`.
-3. Read `memory/MEMORY.md` and load only relevant memory files.
-4. Read the matching rules in `AI/rules/*.md`.
-5. Inspect ADR frontmatter when a task may touch an existing decision.
-6. Make the requested change.
-7. At the end of a coherent feature, update durable documentation when needed.
-8. Attach Living Documentation metadata to created or updated documents when source files prove their content.
+3. Read `AI/PROJECT-STACK.md` to understand the technical choices, useful source tree, and project concepts.
+4. Read `AI/PROJECT-USEFUL-COMMANDS.md` to use the right commands instead of guessing them.
+5. Read `memory/MEMORY.md` and load only relevant memory files.
+6. Read the matching rules in `AI/rules/*.md`.
+7. Inspect ADR frontmatter when a task may touch an existing decision.
+8. Make the requested change.
+9. At the end of a coherent feature, update durable documentation when needed.
+10. Update `PROJECT-STACK.md` or `PROJECT-USEFUL-COMMANDS.md` if the task makes their content wrong, incomplete, or obsolete.
+11. Attach Living Documentation metadata to created or updated documents when source files prove their content.
 
 ## Project Instructions
 
@@ -100,4 +108,5 @@ After setup, remove only what is not useful for your project.
 Common cleanup:
 
 - keep this document if future contributors should understand the initialized structure;
+- adapt `PROJECT-STACK.md` and `PROJECT-USEFUL-COMMANDS.md` as soon as the first real project commands and conventions are known;
 - keep the ADR example only if you want an in-project template.

package/dist/starter-doc/AI/PROJECT-INSTRUCTIONS.md

@@ -10,10 +10,12 @@ Before changing the project:
 
 1. Read `AGENTS.md` or `CLAUDE.md`, depending on the tool.
 2. Read this file: `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
-3. Read `memory/MEMORY.md` and load only the memory files relevant to the task.
-4. Read every rule in `DOCS_FOLDER/AI/rules/*.md`.
-5. Inspect existing ADRs: list `DOCS_FOLDER/ADRS/`, read only `description` and `tags` first, then open the full ADR only when relevant.
-6. Check whether the Living Documentation MCP server is available before creating or modifying documentation.
+3. Read `DOCS_FOLDER/AI/PROJECT-STACK.md` to understand the stack, useful source tree, core concepts, and structural conventions.
+4. Read `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` to know the development, build, test, lint, and setup commands.
+5. Read `memory/MEMORY.md` and load only the memory files relevant to the task.
+6. Read every rule in `DOCS_FOLDER/AI/rules/*.md`.
+7. Inspect existing ADRs: list `DOCS_FOLDER/ADRS/`, read only `description` and `tags` first, then open the full ADR only when relevant.
+8. Check whether the Living Documentation MCP server is available before creating or modifying documentation.
 
 Replace `DOCS_FOLDER` with the real documentation folder used by this project, for example `documentation`, `docs`, or `doc`.
 
@@ -89,6 +91,22 @@ When the AI creates or updates an ADR or technical document:
 
 Metadata is not optional for documents that describe code. If metadata cannot be updated, the AI must say so in its final response and list the files that should be attached.
 
+## Project Stack And Commands
+
+`DOCS_FOLDER/AI/PROJECT-STACK.md` contains the operational project summary: technical stack, important source areas, core concepts, and structural conventions.
+
+`DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` contains commands that are actually useful: installation, local development, build, tests, lint, formatting, setup, and dangerous commands.
+
+These two files are living documentation. The AI must propose updates when a task makes their content false, incomplete, or insufficiently precise.
+
+Rules:
+
+- keep these files short, concrete, and action-oriented;
+- do not duplicate ADRs in them;
+- point to ADRs when a durable explanation exists;
+- verify that a command exists before documenting it;
+- do not silently change a structural convention or dangerous command: explain the change and wait for validation when the risk is significant.
+
 ## AI Rules
 
 Rules live in `DOCS_FOLDER/AI/rules/*.md`.
@@ -114,7 +132,7 @@ Memory is for stable, frequently reused context. Durable decisions should instea
 
 ## Changing AI Instruction Files
 
-The AI may propose changes to `AGENTS.md`, `CLAUDE.md`, `PROJECT-INSTRUCTIONS.md`, `memory/MEMORY.md`, or rules in `AI/rules/`.
+The AI may propose changes to `AGENTS.md`, `CLAUDE.md`, `PROJECT-INSTRUCTIONS.md`, `PROJECT-STACK.md`, `PROJECT-USEFUL-COMMANDS.md`, `memory/MEMORY.md`, or rules in `AI/rules/`.
 
 But these files directly steer AI assistant behavior. Before changing them, the AI must:
 

package/dist/starter-doc/AI/PROJECT-STACK.md

@@ -0,0 +1,77 @@
+# PROJECT-STACK - Template
+
+This file gives the AI assistant a short, factual overview of the project. It must stay concise, concrete, and continuously maintained.
+
+It does not replace ADRs: it helps the assistant quickly know where to look, which technologies are involved, and which concepts structure the code. For the detailed reason behind a decision, read the relevant ADRs.
+
+## Maintenance Rule
+
+The AI must propose an update to this file when a task:
+
+- introduces, removes, or replaces an important technology;
+- changes a structural convention;
+- adds or moves an important source area;
+- changes a central business or technical concept;
+- makes any information below false or incomplete.
+
+Do not document volatile details, temporary TODOs, or information that clearly belongs in an ADR.
+
+## Overview
+
+Replace this paragraph with a short project description:
+
+- what the project does;
+- who it is for;
+- where the application code, documentation, and main entry points live.
+
+## Technical Stack
+
+Fill only the lines that actually exist in the project. Remove irrelevant categories.
+
+- **Main language**:
+- **Runtime**:
+- **Frontend framework**:
+- **Backend / server framework**:
+- **Database / storage**:
+- **External APIs / integrations**:
+- **Authentication / authorization**:
+- **Styles / design system**:
+- **State management**:
+- **Build / bundler**:
+- **Package manager**:
+- **Tests**:
+- **Lint / formatting**:
+- **Observability / logs**:
+- **Deployment / hosting**:
+
+## Useful Source Tree
+
+Describe the folders or files the AI must know to orient itself quickly.
+
+```text
+src/                 <- main application code
+tests/               <- automated tests
+documentation/       <- Living Documentation folder, if this is the project docs folder
+```
+
+Adapt this tree to the real project. Do not list the whole repository: keep only what helps an AI find where to work.
+
+## Core Concepts
+
+List concepts that often come up in tasks.
+
+- **Concept 1**: explain in one sentence and point to the useful ADR or document.
+- **Concept 2**: explain in one sentence and point to the useful ADR or document.
+- **Concept 3**: explain in one sentence and point to the useful ADR or document.
+
+## Structural Conventions
+
+List conventions the AI must respect before changing code.
+
+- Naming convention:
+- Module organization:
+- Error handling:
+- Configuration handling:
+- Test strategy:
+
+If a convention becomes durable or comes from an important trade-off, create or update an ADR instead of overloading this file.

package/dist/starter-doc/AI/PROJECT-USEFUL-COMMANDS.md

@@ -0,0 +1,80 @@
+# PROJECT-USEFUL-COMMANDS - Template
+
+This file describes the commands that are actually useful for working on the project. It must help an AI choose the right verification without guessing.
+
+It must stay up to date. A wrong command is more costly than a missing command.
+
+## Maintenance Rule
+
+The AI must propose an update to this file when a task:
+
+- adds, removes, or renames a development script;
+- changes the package manager;
+- changes the build, test, lint, or formatting command;
+- introduces a required setup step;
+- reveals that a documented command no longer works.
+
+Before adding a command, verify that it really exists in `package.json`, a Makefile, a script, or the project documentation.
+
+## Package Manager
+
+State the expected package manager and the related rule.
+
+```text
+npm | pnpm | yarn | bun | other
+```
+
+If the project mandates a package manager, create or update a rule in `AI/rules/`.
+
+## Installation
+
+| Command | When to use it | Notes |
+|---|---|---|
+| `npm install` | After clone or dependency changes | Adapt to the real package manager. |
+
+## Local Development
+
+| Command | Effect | Notes |
+|---|---|---|
+| `npm run dev` | Starts the local server | Specify port and prerequisites. |
+
+## Quality
+
+| Command | Effect | When to run it |
+|---|---|---|
+| `npm run build` | Compiles or bundles the project | After typed code, build config, or copied asset changes. |
+| `npm test` | Runs tests | After behavior changes. |
+| `npm run lint` | Runs lint | If the project has linting. |
+| `npm run format` | Formats code | If the project has formatting. |
+
+## Focused Tests
+
+Document commands that verify a limited scope without running the whole suite.
+
+| Command | Scope |
+|---|---|
+| `npm test -- <pattern>` | Adapt to the real runner. |
+
+## Initial Setup
+
+List required steps after a clone or initialization.
+
+```bash
+# Example to replace
+cp .env.example .env
+npm install
+```
+
+## Dangerous Or Costly Commands
+
+List commands that change the environment, delete data, deploy, or cost money.
+
+| Command | Risk | Rule |
+|---|---|---|
+| `npm run deploy` | Real deployment | Ask for explicit validation before running. |
+
+## Notes For AI
+
+- Run the smallest useful verification before finishing.
+- If a command fails, report the exact command, the symptom, and the most likely hypothesis.
+- Do not invent scripts: if a command is missing, say so and propose adding it.

package/dist/starter-doc/AI/default/AGENTS.md

@@ -5,10 +5,12 @@ This file is the entry point for Codex and agent-style tools.
 Before making changes:
 
 1. Read `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
-2. Read `memory/MEMORY.md` and load only useful memory files.
-3. Read rules in `DOCS_FOLDER/AI/rules/*.md`.
-4. Inspect ADRs in `DOCS_FOLDER/ADRS/` by reading `description` and `tags` first.
-5. Use the Living Documentation MCP to create, update, and keep documentation reliable when it is available.
+2. Read `DOCS_FOLDER/AI/PROJECT-STACK.md` to understand the stack, useful source areas, core concepts, and structural conventions.
+3. Read `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` to know the development, build, test, lint, and setup commands.
+4. Read `memory/MEMORY.md` and load only useful memory files.
+5. Read rules in `DOCS_FOLDER/AI/rules/*.md`.
+6. Inspect ADRs in `DOCS_FOLDER/ADRS/` by reading `description` and `tags` first, then open the full ADR only when relevant.
+7. Check whether the `living-documentation` MCP is available and use it to create, update, and keep documentation reliable when the task touches a decision, rule, command, stack, or technical document.
 
 Replace `DOCS_FOLDER` with the real documentation folder for this project.
 
@@ -23,6 +25,8 @@ When the MCP is available:
 - attach source files with `add_metadata` after creating or updating an ADR or technical document;
 - call `refresh_metadata` once the document is aligned with the code.
 
-If the MCP is not available, state that explicitly in the final response.
+`PROJECT-STACK.md` and `PROJECT-USEFUL-COMMANDS.md` are living documents. If the agent discovers that they are wrong, incomplete, or obsolete, it should propose or perform their update in the same task unless the user says otherwise.
+
+If the MCP is not available, state that explicitly in the final response and do not claim that Living Documentation metadata or hashes were updated.
 
 If a rule or project instruction conflicts with the user request, state the conflict explicitly before proceeding.

package/dist/starter-doc/AI/default/CLAUDE.md

@@ -5,10 +5,12 @@ This file is the entry point for Claude.
 Before making changes:
 
 1. Read `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
-2. Read `memory/MEMORY.md` and load only useful memory files.
-3. Read rules in `DOCS_FOLDER/AI/rules/*.md`.
-4. Inspect ADRs in `DOCS_FOLDER/ADRS/` by reading `description` and `tags` first.
-5. Use the Living Documentation MCP to create, update, and keep documentation reliable when it is available.
+2. Read `DOCS_FOLDER/AI/PROJECT-STACK.md` to understand the stack, useful source areas, core concepts, and structural conventions.
+3. Read `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` to know the development, build, test, lint, and setup commands.
+4. Read `memory/MEMORY.md` and load only useful memory files.
+5. Read rules in `DOCS_FOLDER/AI/rules/*.md`.
+6. Inspect ADRs in `DOCS_FOLDER/ADRS/` by reading `description` and `tags` first, then open the full ADR only when relevant.
+7. Check whether the `living-documentation` MCP is available and use it to create, update, and keep documentation reliable when the task touches a decision, rule, command, stack, or technical document.
 
 Replace `DOCS_FOLDER` with the real documentation folder for this project.
 
@@ -23,6 +25,8 @@ When the MCP is available:
 - attach source files with `add_metadata` after creating or updating an ADR or technical document;
 - call `refresh_metadata` once the document is aligned with the code.
 
-If the MCP is not available, state that explicitly in the final response.
+`PROJECT-STACK.md` and `PROJECT-USEFUL-COMMANDS.md` are living documents. If the agent discovers that they are wrong, incomplete, or obsolete, it should propose or perform their update in the same task unless the user says otherwise.
+
+If the MCP is not available, state that explicitly in the final response and do not claim that Living Documentation metadata or hashes were updated.
 
 If a rule or project instruction conflicts with the user request, state the conflict explicitly before proceeding.

package/dist/starter-doc-fr/ADRS/2026_01_01_[ADR]_example_architecture_decision.md

@@ -29,6 +29,7 @@ Soyez assez spécifique pour qu'un autre développeur ou assistant IA puisse app
 Exemple :
 
 - stocker les instructions IA projet dans `AI/PROJECT-INSTRUCTIONS.md` ;
+- documenter la stack et les commandes dans `AI/PROJECT-STACK.md` et `AI/PROJECT-USEFUL-COMMANDS.md` ;
 - exposer les points d'entrée propres aux outils via `AGENTS.md` et `CLAUDE.md` ;
 - garder les règles IA réutilisables dans `AI/rules/*.md` ;
 - utiliser des liens symboliques quand un document doit apparaître dans Living Documentation sans dupliquer la source de vérité.

package/dist/starter-doc-fr/AI/2026_01_01_how_to.md

@@ -32,6 +32,10 @@ Autrement dit, les liens ne pointent pas vers un autre fichier dans le dossier d
 
 `AI/PROJECT-INSTRUCTIONS.md` est le guide de travail partagé par tous les assistants IA du projet.
 
+`AI/PROJECT-STACK.md` décrit la stack, l'arborescence source utile, les concepts centraux et les conventions structurantes du projet.
+
+`AI/PROJECT-USEFUL-COMMANDS.md` liste les commandes réellement utiles pour installer, lancer, tester, vérifier et maintenir le projet.
+
 `AI/rules/*.md` contient les règles réutilisables que les assistants IA doivent appliquer lorsqu'ils effectuent des modifications sur le projet.
 
 `ADRS/*.md` contient les décisions durables. Les ADR (Architecture Decision Records) expliquent pourquoi le projet fonctionne d'une certaine manière, ils sont automatiquement créés par l'agent IA lorsqu'il réalise ses tâches tel que cela lui est expliqué dans les instructions projet.
@@ -43,6 +47,7 @@ Ouvrir la page **Contexte IA** depuis la barre principale.
 Cette page doit vous permettre de vérifier :
 
 - que `AGENTS.md`, `CLAUDE.md` et `memory/MEMORY.md` apparaissent comme documents dans `AI/` ;
+- que `PROJECT-INSTRUCTIONS.md`, `PROJECT-STACK.md` et `PROJECT-USEFUL-COMMANDS.md` sont visibles et adaptés à votre projet ;
 - que les règles IA sont visibles dans `AI/rules/` ;
 - que l'explorateur MCP affiche le serveur `living-documentation`, l'endpoint `/mcp`, les outils disponibles et les prompts.
 
@@ -54,12 +59,15 @@ Pour information, le fonctionnement d'un assistant IA est le suivant :
 
 1. Lire son point d'entrée : `AGENTS.md` ou `CLAUDE.md`.
 2. Suivre le lien vers `AI/PROJECT-INSTRUCTIONS.md`.
-3. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire pertinents.
-4. Lire les règles applicables dans `AI/rules/*.md`.
-5. Inspecter le frontmatter des ADR lorsqu'une tâche peut toucher une décision existante.
-6. Réaliser la modification demandée.
-7. À la fin d'une feature cohérente, mettre à jour la documentation durable si nécessaire en utilisant le MCP Living-Documentation intégré.
-8. Attacher les métadonnées Living Documentation aux documents créés ou mis à jour lorsque des fichiers source prouvent leur contenu.
+3. Lire `AI/PROJECT-STACK.md` pour comprendre les choix techniques, l'arborescence utile et les concepts du projet.
+4. Lire `AI/PROJECT-USEFUL-COMMANDS.md` pour utiliser les bonnes commandes au lieu de les deviner.
+5. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire pertinents.
+6. Lire les règles applicables dans `AI/rules/*.md`.
+7. Inspecter le frontmatter des ADR lorsqu'une tâche peut toucher une décision existante.
+8. Réaliser la modification demandée.
+9. À la fin d'une feature cohérente, mettre à jour la documentation durable si nécessaire en utilisant le MCP Living-Documentation intégré.
+10. Mettre à jour `PROJECT-STACK.md` ou `PROJECT-USEFUL-COMMANDS.md` si la tâche rend leur contenu faux, incomplet ou obsolète.
+11. Attacher les métadonnées Living Documentation aux documents créés ou mis à jour lorsque des fichiers source prouvent leur contenu.
 
 ## ADR
 
@@ -88,4 +96,5 @@ Après initialisation, supprimez seulement ce qui n'est pas utile au projet.
 Nettoyage courant :
 
 - garder ce document si les futurs contributeurs doivent comprendre la structure initialisée ;
+- adapter `PROJECT-STACK.md` et `PROJECT-USEFUL-COMMANDS.md` dès que les premières commandes et conventions réelles du projet sont connues ;
 - garder l'ADR exemple seulement si vous voulez un template dans le projet.

package/dist/starter-doc-fr/AI/PROJECT-INSTRUCTIONS.md

@@ -10,16 +10,16 @@ Avant de modifier le projet :
 
 1. Lire `AGENTS.md` ou `CLAUDE.md`, selon l'outil utilisé.
 2. Lire ce fichier : `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
-3. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire utiles à la tâche.
-4. Lire toutes les règles dans `DOCS_FOLDER/AI/rules/*.md`.
-5. Inspecter les ADR existants : lister `DOCS_FOLDER/ADRS/`, lire d'abord `description` et `tags`, puis ouvrir l'ADR complet seulement s'il est pertinent.
-6. Vérifier si le serveur MCP Living Documentation est disponible avant de créer ou modifier de la documentation.
-
-Remplacer `DOCS_FOLDER` par le vrai dossier de documentation du projet, par exemple `documentation`, `docs` ou `doc`.
+3. Lire `DOCS_FOLDER/AI/PROJECT-STACK.md` pour comprendre la stack, l'arborescence utile, les concepts centraux et les conventions structurantes.
+4. Lire `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` pour connaître les commandes de développement, build, test, lint et setup.
+5. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire utiles à la tâche.
+6. Lire toutes les règles dans `DOCS_FOLDER/AI/rules/*.md`.
+7. Inspecter les ADR existants : lister `DOCS_FOLDER/ADRS/`, lire d'abord `description` et `tags`, puis ouvrir l'ADR complet seulement s'il est pertinent.
+8. Vérifier si le MCP `living-documentation` est disponible avant de créer ou modifier de la documentation.
 
 ## Rôle du MCP Living Documentation
 
-Le MCP Living Documentation est le canal privilégié pour lire, créer et maintenir la documentation du projet. Quand il est disponible, l'IA doit l'utiliser plutôt que modifier les fichiers Markdown à la main.
+Le MCP `living-documentation` est le canal privilégié pour lire, créer et maintenir la documentation du projet. Quand il est disponible, l'IA doit l'utiliser plutôt que modifier les fichiers Markdown à la main.
 
 Utiliser notamment :
 
@@ -89,6 +89,22 @@ Quand l'IA crée ou met à jour un ADR ou un document technique :
 
 Les métadonnées ne sont pas optionnelles pour les documents qui décrivent du code. Si elles ne peuvent pas être mises à jour, l'IA doit le signaler dans sa réponse finale et lister les fichiers à attacher.
 
+## Stack et commandes projet
+
+`DOCS_FOLDER/AI/PROJECT-STACK.md` contient le résumé opérationnel du projet : stack technique, zones source importantes, concepts centraux et conventions structurantes.
+
+`DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` contient les commandes réellement utiles : installation, développement local, build, tests, lint, formatage, setup et commandes dangereuses.
+
+Ces deux fichiers sont de la documentation vivante. L'IA doit proposer leur mise à jour lorsqu'une tâche rend leur contenu faux, incomplet ou insuffisamment précis.
+
+Règles :
+
+- garder ces fichiers courts, concrets et orientés action ;
+- ne pas y dupliquer les ADR ;
+- pointer vers les ADR lorsqu'une explication durable existe ;
+- vérifier l'existence d'une commande avant de la documenter ;
+- ne pas modifier silencieusement une convention structurante ou une commande dangereuse : expliquer le changement et attendre validation si le risque est significatif.
+
 ## Règles IA
 
 Les règles vivent dans `DOCS_FOLDER/AI/rules/*.md`.
@@ -114,7 +130,7 @@ La mémoire sert aux informations stables et fréquemment réutilisées. Les dé
 
 ## Modification des fichiers d'instructions IA
 
-L'IA a le droit de proposer des modifications de `AGENTS.md`, `CLAUDE.md`, `PROJECT-INSTRUCTIONS.md`, `memory/MEMORY.md` ou des règles dans `AI/rules/`.
+L'IA a le droit de proposer des modifications de `AGENTS.md`, `CLAUDE.md`, `PROJECT-INSTRUCTIONS.md`, `PROJECT-STACK.md`, `PROJECT-USEFUL-COMMANDS.md`, `memory/MEMORY.md` ou des règles dans `AI/rules/`.
 
 Mais ces fichiers pilotent directement le comportement des assistants IA. Avant de les modifier, l'IA doit :
 

package/dist/starter-doc-fr/AI/PROJECT-STACK.md

@@ -0,0 +1,77 @@
+# PROJECT-STACK - Template
+
+Ce fichier donne à l'assistant IA une vue rapide et factuelle du projet. Il doit rester court, concret et maintenu en continu.
+
+Il ne remplace pas les ADR : il sert à savoir rapidement où regarder, quelles technologies sont en jeu et quels concepts structurent le code. Pour le pourquoi détaillé d'une décision, lire les ADR pertinents.
+
+## Règle de maintenance
+
+L'IA doit proposer une mise à jour de ce fichier lorsqu'une tâche :
+
+- introduit, retire ou remplace une technologie importante ;
+- modifie une convention structurante ;
+- ajoute ou déplace une zone source importante ;
+- change un concept métier ou technique central ;
+- rend une information ci-dessous fausse ou incomplète.
+
+Ne pas documenter ici les détails volatils, les TODO temporaires ou les informations qui appartiennent clairement à un ADR.
+
+## Vue d'ensemble
+
+Remplacer ce paragraphe par une description courte du projet :
+
+- ce que fait le projet ;
+- pour qui ;
+- où se trouvent le code applicatif, la documentation et les points d'entrée principaux.
+
+## Stack technique
+
+Remplir uniquement les lignes qui existent réellement dans le projet. Supprimer les catégories inutiles.
+
+- **Langage principal** :
+- **Runtime** :
+- **Framework frontend** :
+- **Framework backend / serveur** :
+- **Base de données / stockage** :
+- **API externes / intégrations** :
+- **Authentification / autorisation** :
+- **Styles / design system** :
+- **Gestion d'état** :
+- **Build / bundler** :
+- **Package manager** :
+- **Tests** :
+- **Lint / formatage** :
+- **Observabilité / logs** :
+- **Déploiement / hébergement** :
+
+## Arborescence source utile
+
+Décrire les dossiers ou fichiers que l'IA doit connaître pour s'orienter vite.
+
+```text
+src/                 <- code applicatif principal
+tests/               <- tests automatisés
+documentation/       <- documentation Living Documentation, si le dossier porte ce nom
+```
+
+Adapter cette arborescence au projet réel. Ne pas lister tout le dépôt : garder seulement ce qui aide une IA à trouver où intervenir.
+
+## Concepts centraux
+
+Lister les concepts qui reviennent souvent dans les tâches.
+
+- **Concept 1** : expliquer en une phrase et pointer vers l'ADR ou le document utile.
+- **Concept 2** : expliquer en une phrase et pointer vers l'ADR ou le document utile.
+- **Concept 3** : expliquer en une phrase et pointer vers l'ADR ou le document utile.
+
+## Conventions structurantes
+
+Lister les conventions que l'IA doit respecter avant de modifier le code.
+
+- Convention de nommage :
+- Organisation des modules :
+- Gestion des erreurs :
+- Gestion de la configuration :
+- Stratégie de test :
+
+Si une convention devient durable ou résulte d'un compromis important, créer ou mettre à jour un ADR plutôt que surcharger ce fichier.

package/dist/starter-doc-fr/AI/PROJECT-USEFUL-COMMANDS.md

@@ -0,0 +1,80 @@
+# PROJECT-USEFUL-COMMANDS - Template
+
+Ce fichier décrit les commandes réellement utiles pour travailler sur le projet. Il doit permettre à une IA de choisir la bonne vérification sans deviner.
+
+Il doit rester à jour. Une commande fausse coûte plus cher qu'une commande absente.
+
+## Règle de maintenance
+
+L'IA doit proposer une mise à jour de ce fichier lorsqu'une tâche :
+
+- ajoute, retire ou renomme un script de développement ;
+- change le package manager ;
+- change la commande de build, test, lint ou formatage ;
+- introduit une étape de setup nécessaire ;
+- révèle qu'une commande documentée ne marche plus.
+
+Avant d'ajouter une commande, vérifier qu'elle existe réellement dans `package.json`, un Makefile, un script ou la documentation du projet.
+
+## Package manager
+
+Indiquer le package manager attendu et la règle associée.
+
+```text
+npm | pnpm | yarn | bun | autre
+```
+
+Si le projet impose un package manager, créer ou mettre à jour une règle dans `AI/rules/`.
+
+## Installation
+
+| Commande | Quand l'utiliser | Notes |
+|---|---|---|
+| `npm install` | Après clone ou changement de dépendances | Adapter au package manager réel. |
+
+## Développement local
+
+| Commande | Effet | Notes |
+|---|---|---|
+| `npm run dev` | Démarre le serveur local | Préciser le port et les prérequis. |
+
+## Qualité
+
+| Commande | Effet | Quand la lancer |
+|---|---|---|
+| `npm run build` | Compile ou bundle le projet | Après changement de code typé, build config ou assets copiés. |
+| `npm test` | Lance les tests | Après changement de comportement. |
+| `npm run lint` | Lance le lint | Si le projet possède un lint. |
+| `npm run format` | Formate le code | Si le projet possède un formateur. |
+
+## Tests ciblés
+
+Documenter les commandes qui permettent de vérifier un périmètre sans lancer toute la suite.
+
+| Commande | Périmètre |
+|---|---|
+| `npm test -- <pattern>` | Adapter au runner réel. |
+
+## Setup initial
+
+Lister les étapes nécessaires après un clone ou une initialisation.
+
+```bash
+# Exemple à remplacer
+cp .env.example .env
+npm install
+```
+
+## Commandes dangereuses ou coûteuses
+
+Lister les commandes qui modifient l'environnement, suppriment des données, lancent un déploiement ou coûtent de l'argent.
+
+| Commande | Risque | Règle |
+|---|---|---|
+| `npm run deploy` | Déploiement réel | Demander validation explicite avant exécution. |
+
+## Notes pour l'IA
+
+- Lancer la plus petite vérification utile avant de terminer.
+- Si une commande échoue, reporter la commande exacte, le symptôme et l'hypothèse la plus probable.
+- Ne pas inventer de scripts : si une commande manque, le dire et proposer de l'ajouter.

package/dist/starter-doc-fr/AI/default/AGENTS.md

@@ -5,10 +5,12 @@ Ce fichier est le point d'entrée pour Codex et les outils de type agent.
 Avant toute modification :
 
 1. Lire `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
-2. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire utiles.
-3. Lire les règles dans `DOCS_FOLDER/AI/rules/*.md`.
-4. Inspecter les ADR dans `DOCS_FOLDER/ADRS/` en lisant d'abord `description` et `tags`.
-5. Utiliser le MCP Living Documentation pour créer, mettre à jour et fiabiliser la documentation quand il est disponible.
+2. Lire `DOCS_FOLDER/AI/PROJECT-STACK.md` pour comprendre la stack, les zones source utiles, les concepts centraux et les conventions structurantes.
+3. Lire `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` pour connaître les commandes de développement, build, test, lint et setup.
+4. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire utiles à la tâche.
+5. Lire toutes les règles dans `DOCS_FOLDER/AI/rules/*.md`.
+6. Inspecter les ADR dans `DOCS_FOLDER/ADRS/` en lisant d'abord `description` et `tags`, puis ouvrir l'ADR complet seulement s'il est pertinent.
+7. Vérifier si le MCP `living-documentation` est disponible et l'utiliser pour créer, mettre à jour et fiabiliser la documentation lorsque la tâche touche une décision, une règle, une commande, la stack ou un document technique.
 
 Remplacer `DOCS_FOLDER` par le vrai dossier de documentation du projet.
 
@@ -23,6 +25,8 @@ Quand le MCP est disponible :
 - attacher les fichiers source avec `add_metadata` après création ou mise à jour d'un ADR ou document technique ;
 - appeler `refresh_metadata` lorsque le document est aligné avec le code.
 
-Si le MCP n'est pas disponible, le signaler explicitement dans la réponse finale.
+`PROJECT-STACK.md` et `PROJECT-USEFUL-COMMANDS.md` sont des documents vivants. Si l'agent découvre qu'ils sont faux, incomplets ou obsolètes, il doit proposer ou effectuer leur mise à jour dans la même tâche, sauf instruction contraire de l'utilisateur.
+
+Si le MCP n'est pas disponible, le signaler explicitement dans la réponse finale et ne pas prétendre avoir mis à jour les métadonnées ou les hashes Living Documentation.
 
 Si une règle ou une instruction projet contredit la demande utilisateur, signaler explicitement le conflit avant de continuer.

package/dist/starter-doc-fr/AI/default/CLAUDE.md

@@ -5,10 +5,12 @@ Ce fichier est le point d'entrée pour Claude.
 Avant toute modification :
 
 1. Lire `DOCS_FOLDER/AI/PROJECT-INSTRUCTIONS.md`.
-2. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire utiles.
-3. Lire les règles dans `DOCS_FOLDER/AI/rules/*.md`.
-4. Inspecter les ADR dans `DOCS_FOLDER/ADRS/` en lisant d'abord `description` et `tags`.
-5. Utiliser le MCP Living Documentation pour créer, mettre à jour et fiabiliser la documentation quand il est disponible.
+2. Lire `DOCS_FOLDER/AI/PROJECT-STACK.md` pour comprendre la stack, les zones source utiles, les concepts centraux et les conventions structurantes.
+3. Lire `DOCS_FOLDER/AI/PROJECT-USEFUL-COMMANDS.md` pour connaître les commandes de développement, build, test, lint et setup.
+4. Lire `memory/MEMORY.md` et charger seulement les fichiers mémoire utiles à la tâche.
+5. Lire toutes les règles dans `DOCS_FOLDER/AI/rules/*.md`.
+6. Inspecter les ADR dans `DOCS_FOLDER/ADRS/` en lisant d'abord `description` et `tags`, puis ouvrir l'ADR complet seulement s'il est pertinent.
+7. Vérifier si le MCP `living-documentation` est disponible et l'utiliser pour créer, mettre à jour et fiabiliser la documentation lorsque la tâche touche une décision, une règle, une commande, la stack ou un document technique.
 
 Remplacer `DOCS_FOLDER` par le vrai dossier de documentation du projet.
 
@@ -23,6 +25,8 @@ Quand le MCP est disponible :
 - attacher les fichiers source avec `add_metadata` après création ou mise à jour d'un ADR ou document technique ;
 - appeler `refresh_metadata` lorsque le document est aligné avec le code.
 
-Si le MCP n'est pas disponible, le signaler explicitement dans la réponse finale.
+`PROJECT-STACK.md` et `PROJECT-USEFUL-COMMANDS.md` sont des documents vivants. Si l'agent découvre qu'ils sont faux, incomplets ou obsolètes, il doit proposer ou effectuer leur mise à jour dans la même tâche, sauf instruction contraire de l'utilisateur.
+
+Si le MCP n'est pas disponible, le signaler explicitement dans la réponse finale et ne pas prétendre avoir mis à jour les métadonnées ou les hashes Living Documentation.
 
 Si une règle ou une instruction projet contredit la demande utilisateur, signaler explicitement le conflit avant de continuer.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "living-documentation",
-  "version": "7.58.0",
+  "version": "7.59.0",
   "description": "A CLI tool that serves a local Markdown documentation viewer",
   "main": "dist/src/server.js",
   "bin": {