@dev-kosaly/kagents 0.1.0 → 0.2.0

package/bin/kagents.js

@@ -5,39 +5,49 @@
 
 const fs = require('fs');
 const path = require('path');
+const readline = require('readline');
+const tty = require('tty');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
 const PKG = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
-const KIT_DIRS = ['agents', 'skills', 'commands', 'templates', 'checklists', 'workflows', 'governance'];
+const KIT_DIRS = ['agents', 'skills', 'commands', 'rules', 'templates', 'checklists', 'workflows', 'governance', 'docs'];
 const SKIP = new Set(['README.md', '.gitkeep']);
 const BLOCK_RE = /<!-- kagents:start -->[\s\S]*?<!-- kagents:end -->/;
+const GITIGNORE_RE = /# kagents:start\n[\s\S]*?# kagents:end\n?/;
+// On ignore le kit (régénérable) mais pas docs/ : livrables et contexte sont à versionner.
 
 // Adaptateurs : un outil = une liste [dossier du kit, destination, type].
 // type : files (fichiers), dirs (dossiers), agents (fichiers .md avec `name:`).
+// Les skills ne sont volontairement PAS liées dans .claude/ ni .cursor/ : ces outils les listeraient
+// comme commandes `/`. Les agents et commandes les chargent par chemin depuis .kagents/skills/.
 const ADAPTERS = {
   agents: [['skills', '.agents/skills', 'dirs']],
   claude: [
     ['commands', '.claude/commands', 'files'],
-    ['skills', '.claude/skills', 'dirs'],
     ['agents', '.claude/agents', 'agents'],
   ],
   cursor: [
     ['commands', '.cursor/commands', 'files'],
-    ['skills', '.cursor/skills', 'dirs'],
     ['agents', '.cursor/agents', 'agents'],
+    ['rules/global', '.cursor/rules', 'files'],
+    ['rules/domains', '.cursor/rules', 'files'],
   ],
 };
 
 const HELP = `kagents ${PKG.version}
 
-Usage : kagents [install] [--tools claude,cursor,agents|auto] [--copy]
+Usage : kagents [install] [--tools claude,cursor,agents|auto|none] [--yes] [--copy]
+        kagents --configure          (rechoisir les outils)
         kagents uninstall
         kagents --help | --version
 
-À lancer depuis la racine du projet.
-  --tools   outils à brancher (défaut : auto = agents + claude/cursor s'ils sont détectés)
-  --copy    copies au lieu de liens symboliques (aussi la variable KAGENTS_MODE=copy)
-  uninstall retire ce que KAgents a installé (docs/ est conservé)
+À lancer depuis la racine du projet. Dans un terminal, une liste permet de choisir
+les outils à brancher ; le choix est mémorisé dans .kagents/config.json.
+  --tools      outils à brancher, sans question
+  --yes, -y    ne pose pas de question (détection automatique)
+  --configure  pose à nouveau la question
+  --copy       copies au lieu de liens symboliques (aussi KAGENTS_MODE=copy)
+  uninstall    retire ce que KAgents a installé (docs/ est conservé)
 `;
 
 const log = (m) => console.log(`kagents: ${m}`);
@@ -49,12 +59,14 @@ const die = (m) => {
 
 // --- Arguments ----------------------------------------------------------------
 function parseArgs(argv) {
-  const o = { cmd: 'install', tools: 'auto', copy: process.env.KAGENTS_MODE === 'copy' };
+  const o = { cmd: 'install', tools: null, yes: false, configure: false, copy: process.env.KAGENTS_MODE === 'copy' };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === '-h' || a === '--help') o.cmd = 'help';
     else if (a === '-v' || a === '--version') o.cmd = 'version';
     else if (a === '--copy') o.copy = true;
+    else if (a === '-y' || a === '--yes') o.yes = true;
+    else if (a === '--configure') o.configure = true;
     else if (a === '--tools') o.tools = argv[++i] || die('--tools attend une valeur');
     else if (a.startsWith('--tools=')) o.tools = a.slice(8);
     else if (a === 'install' || a === 'uninstall') o.cmd = a;
@@ -100,6 +112,7 @@ class Installer {
     this.copy = copy;
     this.kagents = path.join(target, '.kagents');
     this.manifest = path.join(this.kagents, '.installed');
+    this.config = path.join(this.kagents, 'config.json');
     this.entries = [];
   }
 
@@ -168,6 +181,7 @@ class Installer {
       const docs = frontmatter(path.join(this.kagents, 'agents', f)).docs;
       if (docs) fs.mkdirSync(path.join(this.kagents, 'docs', docs), { recursive: true });
     }
+    this.createArchitectDocs();
     const ctx = path.join(this.kagents, 'docs', 'knowledge', 'context.md');
     if (!fs.existsSync(ctx)) {
       fs.writeFileSync(
@@ -196,6 +210,17 @@ Document partagé, écrit par l'utilisateur. Les agents le lisent, ne l'écriven
     }
   }
 
+  // Espace de l'Architect : livrables, décisions, propositions et INDEX.md (créé une fois, jamais écrasé).
+  createArchitectDocs() {
+    const root = path.join(this.kagents, 'docs', 'architect-docs');
+    if (!fs.existsSync(root)) return;
+    for (const d of ['architecture', 'impacts', 'features', 'specs', 'designs', 'audits'].map((n) => `outputs/${n}`).concat(['decisions', 'proposals']))
+      fs.mkdirSync(path.join(root, d), { recursive: true });
+    const index = path.join(root, 'INDEX.md');
+    const tpl = path.join(this.kagents, 'templates', 'architect-index', 'INDEX.template.md');
+    if (!fs.existsSync(index) && fs.existsSync(tpl)) fs.copyFileSync(tpl, index);
+  }
+
   renderBlock() {
     const agentsDir = path.join(this.kagents, 'agents');
     const cmdDir = path.join(this.kagents, 'commands');
@@ -252,15 +277,49 @@ Document partagé, écrit par l'utilisateur. Les agents le lisent, ne l'écriven
     fs.writeFileSync(file, out);
   }
 
-  resolveTools(tools) {
-    if (tools !== 'auto') return tools.split(',').filter(Boolean);
-    const t = ['agents'];
+  // Bloc .gitignore : le kit et les liens que l'on a posés, jamais docs/ (sauf les fichiers du kit qui s'y trouvent).
+  gitignoreBlock() {
+    const extra = this.entries.filter((e) => !e.startsWith('.kagents/') || e.startsWith('.kagents/docs/')).sort();
+    return ['# kagents:start', '.kagents/*', '!.kagents/docs/', ...extra, '# kagents:end'].join('\n') + '\n';
+  }
+
+  writeGitignore() {
+    const file = path.join(this.target, '.gitignore');
+    if (!fs.existsSync(file) && !fs.existsSync(path.join(this.target, '.git'))) return;
+    const cur = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+    const block = this.gitignoreBlock();
+    const out = GITIGNORE_RE.test(cur)
+      ? cur.replace(GITIGNORE_RE, () => block)
+      : (cur && !cur.endsWith('\n') ? cur + '\n' : cur) + (cur ? '\n' : '') + block;
+    fs.writeFileSync(file, out);
+  }
+
+  detectTools() {
     const has = (p) => fs.existsSync(path.join(this.target, p));
+    const t = [];
     if (has('.claude') || has('CLAUDE.md')) t.push('claude');
     if (has('.cursor')) t.push('cursor');
     return t;
   }
 
+  resolveTools(tools) {
+    return tools === 'auto' ? ['agents', ...this.detectTools()] : tools;
+  }
+
+  loadConfig() {
+    try {
+      const c = JSON.parse(fs.readFileSync(this.config, 'utf8'));
+      return Array.isArray(c.tools) ? c.tools : null;
+    } catch {
+      return null;
+    }
+  }
+
+  saveConfig(tools) {
+    fs.mkdirSync(this.kagents, { recursive: true });
+    fs.writeFileSync(this.config, JSON.stringify({ tools }, null, 2) + '\n');
+  }
+
   runAdapters(tools) {
     for (const tool of this.resolveTools(tools)) {
       if (!ADAPTERS[tool]) {
@@ -312,6 +371,7 @@ Document partagé, écrit par l'utilisateur. Les agents le lisent, ne l'écriven
     this.createDocs();
     this.writeAgentsMd();
     this.runAdapters(tools);
+    this.writeGitignore();
     this.saveManifest();
     log(`installé dans ${this.kagents} (${this.copy ? 'copies' : 'liens'})`);
   }
@@ -327,22 +387,125 @@ Document partagé, écrit par l'utilisateur. Les agents le lisent, ne l'écriven
         else fs.rmSync(file);
       }
     }
+    const gi = path.join(this.target, '.gitignore');
+    if (fs.existsSync(gi) && GITIGNORE_RE.test(fs.readFileSync(gi, 'utf8'))) {
+      const out = fs.readFileSync(gi, 'utf8').replace(GITIGNORE_RE, '').replace(/\n{3,}/g, '\n\n').replace(/\s+$/, '');
+      if (out) fs.writeFileSync(gi, out + '\n');
+      else fs.rmSync(gi);
+    }
     fs.rmSync(this.manifest, { force: true });
+    fs.rmSync(this.config, { force: true });
     this.prune(removed);
     log('désinstallé (.kagents/docs/ conservé : ce sont vos livrables)');
   }
 }
 
+// --- Question interactive -----------------------------------------------------
+// Terminal utilisable : le nôtre, ou /dev/tty quand on est lancé par un postinstall (stdin/stdout détournés).
+function openTTY() {
+  if (process.stdin.isTTY && process.stdout.isTTY) return { input: process.stdin, output: process.stdout, close() {} };
+  if (process.env.KAGENTS_FROM_POSTINSTALL && process.platform !== 'win32') {
+    try {
+      const rfd = fs.openSync('/dev/tty', 'r');
+      const wfd = fs.openSync('/dev/tty', 'w');
+      const input = new tty.ReadStream(rfd);
+      const output = new tty.WriteStream(wfd);
+      return { input, output, close: () => { input.destroy(); output.destroy(); } };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// Liste à cocher : ↑↓ déplacer, espace cocher, a tout, entrée valider. Renvoie les ids cochés.
+function multiselect(io, message, items) {
+  return new Promise((resolve) => {
+    const { input, output } = io;
+    const state = items.map((i) => ({ ...i }));
+    let cur = 0;
+    let drawn = false;
+    const draw = () => {
+      if (drawn) output.write(`\x1b[${state.length + 1}A`);
+      drawn = true;
+      output.write(`\x1b[2K\x1b[1m?\x1b[0m ${message}\n`);
+      state.forEach((it, i) => {
+        const box = it.checked ? '\x1b[32m◉\x1b[0m' : '◯';
+        output.write(`\x1b[2K ${i === cur ? '\x1b[36m❯\x1b[0m' : ' '} ${box} ${it.label}\n`);
+      });
+    };
+    const finish = () => {
+      input.removeListener('keypress', onKey);
+      input.setRawMode(false);
+      input.pause();
+      output.write('\x1b[?25h');
+      io.close();
+      resolve(state.filter((i) => i.checked).map((i) => i.id));
+    };
+    const onKey = (str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        output.write('\x1b[?25h\n');
+        process.exit(130);
+      }
+      if (key.name === 'up') cur = (cur + state.length - 1) % state.length;
+      else if (key.name === 'down') cur = (cur + 1) % state.length;
+      else if (key.name === 'space') state[cur].checked = !state[cur].checked;
+      else if (key.name === 'a') {
+        const all = state.every((i) => i.checked);
+        state.forEach((i) => (i.checked = !all));
+      } else if (key.name === 'return') {
+        draw();
+        return finish();
+      }
+      draw();
+    };
+    readline.emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    output.write('\x1b[?25l');
+    input.on('keypress', onKey);
+    draw();
+  });
+}
+
+async function chooseTools(inst, o) {
+  if (o.tools) {
+    const t = o.tools === 'auto' ? 'auto' : o.tools === 'none' ? [] : o.tools.split(',').filter(Boolean);
+    if (t !== 'auto') inst.chosen = t;
+    return t;
+  }
+  if (!o.configure) {
+    const saved = inst.loadConfig();
+    if (saved) return saved;
+  }
+  if (!o.yes && !process.env.KAGENTS_NO_PROMPT && !process.env.CI) {
+    const io = openTTY();
+    if (io) {
+      const detected = inst.detectTools();
+      const picked = await multiselect(io, 'Pour quels outils installer KAgents ?  (↑↓ espace a entrée)', [
+        { id: 'claude', label: 'Claude Code  (.claude/commands, .claude/agents)', checked: detected.includes('claude') },
+        { id: 'cursor', label: 'Cursor  (.cursor/commands, .cursor/agents, .cursor/rules)', checked: detected.includes('cursor') },
+        { id: 'agents', label: 'Codex et autres outils AGENTS.md  (.agents/skills)', checked: true },
+      ]);
+      inst.chosen = picked;
+      return picked;
+    }
+  }
+  return 'auto';
+}
+
 // --- Main ---------------------------------------------------------------------
-function main() {
+async function main() {
   const o = parseArgs(process.argv.slice(2));
   if (o.cmd === 'help') return console.log(HELP);
   if (o.cmd === 'version') return console.log(PKG.version);
   const target = process.cwd();
   if (path.resolve(target) === PKG_ROOT) die("à lancer depuis la racine d'un projet, pas depuis le kit.");
   const inst = new Installer(target, o.copy);
-  if (o.cmd === 'uninstall') inst.uninstall();
-  else inst.install(o.tools);
+  if (o.cmd === 'uninstall') return inst.uninstall();
+  const tools = await chooseTools(inst, o);
+  inst.install(tools);
+  if (inst.chosen) inst.saveConfig(inst.chosen);
 }
 
 main();

package/bin/postinstall.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+// Lancé par npm/pnpm après `add @dev-kosaly/kagents` : installe le kit dans le projet.
+// Ne doit jamais faire échouer l'installation des dépendances.
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const pkgRoot = path.resolve(__dirname, '..');
+const project = process.env.INIT_CWD;
+
+const skip = (why) => {
+  if (why) console.log(`kagents: installation automatique ignorée (${why}). Lancez : npx kagents`);
+  process.exit(0);
+};
+
+if (process.env.KAGENTS_SKIP_POSTINSTALL) skip();
+if (!project) skip();
+if (process.env.npm_config_global === 'true') skip('installation globale');
+if (!pkgRoot.split(path.sep).includes('node_modules')) skip(); // développement du kit lui-même
+if (path.resolve(project) === pkgRoot) skip();
+
+try {
+  spawnSync(process.execPath, [path.join(__dirname, 'kagents.js')], { cwd: project, stdio: 'inherit', env: { ...process.env, KAGENTS_FROM_POSTINSTALL: '1' } });
+} catch {
+  /* jamais bloquant */
+}

package/commands/architect-audit.md

@@ -0,0 +1,17 @@
+---
+description: Architect — auditer l'architecture existante
+agent: architect
+mode: Audit
+triggers: audite l'architecture existante
+---
+Lis le role Architect.
+
+Commande : **`kagents architect:audit [scope]`**.
+
+Identifier incoherences, derives, ecarts doc/code **uniquement si observes**. Ne pas modifier le code.
+
+Skills internes : `architect-audit`, `architect-write-output`, `architect-index`.
+
+Workflow : `workflows/architect-audit-run.md`.
+
+Scope optionnel : $ARGUMENTS

package/commands/architect-compare.md

@@ -0,0 +1,13 @@
+---
+description: Architect — comparer des options (extension future)
+agent: architect
+mode: Comparaison (non implémenté)
+triggers: compare ces options d'architecture
+---
+**Extension preparee — non implementee.**
+
+Commande prevue : `kagents architect:compare "<question>"`.
+
+Voir `docs/architect-commands.md`. Ne pas simuler un workflow complet tant qu'il n'est pas defini.
+
+Question : $ARGUMENTS

package/commands/architect-decision.md

@@ -0,0 +1,20 @@
+---
+description: Architect — enregistrer une decision humaine explicitement fournie
+agent: architect
+mode: Décision humaine
+triggers: enregistre cette décision d'architecture
+---
+Lis `agents/architect.md`.
+
+Commande : **`kagents architect:decision "<decision>"`**.
+
+Le argument utilisateur **est** la decision a enregistrer (confirmation humaine implicite via la commande). Ce n'est pas une question a resoudre.
+
+Skill : `architect-decision`.
+Workflow : `workflows/architect-decision.md`.
+Template : `templates/architect-decision/template.md`.
+Cible : `.kagents/docs/architect-docs/decisions/DEC-XXX-<slug>.md`
+
+Statut par defaut : **VALIDEE**. Ne jamais promouvoir une PROPOSITION agent sans cette commande.
+
+Decision a enregistrer : $ARGUMENTS

package/commands/architect-design.md

@@ -0,0 +1,18 @@
+---
+description: Architect — concevoir une architecture cible (proposition)
+agent: architect
+mode: Architecture cible
+triggers: conçois l'architecture cible, propose une architecture
+---
+Lis le role Architect.
+
+Commande : **`kagents architect:design "<objectif>"`**.
+
+Distinction : `kagents architect` = observe ; `kagents architect:design` = **cible proposee** (PROPOSITION, pas decision).
+
+Skills internes : `architect-discovery` (existant), `architect-write-output`, `architect-index`.
+
+Workflow : `workflows/architect-design.md`.
+Template : `templates/architect-design/template.md`.
+
+Objectif : $ARGUMENTS

package/commands/architect-impact.md

@@ -0,0 +1,16 @@
+---
+description: Architect — impact d'une evolution sur l'architecture existante
+agent: architect
+mode: Impact
+triggers: avant de coder, impact d'une évolution, ajouter une fonctionnalité
+---
+Lis le role Architect (chemins ci-dessus).
+
+Commande officielle : **`kagents architect:impact "<demande>"`**.
+
+Skills internes : `architect-audit` (si besoin), `architect-impact`, `architect-write-output`, `architect-index`.
+
+Workflow : `workflows/architect-impact.md`.
+Niveaux : `workflows/architect-impact-levels.yaml`.
+
+Demande : $ARGUMENTS

package/commands/architect-spec.md

@@ -0,0 +1,18 @@
+---
+description: Architect — formaliser une fonctionnalite en specification
+agent: architect
+mode: Spécification
+triggers: spécifie cette fonctionnalité, rédige la spec
+---
+Lis le role Architect.
+
+Commande : **`kagents architect:spec "<fonctionnalite>"`**.
+
+Distinction : section **Impact** (ce que ca touche) vs **Spec** (comportement attendu). Ne pas inventer de regles metier.
+
+Skills internes : `architect-audit` (si besoin), `architect-impact` (partie impact uniquement), `architect-write-output`, `architect-index`.
+
+Workflow : `workflows/architect-spec.md`.
+Template : `templates/architect-spec/template.md`.
+
+Fonctionnalite : $ARGUMENTS

package/commands/architect-status.md

@@ -0,0 +1,26 @@
+---
+description: Architect — etat documentaire et architectural connu (read-only)
+agent: architect
+mode: État (lecture seule)
+triggers: où en est-on, état des décisions et propositions
+---
+Lis `agents/architect.md` (ou `.kagents/docs/architect-docs/architect.md`).
+
+Commande : **`kagents architect:status`**.
+
+Skill interne : `architect-status`.
+Workflow : `workflows/architect-status.md`.
+
+**Read-only** : pas de nouveau livrable obligatoire ; pas d'audit repo complet.
+
+Sortie chat type :
+
+# Architect — Etat du projet
+
+**Etat architectural :** ...
+**Derniere activite :** ...
+**Travaux ouverts / Decisions en attente / Blocages** (si presents)
+
+Sections adaptatives : Travaux en cours (tableau), Decisions, Handoffs, Points d'attention, Derniers livrables, Prochaine etape.
+
+Argument optionnel (filtre domaine) : $ARGUMENTS

package/commands/architect.md

@@ -0,0 +1,20 @@
+---
+description: Architect — vue de l'architecture observee du projet
+agent: architect
+mode: Architecture observée
+triggers: explique l'architecture, comment le projet est construit
+---
+Lis le role Architect :
+- projet client : `.kagents/docs/architect-docs/architect.md`
+- harness : `agents/architect.md`
+
+Commande officielle : **`kagents architect`** (ne pas utiliser `kagents architecture`).
+
+Applique la vue **architecture actuelle observee** — pas une analyse de feature.
+
+Skills internes : `architect-discovery`, `architect-write-output`, `architect-index`.
+
+Workflow : `workflows/architect-architecture.md`.
+Contrat : `docs/architect-commands.md`.
+
+Demande ou focus : $ARGUMENTS

package/docs/architect-commands.md

@@ -0,0 +1,52 @@
+# Contrat des commandes — Architect (public)
+
+Racine officielle : **`kagents architect`** (pas `kagents architecture`).
+
+Les skills `architect-*` sont **internes** ; l'utilisateur invoque une **commande**, pas une skill.
+
+## Priorite 1 — disponibles
+
+| Commande | Role | Workflow | Skills internes | Livrable |
+|----------|------|----------|-----------------|----------|
+| `kagents architect` | Architecture **observee** (existant) | `workflows/architect-architecture.md` | discovery, write-output, index | `outputs/architecture/` |
+| `kagents architect:impact "<demande>"` | Impact d'une evolution | `workflows/architect-impact.md` | audit?, impact, write-output, index | `outputs/features/` ou `outputs/impacts/` |
+| `kagents architect:spec "<fonctionnalite>"` | Spec exploitable (comportement attendu) | `workflows/architect-spec.md` | audit?, impact (partie impact), write-output, index | `outputs/specs/` |
+| `kagents architect:design "<objectif>"` | Architecture **cible** proposee | `workflows/architect-design.md` | discovery, write-output, index | `outputs/designs/` |
+| `kagents architect:audit [scope]` | Audit architecture existante | `workflows/architect-audit-run.md` | audit, write-output, index | `outputs/audits/` |
+| `kagents architect:status` | Etat documentaire (read-only) | `workflows/architect-status.md` | architect-status | chat |
+| `kagents architect:decision "<texte>"` | Decision **humaine** enregistree | `workflows/architect-decision.md` | architect-decision | `decisions/DEC-XXX-*.md` |
+
+Fichiers entree harness : `commands/architect*.md`.
+
+## Distinctions
+
+- **Impact** : ce que le changement **touche** (MVC, risques, L0–L3).
+- **Spec** : ce que la fonctionnalite doit **faire** (comportement, cas, criteres) + reference impact si pertinent.
+- **architect** (sans suffixe) : etat **reel** observe.
+- **architect:design** : etat **cible** PROPOSITION (jamais decision automatique).
+- **architect:status** : synthese **read-only** (INDEX, decisions, proposals, travaux ouverts) — pas d’audit repo complet.
+- **architect:decision** : enregistre une decision **explicitement fournie ou confirmee par l’humain** ; statut typique **VALIDEE** ; registre `decisions/DEC-XXX-*.md` + ligne dans INDEX. Une proposition dans `proposals/` ou un livrable n’est **pas** promue en decision sans cette commande.
+
+Statuts decision : PROPOSEE, A VALIDER, VALIDEE, REJETEE, REMPLACEE (remplacement sans suppression du fichier historique).
+
+## Priorite 2 — extension
+
+| Commande | Statut |
+|----------|--------|
+| `kagents architect:compare "<question>"` | Prepare — workflow a creer |
+
+Fichier : `commands/architect-compare.md`.
+
+## Mode naturel
+
+Formulations sans commande → resolver vers la commande la plus proche (souvent `architect:impact` ou `architect`).
+
+## Database Architect (Base)
+
+**Hors scope.** Commandes inchangees : `commands/base-audit.md`, `base-design.md`, `base-evolve.md`.
+
+## Chaine d'execution
+
+```text
+Commande → agents/architect.md → rules/architect-* → workflow → skills → template → livrable → INDEX → chat
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-kosaly/kagents",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Kit d'agents IA d'ingénierie installable dans un projet (Claude Code, Cursor, AGENTS.md)",
   "bin": {
     "kagents": "bin/kagents.js"
@@ -10,10 +10,12 @@
     "agents",
     "skills",
     "commands",
+    "rules",
     "templates",
     "checklists",
     "workflows",
-    "governance"
+    "governance",
+    "docs"
   ],
   "engines": {
     "node": ">=18"
@@ -27,6 +29,7 @@
     "access": "public"
   },
   "scripts": {
+    "postinstall": "node bin/postinstall.js",
     "test": "node scripts/smoke-test.js",
     "prepublishOnly": "npm test"
   },

package/rules/domains/architect-chat.md

@@ -0,0 +1,61 @@
+# Contrat de sortie chat — Architect
+
+Reference adaptative — omettre les sections sans contenu utile.
+
+Priorite : **Clarte > Pertinence > Structure > Concision > Esthetique**.
+
+```markdown
+# Architect — [titre]
+
+**Mode :** Architecture | Impact
+**Niveau :** L0 | L1 | L2 | L3
+**Statut :** ETABLI | A VALIDER | BLOQUANT (selon le cas)
+
+## Synthese
+
+Quelques paragraphes : conclusion immediate, ce qui a ete analyse, proposition retenue.
+
+## Constats principaux
+
+Tableau ou liste (elements importants seulement).
+
+## Impact architectural
+
+Tableau MVC si mode Impact (ou « Pas d'impact identifie » par couche).
+
+| Couche | Impact | Element cle |
+|--------|--------|-------------|
+| Modele | | |
+| Controleur | | |
+| Vue | | |
+
+## Architecture concernee
+
+Diagramme Mermaid ou schema **uniquement** si cela clarifie flux ou composants.
+
+## Points a decider
+
+Decisions humaines importantes (pas les propositions de l'agent presentees comme decidees).
+
+## Incertitudes / points bloquants
+
+Ce qui influence la suite (max 5 questions bloquantes).
+
+## Handoff
+
+### Base (Database Expert)
+Si BDD / donnees concernees : ce que Base doit analyser dans `base-docs/`.
+
+### Suite du travail
+Validation humaine, Base, puis implementation (Developer hors scope de ce role).
+
+## Prochaine etape
+
+Action concrete.
+
+## Livrable
+
+Chemin exact : `.kagents/docs/architect-docs/outputs/...`
+```
+
+Le chat **n'est pas** une copie du fichier persistant. Ne pas lister tous les fichiers du repo.

package/rules/domains/architect-invariants.md

@@ -0,0 +1,22 @@
+# Invariants — Architect / Spec
+
+## Non-negociable
+
+- Ne pas modifier le code applicatif, migrations, modeles, ni `base-docs/`.
+- Ne pas ecrire SQL ni imposer un schema BDD.
+- Ne pas modifier les commandes, agents ou skills Base.
+- Ne pas lire ni recopier secrets (`.env`, credentials, tokens).
+- Ne pas ecraser un livrable dans `architect-docs/outputs/` sans suffixe version explicite.
+- Ne pas transformer PROPOSITION / DEDUIT en ETABLI sans source.
+
+## Qualification
+
+Chaque affirmation importante porte un statut : ETABLI, DEDUIT, PROPOSITION, A VALIDER, INCONNU, BLOQUANT.
+
+## Repository vs documentation
+
+Le code prevaut en cas de divergence avec une doc obsolete ; signaler l'ecart, ne pas trancher silencieusement.
+
+## knowledge/context.md
+
+Lecture autorisee. Ecriture automatique interdite sauf instruction explicite utilisateur ou politique projet documentee.