@nodefony/devkit 10.0.0-alpha.1

package/README.md

@@ -0,0 +1,318 @@
+# @nodefony/devkit
+
+L'outillage de **développement** d'une application Nodefony : sa carte de visite,
+les **skills d'agent** qui disent comment faire les tâches courantes, et les
+portes qui mènent au reste.
+
+Il répond à la question que tout le monde se pose en arrivant sur une application
+— humain qui reprend un projet, agent qui code : **qui répond ici, et où faut-il
+aller ensuite ?**
+
+```bash
+npx nodefony card               # -j pour du JSON (| jq)
+```
+
+> La commande est servie par le **cœur**, pas par ce module : elle doit répondre
+> sur une application pas encore construite et dans un terminal sans `NODE_ENV`,
+> deux cas où aucun module n'est chargé. Ce paquet, lui, sert la même carte en
+> **HTTP** — et c'est la seule porte qui connaisse les modules réellement
+> CHARGÉS.
+
+```
+ma-boutique 1.4.0 — development (nodefony 10.0.0)
+
+Modules chargés (7) : drizzle, framework, frontend, http, security, studio, user
+
+Où aller :
+  AGENTS.md
+      Les instructions de cette application — générateurs disponibles, table
+      tâche → fichier, gates à passer. À lire AVANT d'écrire du code.
+  node_modules/nodefony/docs/catalogue.md
+      Le catalogue des briques — quel module prendre pour quel besoin.
+  …
+
+Quoi lancer :
+  npx nodefony doctor
+      diagnostic STATIQUE : il répond même quand l'application ne démarre plus.
+  …
+```
+
+## Installation
+
+`nodefony create app` l'ajoute déjà — en **`devDependencies`**, et déclaré
+`policy: "dev"` :
+
+```ts
+// nodefony.config.ts
+use("@nodefony/devkit", {}, { policy: "dev" }),
+```
+
+Les deux moitiés comptent : la `devDependency` fait qu'un `npm ci --omit=dev` ne
+l'installe pas ; la `policy` fait qu'un déploiement qui installerait tout ne le
+charge pas quand même. **En production, le module n'est même pas importé** — le
+coût y est nul, pas « faible ».
+
+Corollaire : **la route** n'existe que hors production. La **commande**, elle,
+répond toujours — elle ne dépend pas de ce module.
+
+## Ce qu'il expose
+
+| Porte                           | Pour qui                                                     |
+| ------------------------------- | ------------------------------------------------------------ |
+| `GET /nodefony/devkit/api/card` | Studio, un script authentifié — modules réellement CHARGÉS   |
+| **`POST /nodefony/mcp`**        | **un agent qui appelle des outils** (Model Context Protocol) |
+| `buildCard()` (export du cœur)  | une porte de plus, à écrire — rien à réimplémenter           |
+| `npx nodefony card`             | un agent, un humain au terminal — **servie par le cœur**     |
+| `skills/` (dossier du paquet)   | l'agent de codage que vous utilisez déjà — voir ci-dessous   |
+
+La route de la carte vit sous `/nodefony/<module>/api`, que le pare-feu d'une
+application réelle couvre : un agent qui code ne s'authentifie pas et n'a pas de
+navigateur — d'où la commande, qui reste la porte utile.
+
+## Le serveur MCP — les mêmes réponses, en outils
+
+```bash
+npx nodefony ai:mcp        # écrit .mcp.json ; --dry-run pour voir sans écrire
+```
+
+Quatre outils : **`nodefony_inspect`** (ce qui est monté), **`nodefony_check`**
+(ce qui manque), **`nodefony_symbols`** (ce qu'une API du framework signifie),
+**`nodefony_card`** (par où commencer). Ce sont les mêmes briques que les
+commandes du même nom — une source, plusieurs portes.
+
+**Ce n'est pas un process de plus.** Depuis la révision `2026-07-28` du transport
+« Streamable HTTP », un serveur MCP est un simple endpoint `POST` sans session :
+c'est donc une **route de votre application**. Elle n'existe que pendant qu'elle
+tourne, suit chaque rechargement du serveur de développement, et n'a aucun cache
+à invalider.
+
+**Ce qui la protège**, et il faut le savoir avant de s'étonner d'un `403` :
+
+- toute **adresse non locale** est refusée (`mcp.allowRemote`) ;
+- toute **origine de navigateur** non déclarée est refusée (`mcp.allowedOrigins`).
+  Un client MCP natif n'envoie pas d'en-tête `Origin` ; une page web en envoie
+  toujours un. C'est ce qui ferme le détournement DNS, seul vecteur réel contre
+  un serveur local ;
+- le module étant `policy: "dev"`, **la route n'existe pas en production** ;
+- les outils sont en **lecture seule**, et la liste est une allowlist
+  (`mcp.tools`).
+
+### Protéger la porte par OAuth 2.1
+
+Par défaut la porte est anonyme, et ce qui la borne est le périmètre ci-dessus.
+Déclarez un serveur d'autorisation, et elle prend son rôle de **resource
+server** : elle publie ses métadonnées, valide le porteur présenté, et refuse en
+disant où obtenir un jeton.
+
+```ts
+use("@nodefony/devkit", {
+  mcp: {
+    authorization: {
+      // Un seul réglage commande : vide = porte anonyme, comme avant.
+      authorizationServers: ["https://auth.example"],
+      // L'URI PUBLIQUE de la porte — l'audience que les jetons doivent porter.
+      // Elle s'écrit : la déduire de l'en-tête `Host` permettrait à un Host
+      // forgé d'obtenir un jeton d'audience arbitraire ET de passer la
+      // vérification.
+      resource: "https://mon-app.example/nodefony/mcp",
+    },
+  },
+});
+```
+
+> **Les scopes ne s'écrivent pas ici.** Ce que la porte publie
+> (`scopes_supported`) et nomme dans son défi est **dérivé** des outils qu'elle
+> sert : l'union de leurs `IMcpTool.scopes`. Pour qu'un scope soit publié, le
+> poser sur l'outil qu'il ouvre — le seul endroit où il a un effet. Une liste
+> écrite à côté du code annonçait au client autre chose que ce qu'on exige de
+> lui, dans les deux sens et sans qu'aucun contrôle ne s'en aperçoive.
+
+Le document est alors servi sur
+`GET /.well-known/oauth-protected-resource/nodefony/mcp` (RFC 9728 — le suffixe
+s'**insère** entre l'hôte et le chemin, ce qui permet plusieurs ressources par
+hôte), et une requête sans jeton reçoit :
+
+```http
+HTTP/1.1 401 Unauthorized
+WWW-Authenticate: Bearer resource_metadata="https://mon-app.example/.well-known/oauth-protected-resource/nodefony/mcp", scope="admin:read"
+```
+
+C'est cet en-tête qui rend l'autorisation **apprenable** : sans lui, un refus
+est un mur — le client ignore qu'un jeton existe et où le demander.
+
+> 🔴 **La vérification du jeton est fournie par l'application.** Ce module est
+> `policy: "dev"` et ne porte aucune cryptographie : il cherche un service
+> `accessTokenVerifier` dans le conteneur (contrat `IAccessTokenVerifier` du cœur).
+> Déclarer un serveur d'autorisation **sans** ce service fait répondre `503` à
+> la porte, avec un journal `CRITIC` — accepter des porteurs sans les lire
+> serait pire que rester anonyme.
+>
+> `anonymous: true` laisse la porte ouverte aux outils publics tout en gardant
+> les outils réservés retenus. C'est un choix qui s'écrit, jamais un défaut.
+
+Le serveur est **dual-ère** : il répond à `server/discover` et aux métadonnées
+par requête des clients modernes, **et** au handshake `initialize` des clients
+déployés aujourd'hui — ce que la spec autorise explicitement. Il sert cinq
+révisions (`2026-07-28`, `2025-11-25`, `2025-06-18`, `2025-03-26`,
+`2024-11-05`) et **répond celle que le client demande** : annoncer la plus
+récente à tous rendrait la porte injoignable par les clients dont le SDK ne la
+connaît pas encore.
+
+Éprouvé avec deux clients indépendants : Claude Code et Mistral Vibe.
+
+### Vos propres outils
+
+Ces quatre-là décrivent le framework ; ils ne savent rien de votre métier. Tout
+module de votre application peut publier les siens en implémentant
+`getMcpTools(): IMcpTool[]` :
+
+```ts
+import { Module, mcpText, type IMcpTool } from "nodefony";
+
+class Shop extends Module {
+  getMcpTools(): IMcpTool[] {
+    return [
+      {
+        name: "shop_stock",
+        description:
+          "Stock réel d'une référence produit. À utiliser avant de proposer " +
+          "une commande — la réponse vient de la base, pas d'un cache.",
+        inputSchema: {
+          type: "object",
+          properties: { sku: { type: "string" } },
+          required: ["sku"],
+        },
+        handler: async (args) => mcpText(await this.stock(String(args.sku))),
+      },
+    ];
+  }
+}
+```
+
+Rien ne s'enregistre au démarrage : la liste est relue à chaque requête, et
+`mcp.tools` ne filtre que les outils **intégrés** — le vôtre est publié dès qu'il
+est déclaré. Un outil écarté (nom hors forme, nom déjà pris, handler absent) le
+dit en `WARNING`, jamais en silence.
+
+Un outil peut aussi se **réserver** — `scopes: ["shop:read"]` (tous exigés) ou
+`requiresAuth: true` — et son handler reçoit alors l'appelant en second
+paramètre. Il est alors absent de `tools/list` **et** inappelable en le nommant.
+🔴 Tant que la porte n'authentifie personne, un tel outil ne sortira jamais :
+c'est fermé par défaut, et c'est voulu. Détail et pièges :
+[la documentation du module](./docs/index.md).
+
+## Les skills d'agent
+
+Le paquet livre six **skills** au format [Agent Skills](https://agentskills.io)
+— la marche à suivre complète pour les tâches où un agent, sans eux, inventerait
+du code : créer une ressource REST, ajouter un service injectable, réserver une
+route à qui est habilité, ouvrir un canal temps réel, faire évoluer le schéma
+d'une base sans la détruire, et voir puis MESURER un écran dans un navigateur
+piloté. Ils sont lus par tout client conforme (Claude Code, Cursor, Copilot,
+VS Code, Codex, Goose…).
+
+`nodefony create app` les met à disposition à la création. Après un
+`npm update`, une commande les remet à jour :
+
+```bash
+npx nodefony ai:sync            # --dry-run pour voir sans écrire, --json pour un script
+```
+
+```
+  Skills d'agent — .agents/skills
+
+  = nodefony-add-crud              @nodefony/devkit
+  = nodefony-add-realtime-channel  @nodefony/devkit
+  = nodefony-add-service           @nodefony/devkit
+  = nodefony-browser               @nodefony/devkit
+  = nodefony-migrate-schema        @nodefony/devkit
+  = nodefony-protect-route         @nodefony/devkit
+
+  0 posé(s) · 0 mis à jour · 6 inchangé(s)
+```
+
+**Le préfixe `nodefony-` vous laisse la place.** Ces pointeurs arrivent dans
+`.agents/skills/`, le dossier où vous écrivez aussi les vôtres : sans namespace,
+un `add-crud` propre à votre métier et le nôtre se disputeraient un nom — et
+c'est `ai:sync` qui écraserait le vôtre à la synchronisation suivante. Vos skills
+n'ont donc aucune contrainte de nommage, sauf à commencer par `nodefony-`.
+
+**Ce qui est écrit chez vous est un POINTEUR, pas une copie.** Le contenu reste
+dans le paquet et suit vos montées de version ; un skill recopié dans le projet
+décrirait, six mois plus tard, un framework qui a changé — sans casser le build,
+donc sans que personne le voie. Les pointeurs sont faits pour être **commités** :
+votre équipe et votre intégration continue disposent alors des mêmes skills.
+
+Le dossier visé, `.agents/skills/`, est celui que **tous** les clients conformes
+lisent — pas le dossier propriétaire d'un seul. Si le vôtre ne scanne que le
+sien, ajoutez-y ce chemin plutôt que de dupliquer un contenu qui divergerait.
+
+Deux garanties de la commande : un pointeur déjà à jour n'est **pas réécrit**
+(votre arbre git reste propre, l'horodatage ne bouge pas), et un pointeur que
+plus aucun paquet ne livre est **signalé, jamais supprimé** — vous avez pu en
+écrire un à la main sous le même nom.
+
+> **Aucun `postinstall`** ne fait ce geste, volontairement : `--ignore-scripts`
+> est courant, les scripts d'installation sont un vecteur d'attaque connu de
+> l'écosystème npm, et écrire dans un dossier versionné à chaque installation
+> produirait des différences surprises. La commande, elle, se lance quand vous
+> le décidez. Un module tiers qui livre ses propres skills est servi par la même
+> commande : elle scanne tout paquet `@nodefony/*` **et** les modules locaux de
+> l'application, sans que le cœur ait à les connaître.
+
+## Configuration
+
+| Clé       | Type      | Défaut | Rôle                   |
+| --------- | --------- | ------ | ---------------------- |
+| `enabled` | `boolean` | `true` | Interrupteur du module |
+
+La source unique est le schéma Zod de `nodefony/config/config.ts` : c'est lui qui
+porte les défauts, les descriptions et la validation. Une clé inconnue ou mal
+typée fait échouer le **boot**, en nommant le champ fautif.
+
+Surcharge par l'application : `use("@nodefony/devkit", { enabled: false })`.
+Par l'environnement : `NF__DEVKIT__ENABLED=false`.
+
+## Ce qu'il ne fait pas
+
+- **Il n'invente rien.** Tout ce qu'il rend est DÉRIVÉ de l'état du Kernel,
+  recalculé à chaque lecture, jamais mis en cache — une carte en cache mentirait
+  au premier module ajouté.
+- **Il ne crée rien.** Le scaffold (`nodefony create …`), le diagnostic
+  (`nodefony doctor`) et l'introspection (`nodefony inspect`) vivent dans le
+  cœur : ils doivent répondre sans qu'aucun module soit installé, et quand
+  l'application est cassée.
+- **Il ne dépend d'aucun fournisseur de modèle.** Son intérêt est de servir
+  l'agent que vous avez déjà.
+- **Il ne s'installe pas tout seul dans votre projet.** Aucun `postinstall` :
+  les pointeurs de skills sont posés par `create app` à la création, et remis à
+  jour par `ai:sync` quand vous le demandez.
+
+## Développer
+
+```bash
+npm run build       # rolldown → dist/ + déclarations .d.ts
+npm run typecheck   # tsgo --noEmit (sources + tests)
+npm test            # vitest
+```
+
+## Structure
+
+```
+@nodefony/devkit/
+├── index.ts                          ← la classe Module + les exports publics
+├── nodefony/
+│   ├── config/config.ts              ← schéma Zod = source unique des défauts
+│   ├── config/defineModuleConfig.ts  ← builder pur (valide, gèle)
+│   ├── src/card.ts                   ← ré-export du cœur (la composition y vit)
+│   ├── service/DevkitService.ts      ← dérive la carte du Kernel (`container.get("devkit")`)
+│   ├── controllers/DevkitController.ts ← la porte HTTP
+│   └── interfaces/                   ← l'API publique du service
+├── skills/<nom>/SKILL.md             ← les skills d'agent livrés par npm
+├── docs/                             ← documentation, surfacée dans Studio
+└── tests/
+```
+
+`dist/`, `docs/` et `skills/` sont les trois dossiers publiés (`files`) : un
+skill se corrige ici, et la correction arrive chez l'utilisateur par
+`npm update`, sans qu'il ait un fichier à réécrire.

package/dist/_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as default };

package/dist/_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/decorateMetadata.js

@@ -0,0 +1,6 @@
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+export { __decorateMetadata as default };

package/dist/_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/decorateParam.js

@@ -0,0 +1,8 @@
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+export { __decorateParam as default };

package/dist/_virtual/_@oxc-project_runtime@0.143.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as default };

package/dist/_virtual/_@oxc-project_runtime@0.143.0/helpers/esm/decorateMetadata.js

@@ -0,0 +1,6 @@
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+export { __decorateMetadata as default };

package/dist/_virtual/_@oxc-project_runtime@0.143.0/helpers/esm/decorateParam.js

@@ -0,0 +1,8 @@
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+export { __decorateParam as default };

package/dist/_virtual/_@oxc-project_runtime@0.146.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.146.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as default };

package/dist/_virtual/_@oxc-project_runtime@0.146.0/helpers/esm/decorateMetadata.js

@@ -0,0 +1,6 @@
+//#region \0@oxc-project+runtime@0.146.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+export { __decorateMetadata as default };

package/dist/_virtual/_@oxc-project_runtime@0.146.0/helpers/esm/decorateParam.js

@@ -0,0 +1,8 @@
+//#region \0@oxc-project+runtime@0.146.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+export { __decorateParam as default };

package/dist/_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as default };

package/dist/_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateMetadata.js

@@ -0,0 +1,6 @@
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+export { __decorateMetadata as default };

package/dist/_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateParam.js

@@ -0,0 +1,8 @@
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+export { __decorateParam as default };

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as default };

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js

@@ -0,0 +1,6 @@
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+export { __decorateMetadata as default };

package/dist/_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js

@@ -0,0 +1,8 @@
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+export { __decorateParam as default };

package/dist/index.js

@@ -0,0 +1,47 @@
+import defaults, { devkitConfigSchema } from "./nodefony/config/config.js";
+import { defineDevkitConfig } from "./nodefony/config/defineModuleConfig.js";
+import { buildCard } from "./nodefony/src/card.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import DevkitService_default from "./nodefony/service/DevkitService.js";
+import DevkitController_default from "./nodefony/controllers/DevkitController.js";
+import McpController_default from "./nodefony/controllers/McpController.js";
+import { Kernel, Module, services } from "nodefony";
+import { controllers } from "@nodefony/framework";
+//#region index.ts
+let DevkitModule = class DevkitModule extends Module {
+	/**
+	* ⚠️ Ce module ne pose PLUS de commande CLI.
+	*
+	* `devkit:card` vivait ici, et n'existait donc que lorsque le module était
+	* chargé : hors développement (`policy: "dev"`) le CLI répondait
+	* `unknown command`, et sur une application non encore construite le Kernel
+	* refusait de démarrer avant elle. Une carte de visite qui disparaît selon
+	* l'environnement n'accueille personne. Elle est désormais servie par le cœur
+	* (`nodefony card`, alias `devkit:card`, standalone 0-boot — fast-path de
+	* `CliKernel.start`), qui ne lit que des fichiers.
+	*
+	* Ce module garde la porte HTTP : elle, et elle seule, connaît les modules
+	* réellement CHARGÉS.
+	*/
+	constructor(kernel) {
+		super("devkit", kernel, import.meta.url, defaults);
+	}
+	/**
+	* Valide la config au boot — défauts du schéma fusionnés avec ce que l'app
+	* passe dans `use()`. Une clé inconnue ou mal typée plante ICI, avec le champ
+	* fautif nommé, plutôt qu'en `undefined.x` au premier appel en production.
+	*/
+	async onKernelRegister() {
+		this.options = defineDevkitConfig(this.options ?? {});
+		return this;
+	}
+};
+DevkitModule = __decorate([
+	controllers([DevkitController_default, McpController_default]),
+	services([DevkitService_default]),
+	__decorateMetadata("design:paramtypes", [typeof Kernel === "undefined" ? Object : Kernel])
+], DevkitModule);
+var devkit_default = DevkitModule;
+//#endregion
+export { DevkitController_default as DevkitController, DevkitService_default as DevkitService, McpController_default as McpController, buildCard, devkit_default as default, defineDevkitConfig, devkitConfigSchema };

package/dist/nodefony/command/CardCommand.js

@@ -0,0 +1,70 @@
+import { Command } from "nodefony";
+//#region nodefony/command/CardCommand.ts
+/**
+* `onReady` : les services sont construits, AUCUN serveur n'écoute. La carte se
+* lit dans l'état du kernel — ouvrir un port pour la rendre serait payer un
+* démarrage complet pour une réponse qui n'en dépend pas.
+*/
+const options = {
+	showBanner: false,
+	kernelEvent: "onReady"
+};
+/**
+* `nodefony devkit:card [-j]` — qui répond, et où aller ensuite.
+*
+* ## Pourquoi une commande, alors que la route existe
+*
+* La route HTTP vit sous `/nodefony`, que le pare-feu d'une application réelle
+* couvre : un agent qui code ne s'authentifie pas, et n'a pas de navigateur. La
+* porte qu'il a déjà, c'est le terminal. Même source (le service), deux rendus —
+* ajouter une porte n'ajoute jamais une vérité.
+*
+* ⚠️ Le module est `policy: "dev"` : hors développement il n'est pas chargé, donc
+* cette commande **n'existe pas**. C'est voulu — et c'est pour ça qu'elle
+* s'invoque `NODE_ENV=development npx nodefony devkit:card` depuis un terminal
+* qui n'aurait pas posé la variable.
+*/
+var CardCommand = class CardCommand extends Command {
+	constructor(cli) {
+		super("devkit:card", "Imprime la carte de visite de l application", cli, options);
+		this.addOption("-j, --json", "sortie JSON brute (scriptable, `| jq`)");
+	}
+	async generate(opts) {
+		const svc = this.kernel?.container?.get("devkit");
+		if (!svc) {
+			this.log("service « devkit » non enregistré — module non chargé (policy dev) ?", "ERROR");
+			return this;
+		}
+		const card = svc.getCard();
+		if (opts.json) {
+			process.stdout.write(`${JSON.stringify(card, null, 2)}\n`);
+			return this;
+		}
+		process.stdout.write(CardCommand.format(card));
+		return this;
+	}
+	/**
+	* Rend la carte pour un HUMAIN (ou un agent qui lit un terminal).
+	*
+	* Statique et PURE : elle ne touche ni au kernel ni au service, donc elle
+	* s'éprouve seule. Sortie sur `stdout` plutôt que par le journal — une carte
+	* de visite n'est pas un événement de log, et le préfixe horodaté rendrait le
+	* copier-coller inutilisable.
+	*/
+	static format(card) {
+		return [
+			`${card.app.name} ${card.app.version} — ${card.app.environment} (nodefony ${card.nodefony.version})`,
+			"",
+			`Modules chargés (${card.modules.length}) : ${card.modules.join(", ")}`,
+			"",
+			"Où aller :",
+			...card.portes.map((p) => `  ${p.ou}\n      ${p.titre} — ${p.pourquoi}`),
+			"",
+			"Quoi lancer :",
+			...card.verbes.map((v) => `  ${v.commande}\n      ${v.pourquoi}`),
+			""
+		].join("\n");
+	}
+};
+//#endregion
+export { CardCommand as default };