create-byan-agent 2.60.1 → 2.60.2

package/install/templates/.claude/hooks/inject-voice-anchor.js

@@ -1,161 +1,28 @@
 #!/usr/bin/env node
-/**
- * UserPromptSubmit hook — keeps BYAN's voice present near the live edge each turn.
- *
- * Most turns inject a COMPACT voice anchor (~95 tokens). Every Nth turn re-inject
- * the FULL tao instead, so on a long session the heart is refreshed close to the
- * live edge. N defaults to 12 (override with BYAN_TAO_REFRESH_EVERY; <= 0 disables
- * the refresh, anchor every turn). The per-turn counter lives under _byan-output/
- * (gitignored) and is reset at SessionStart by inject-tao.js, so the cadence
- * restarts from each fresh full-tao load.
- *
- * Layered guarantee (best-effort, honest about its floor): each turn is a separate
- * process, so the cadence needs a WRITABLE counter file to advance. If _byan-output/
- * cannot be written, the counter cannot advance and this hook degrades to the anchor
- * every turn -- it never crashes (exit 0), and the full heart still returns via
- * inject-tao at SessionStart AND after every compaction (source=compact, pinned by
- * the F1 test). So the periodic refresh is the in-window ENHANCEMENT; the
- * SessionStart/compaction re-injection is the FLOOR that always holds. A persistent
- * degradation means _byan-output/ is not writable -- check its permissions.
- *
- * The full tao is read via inject-tao.buildTaoContext (single source, no
- * duplication; require is side-effect-free thanks to its require.main guard).
- * Always exits 0 ; never blocks prompt submission.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { buildTaoContext, turnCounterPath } = require('./inject-tao');
+'use strict';
+const communication = require('../../_byan/core/communication.cjs');
 const pl = require('./lib/plain-language');
 const gate = require('./lib/agent-gate');
 const voice = require('./lib/voice-conformance');
 
-const ANCHOR = [
-  'Voix BYAN (rappel par tour ; tao complet chargé au démarrage de session) :',
-  '- Tutoiement, registre artisan-senior, direct sans être brusque, concis.',
-  '- Challenge avant de confirmer ; questionne les absolus (Mantra IA-16).',
-  '- Signatures : "Attends — pourquoi ?", "OK. On construit.", "Ça, c\'est du générique.".',
-  '- Zéro emoji. Orienté solution : on cherche la meilleure option, pas le mur.',
-  '- Français réel et cohérent (Mantra IA-26) : pas d\'anglais gratuit (dis "redémarrer le conteneur", pas "cutoff"), pas de jargon interne brut ("nudge", "up-tier", "ladder", "runtime"), pas de métaphore collée de travers ("forger" un token).',
-  '- Précision factuelle : nomme l\'outil et le résultat observé ("byan_ping a répondu", pas "le MCP est vivant") ; un état = un fait mesuré, pas une image.',
-].join('\n');
-
-const DEFAULT_REFRESH_EVERY = 12;
-
-function buildVoiceAnchor() {
-  return ANCHOR;
-}
-
-// Turns between full-tao refreshes. Invalid/absent env -> default. A value <= 0
-// disables the periodic refresh (anchor every turn) -- an explicit opt-out.
-function refreshEvery(env = process.env) {
-  const n = parseInt(env.BYAN_TAO_REFRESH_EVERY, 10);
-  return Number.isInteger(n) ? n : DEFAULT_REFRESH_EVERY;
-}
-
-function readTurn(projectDir) {
-  try {
-    const n = parseInt(fs.readFileSync(turnCounterPath(projectDir), 'utf8').trim(), 10);
-    return Number.isInteger(n) && n >= 0 ? n : 0;
-  } catch {
-    return 0;
-  }
-}
-
-function writeTurn(projectDir, n) {
-  try {
-    const p = turnCounterPath(projectDir);
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    fs.writeFileSync(p, String(n));
-  } catch {
-    // Never block prompt submission.
-  }
-}
-
-// Pure cadence decision. Every Nth turn (N > 0) surfaces the full tao when it is
-// available; otherwise the compact anchor. Kept pure so the cadence is unit-testable
-// without fs.
-function decideAnchor({ turn, every, fullTao }) {
-  if (every > 0 && turn % every === 0 && fullTao) {
-    return { mode: 'full', additionalContext: fullTao };
-  }
-  return { mode: 'anchor', additionalContext: ANCHOR };
+// Stateless reload: no other session or discarded context can suppress this reminder.
+function buildVoiceAnchor(root = process.env.CLAUDE_PROJECT_DIR || process.cwd()) {
+  return communication.renderContract(communication.resolveContract(communication.loadPolicy(root), {}, 'conversation')) +
+    '\nLe profil affiché est le défaut, pas un choix imposé au livrable. Pour chaque production, choisir selon la demande et le public ; lire les règles du profil dans _byan/_config/communication-policy.json. Ne pas afficher les diagnostics dans le livrable.';
 }
-
-// Append a plain-language slip reminder (IA-25) to the injected context when the
-// previous turn tripped the forward net. Pure so it is unit-testable; the fs read
-// + clear stays in the require.main path below. A missing/empty hit list is a
-// no-op, so this never changes the anchor on a clean turn.
-function withSlipReminder(baseContext, hits) {
-  const reminder = pl.formatReminder(hits);
-  return reminder ? `${baseContext}\n${reminder}` : baseContext;
-}
-
-// Append the agent-gate reminder (F4) when the previous turn did a task directly
-// without proposing an agent. Pure; the fs read + clear stays in require.main.
-function withGateReminder(baseContext, slip) {
-  const reminder = gate.formatReminder(slip);
-  return reminder ? `${baseContext}\n${reminder}` : baseContext;
-}
-
-// Append the dispatch reminder (WI-3) when the previous turn wrote code without
-// consulting byan_dispatch. Pure; fs read + clear stays in require.main.
-function withDispatchReminder(baseContext, slip) {
-  const reminder = gate.formatDispatchReminder(slip);
-  return reminder ? `${baseContext}\n${reminder}` : baseContext;
-}
-
-// Append the voice-conformance reminder (WI-2) when the previous turn drifted from
-// the BYAN voice (emoji / vouvoiement). Pure; fs read + clear stays in require.main.
-function withVoiceReminder(baseContext, hits) {
-  const reminder = voice.formatReminder(hits);
-  return reminder ? `${baseContext}\n${reminder}` : baseContext;
-}
-
+function append(base, reminder) { return reminder ? `${base}\n${reminder}` : base; }
+function withSlipReminder(base, hits) { return append(base, pl.formatReminder(hits)); }
+function withGateReminder(base, slip) { return append(base, gate.formatReminder(slip)); }
+function withDispatchReminder(base, slip) { return append(base, gate.formatDispatchReminder(slip)); }
+function withVoiceReminder(base, hits) { return append(base, voice.formatReminder(hits)); }
 if (require.main === module) {
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  const every = refreshEvery();
-  const turn = readTurn(projectDir) + 1;
-  writeTurn(projectDir, turn);
-  const fullTao = every > 0 && turn % every === 0 ? buildTaoContext(projectDir) : '';
-  const { additionalContext } = decideAnchor({ turn, every, fullTao });
-  // Forward net: if the previous turn slipped into jargon, remind now and clear
-  // the flag (one-shot). Read/clear here, formatting stays pure in withSlipReminder.
-  const slipHits = pl.readSlip(projectDir);
-  if (slipHits && slipHits.length) pl.clearSlip(projectDir);
-  // Forward net #2 (F4): agent entry-gate slip. Read + clear one-shot.
-  const gateSlip = gate.readSlip(projectDir);
-  if (gateSlip) gate.clearSlip(projectDir);
-  // Forward net #3 (WI-3): dispatch-runtime slip. Read + clear one-shot.
-  const dispatchSlip = gate.readDispatchSlip(projectDir);
-  if (dispatchSlip) gate.clearDispatchSlip(projectDir);
-  // Forward net #4 (WI-2): voice-conformance slip. Read + clear one-shot.
-  const voiceHits = voice.readSlip(projectDir);
-  if (voiceHits && voiceHits.length) voice.clearSlip(projectDir);
-  let ctx = withSlipReminder(additionalContext, slipHits);
-  ctx = withGateReminder(ctx, gateSlip);
-  ctx = withDispatchReminder(ctx, dispatchSlip);
-  ctx = withVoiceReminder(ctx, voiceHits);
-  process.stdout.write(
-    JSON.stringify({
-      hookSpecificOutput: {
-        hookEventName: 'UserPromptSubmit',
-        additionalContext: ctx,
-      },
-    })
-  );
-}
-
-module.exports = {
-  buildVoiceAnchor,
-  ANCHOR,
-  refreshEvery,
-  readTurn,
-  writeTurn,
-  decideAnchor,
-  withSlipReminder,
-  withGateReminder,
-  withDispatchReminder,
-  withVoiceReminder,
-  DEFAULT_REFRESH_EVERY,
-};
+  const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  let ctx = buildVoiceAnchor(root);
+  const slips = [[pl.readSlip(root), withSlipReminder, () => pl.clearSlip(root)],
+    [gate.readSlip(root), withGateReminder, () => gate.clearSlip(root)],
+    [gate.readDispatchSlip(root), withDispatchReminder, () => gate.clearDispatchSlip(root)],
+    [voice.readSlip(root), withVoiceReminder, () => voice.clearSlip(root)]];
+  for (const [slip, format, clear] of slips) if (slip) { ctx = format(ctx, slip); clear(); }
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: ctx } }));
+}
+module.exports = { buildVoiceAnchor, withSlipReminder, withGateReminder, withDispatchReminder, withVoiceReminder };

package/install/templates/.claude/hooks/lib/dispatch-approval.cjs

@@ -0,0 +1,135 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const MAX_BYTES = 2 * 1024 * 1024;
+const hash = value => crypto.createHash('sha256').update(value).digest('hex');
+const filePath = root => path.join(root, '_byan-output', 'dispatch-plan.json');
+const markdownPath = root => path.join(root, '_byan-output', 'plan.md');
+
+function validatePlan(plan) {
+  if (!plan || typeof plan.task !== 'string' || !plan.task.trim() ||
+      typeof plan.resume !== 'string' || typeof plan.stamp !== 'string' ||
+      !Array.isArray(plan.table) || !plan.table.length || plan.table.length > 100) {
+    throw new Error('Plan incomplet');
+  }
+  const ids = new Set();
+  for (const step of plan.table) {
+    if (!step || typeof step.id !== 'string' || !/^[\w-]+$/.test(step.id) || ids.has(step.id) ||
+        typeof step.titre !== 'string' || typeof step.consigne !== 'string' || !step.consigne.trim() ||
+        !Number.isFinite(step.complexite) || step.complexite < 0 || step.complexite > 100 ||
+        !['exploration', 'analyse', 'analysis', 'mechanical', 'implementation', 'verification', 'shell', 'deploiement', 'navigation', 'doc'].includes(step.nature) ||
+        !['claude', 'codex'].includes(step.moteur) ||
+        ![null, 'haiku', 'sonnet', 'opus', 'fable'].includes(step.modele) ||
+        ![null, 'low', 'medium', 'high', 'xhigh', 'max'].includes(step.effort)) throw new Error('Etape invalide');
+    if (step.nature === 'verification' && (step.modele !== null || step.effort !== null || step.moteur !== 'claude')) {
+      throw new Error('La verification doit heriter de la session');
+    }
+    ids.add(step.id);
+  }
+  return plan;
+}
+
+function readBounded(file) {
+  if (fs.statSync(file).size > MAX_BYTES) throw new Error('Plan trop volumineux');
+  return fs.readFileSync(file, 'utf8');
+}
+function renderPlan(plan) {
+  const cell = value => String(value).replace(/\|/g, '&#124;').replace(/[\r\n]/g, ' ');
+  return [
+    '# Plan de dispatch — ' + cell(plan.resume), '',
+    '- Tache d origine : ' + cell(plan.task),
+    '- Genere par : workflow natif byan-auto-dispatch (' + cell(plan.stamp) + ')', '',
+    '| Etape | Titre | Nature | Complexite | Moteur | Modele | Effort |',
+    '|-------|-------|--------|------------|--------|--------|--------|',
+    ...plan.table.map(s => `| ${s.id} | ${cell(s.titre)} | ${s.nature} | ${s.complexite} | ${s.moteur} | ${s.modele || 'modele de session'} | ${s.effort || 'effort de session'} |`),
+    '', '## Consignes par etape', '',
+    ...plan.table.map(s => `### ${s.id} — ${cell(s.titre)}\n\n${s.consigne}\n`),
+  ].join('\n');
+}
+function writeAtomic(root, record) {
+  const file = filePath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(record, null, 2) + '\n', { mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } finally {
+    try { fs.unlinkSync(temporary); } catch { /* renamed */ }
+  }
+}
+function read(root) {
+  const record = JSON.parse(readBounded(filePath(root)));
+  validatePlan(record.planData);
+  if (record.version !== 1 || record.id !== hash(JSON.stringify(record.planData)) ||
+      !['pending', 'approved', 'executing', 'completed'].includes(record.status) ||
+      record.markdownHash !== hash(readBounded(markdownPath(root)))) throw new Error('Plan modifie ou invalide : preparer et valider a nouveau');
+  return record;
+}
+function saveUnlocked(root, planData) {
+  validatePlan(planData);
+  const markdown = renderPlan(planData);
+  if (Buffer.byteLength(markdown) > MAX_BYTES || Buffer.byteLength(JSON.stringify(planData)) > MAX_BYTES) throw new Error('Plan trop volumineux');
+  fs.mkdirSync(path.dirname(markdownPath(root)), { recursive: true });
+  fs.writeFileSync(markdownPath(root), markdown);
+  const record = { version: 1, id: hash(JSON.stringify(planData)), status: 'pending', planData,
+    markdownHash: hash(markdown) };
+  writeAtomic(root, record);
+  return record;
+}
+function approveUnlocked(root, id, approvedBy = 'terminal') {
+  const record = read(root);
+  if (record.id !== id || record.status !== 'pending') throw new Error('Ce plan ne peut plus etre valide');
+  record.status = 'approved';
+  record.approvedAt = new Date().toISOString();
+  record.approvedBy = approvedBy;
+  writeAtomic(root, record);
+  return record;
+}
+function authorize(root, input) {
+  const record = read(root);
+  if (record.status !== 'approved' || !record.approvedAt || record.id !== input.approvedPlanId ||
+      JSON.stringify(record.planData) !== JSON.stringify(input.planData)) throw new Error('Execution refusee : validation du plan courant requise');
+  return record;
+}
+function transitionUnlocked(root, id, status) {
+  const record = read(root);
+  const from = status === 'executing' ? 'approved' : 'executing';
+  if (record.id !== id || record.status !== from) throw new Error('Transition de plan refusee');
+  record.status = status;
+  writeAtomic(root, record);
+  return record;
+}
+
+function locked(root, action) {
+  const lock = path.join(root, '_byan-output', 'dispatch-plan.lock');
+  fs.mkdirSync(path.dirname(lock), { recursive: true });
+  try { fs.mkdirSync(lock); } catch (error) {
+    if (error.code === 'EEXIST') throw new Error('Plan occupe : reessayer apres la fin de la modification');
+    throw error;
+  }
+  try { return action(); } finally { fs.rmdirSync(lock); }
+}
+const save = (root, planData) => locked(root, () => saveUnlocked(root, planData));
+const approve = (root, id, by) => locked(root, () => approveUnlocked(root, id, by));
+const transition = (root, id, status) => locked(root, () => transitionUnlocked(root, id, status));
+
+module.exports = { hash, validatePlan, renderPlan, read, save, approve, authorize, transition, filePath, MAX_BYTES };
+
+if (require.main === module) {
+  try {
+    const [command, id] = process.argv.slice(2);
+    const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    let result;
+    if (command === 'save') result = save(root, JSON.parse(fs.readFileSync(0, 'utf8')));
+    else if (command === 'read') result = read(root);
+    else if (command === 'claim') result = transition(root, id, 'executing');
+    else if (command === 'complete') { const current = read(root); result = current.id === id && current.status === 'completed' ? current : transition(root, id, 'completed'); }
+    else throw new Error('Usage : dispatch-approval.cjs save|read|complete [id]. Validation par geste utilisateur uniquement.');
+    process.stdout.write(JSON.stringify(result) + '\n');
+  } catch (error) {
+    process.stderr.write(error.message + '\n');
+    process.exitCode = 1;
+  }
+}

package/install/templates/.claude/hooks/lib/dispatch-plan-format.js

@@ -0,0 +1,293 @@
+'use strict';
+
+// Formateur du plan de dispatch — le rendu terminal.
+//
+// POURQUOI ce module existe : l'utilisateur ne peut pas mesurer ce que le
+// routage lui coute tant qu'on ne lui a pas montre de plan. Le workflow natif
+// `byan-auto-dispatch` calcule bien une table (etape x nature x complexite x
+// moteur x modele x effort) avant d'ecrire _byan-output/plan.md, mais un script
+// natif n'a ni import ni acces fichier : il ne peut pas mettre en forme. Le
+// rendu vit donc ici, en pur code testable, et se nourrit de la meme structure.
+//
+// POURQUOI la couleur n'encode rien ici : dans un terminal on n'a ni palette ni
+// garantie de fond. Le palier — le levier de cout principal, d'apres le brief de
+// conception — est donc encode par la LARGEUR d'une jauge, canal qui survit au
+// monochrome, au copier-coller et au journal de session.
+//
+// POURQUOI aucun montant n'est calcule : au moment du plan, aucun jeton n'a ete
+// consomme. Afficher un montant serait une invention, et un zero serait faux.
+// La regle produit dit : une valeur, ou un tiret accompagne de la raison du
+// silence — pas de troisieme forme. Le plan annonce donc le melange des paliers
+// et le plafond engage, qui sont mesurables, et dit pourquoi le montant manque.
+
+// Les quatre paliers, du moins cher au plus cher. L'ordre porte le sens : c'est
+// lui qui remplit la jauge et qui designe le plafond.
+const PALIERS = Object.freeze(['haiku', 'sonnet', 'opus', 'fable']);
+
+const LARGEUR_JAUGE = 4;
+const SESSION = 'session';
+const INCONNU = 'inconnu';
+const TIRET = '-';
+
+// Le routeur ecrit `null` dans la table et « modele de session » dans le
+// plan.md pour la meme realite. Les deux entrent ici.
+const MOTS_SESSION = Object.freeze([
+  'session',
+  'modele de session',
+  'modèle de session',
+  'effort de session',
+]);
+
+const RAISON_SESSION =
+  "modele de session : le palier n'est connu qu'a l'execution";
+
+function texte(v) {
+  if (v === null || v === undefined) return '';
+  return String(v).trim();
+}
+
+function estMotSession(mot) {
+  return MOTS_SESSION.includes(mot.toLowerCase());
+}
+
+// La jauge : un palier se lit a la largeur de son remplissage, pas a sa couleur.
+// Un palier non connu prend un remplissage de tirets et non de diese — il ne
+// doit pas ressembler a « fable » d'un coup d'oeil.
+function jaugePalier(modele) {
+  const rang = PALIERS.indexOf(texte(modele));
+  if (rang < 0) return `[${TIRET.repeat(LARGEUR_JAUGE)}]`;
+  return `[${'#'.repeat(rang + 1)}${'.'.repeat(LARGEUR_JAUGE - rang - 1)}]`;
+}
+
+function normaliserEtape(brut, rang) {
+  const e = brut && typeof brut === 'object' ? brut : {};
+
+  const modeleBrut = texte(e.modele) || texte(e.model);
+  let palier;
+  let raison = null;
+  if (PALIERS.includes(modeleBrut)) {
+    palier = modeleBrut;
+  } else if (!modeleBrut || estMotSession(modeleBrut)) {
+    palier = SESSION;
+    raison = RAISON_SESSION;
+  } else {
+    palier = INCONNU;
+    raison = `modele « ${modeleBrut} » hors des quatre paliers connus`;
+  }
+
+  const effortBrut = texte(e.effort);
+  const effort = !effortBrut || estMotSession(effortBrut) ? SESSION : effortBrut;
+
+  // La complexite peut valoir 0 : on teste la finitude, pas la verite.
+  const cxBrut = e.complexite === null || e.complexite === undefined || e.complexite === ''
+    ? NaN
+    : Number(e.complexite);
+  const complexite = Number.isFinite(cxBrut) ? cxBrut : null;
+
+  return {
+    id: texte(e.id) || `E${rang + 1}`,
+    titre: texte(e.titre) || texte(e.title) || 'etape sans titre',
+    nature: texte(e.nature) || INCONNU,
+    complexite,
+    palier,
+    raison,
+    chiffrable: raison === null,
+    effort,
+    moteur: texte(e.moteur) || texte(e.engine) || TIRET,
+  };
+}
+
+function normaliserPlan(plan) {
+  const p = plan && typeof plan === 'object' ? plan : {};
+  const brutes = Array.isArray(p.etapes) ? p.etapes : Array.isArray(p.table) ? p.table : [];
+  return {
+    resume: texte(p.resume) || texte(p.tache) || 'resume absent du plan',
+    etapes: brutes.map(normaliserEtape),
+  };
+}
+
+function resumerPlan(plan) {
+  const { etapes } = normaliserPlan(plan);
+
+  const parPalier = {};
+  PALIERS.forEach((p) => { parPalier[p] = 0; });
+  const parMoteur = {};
+  const nonChiffrees = [];
+
+  etapes.forEach((e) => {
+    if (e.chiffrable) parPalier[e.palier] += 1;
+    else nonChiffrees.push({ id: e.id, raison: e.raison });
+    if (e.moteur !== TIRET) parMoteur[e.moteur] = (parMoteur[e.moteur] || 0) + 1;
+  });
+
+  const engages = PALIERS.filter((p) => parPalier[p] > 0);
+  return {
+    nbEtapes: etapes.length,
+    parPalier,
+    parMoteur,
+    plafond: engages.length ? engages[engages.length - 1] : null,
+    nonChiffrees,
+  };
+}
+
+// Au-dela, un titre pousse les colonnes chiffrees hors de vue : on tronque avec
+// une marque visible plutot que de laisser la table se desaligner.
+const LARGEUR_TITRE_MAX = 38;
+const INDENT = 2;
+const ECART = 2;
+
+function cellulePalier(etape) {
+  return `${etape.palier.padEnd(7)} ${jaugePalier(etape.palier)}`;
+}
+
+function valeurs(etape) {
+  return {
+    id: etape.id,
+    titre: etape.titre,
+    nature: etape.nature,
+    complexite: etape.complexite === null ? TIRET : String(etape.complexite),
+    palier: cellulePalier(etape),
+    effort: etape.effort,
+    moteur: etape.moteur,
+  };
+}
+
+// La mise en page est exportee : c'est elle qui rend le rendu verifiable au
+// caractere pres, et qui garantit que l'en-tete et les lignes partagent les
+// memes bornes.
+function colonnesPlan(plan, opts = {}) {
+  const { etapes } = normaliserPlan(plan);
+  const cellules = etapes.map(valeurs);
+  const largeurTitreMax = opts.largeurTitreMax || LARGEUR_TITRE_MAX;
+
+  const large = (cle, plancher, plafond) => {
+    const mesures = cellules.map((c) => c[cle].length);
+    const brut = Math.max(plancher, ...(mesures.length ? mesures : [0]));
+    return plafond ? Math.min(brut, plafond) : brut;
+  };
+
+  const modele = [
+    { cle: 'id', titre: 'ID', largeur: large('id', 2), aligne: 'gauche' },
+    { cle: 'titre', titre: 'TITRE', largeur: large('titre', 5, largeurTitreMax), aligne: 'gauche' },
+    { cle: 'nature', titre: 'NATURE', largeur: large('nature', 6), aligne: 'gauche' },
+    { cle: 'complexite', titre: 'CX', largeur: large('complexite', 2), aligne: 'droite' },
+    { cle: 'palier', titre: 'PALIER', largeur: large('palier', 6), aligne: 'gauche' },
+    { cle: 'effort', titre: 'EFFORT', largeur: large('effort', 6), aligne: 'gauche' },
+    { cle: 'moteur', titre: 'MOTEUR', largeur: large('moteur', 6), aligne: 'gauche' },
+  ];
+
+  let curseur = INDENT;
+  return modele.map((c) => {
+    const colonne = { ...c, debut: curseur };
+    curseur += c.largeur + ECART;
+    return colonne;
+  });
+}
+
+function poser(valeur, colonne) {
+  let v = valeur;
+  if (v.length > colonne.largeur) v = `${v.slice(0, colonne.largeur - 1)}…`;
+  return colonne.aligne === 'droite' ? v.padStart(colonne.largeur) : v.padEnd(colonne.largeur);
+}
+
+function ligneDe(cellules, colonnes) {
+  return (' '.repeat(INDENT) + colonnes.map((c) => poser(cellules[c.cle], c)).join(' '.repeat(ECART))).trimEnd();
+}
+
+function lignesTete(resume, bilan) {
+  const etiquette = (mot) => `  ${mot.padEnd(13)}`;
+  const moteurs = Object.keys(bilan.parMoteur)
+    .sort((a, b) => bilan.parMoteur[b] - bilan.parMoteur[a] || a.localeCompare(b))
+    .map((m) => `${m} ${bilan.parMoteur[m]}`)
+    .join(', ');
+  const melange = PALIERS.map((p) => `${p} ${bilan.parPalier[p]}`).join('  |  ');
+
+  const lignes = [
+    `PLAN DE DISPATCH — ${resume}`,
+    '',
+    `${etiquette('Etapes')}${bilan.nbEtapes}${moteurs ? `  (moteurs : ${moteurs})` : '  (moteur non precise)'}`,
+    `${etiquette('Paliers')}${melange}`,
+    `${etiquette('Plafond')}${bilan.plafond
+      ? `${bilan.plafond} — le palier le plus cher engage par ce plan`
+      : `${TIRET}  aucun des quatre paliers connus n'est engage`}`,
+  ];
+
+  if (bilan.nonChiffrees.length) {
+    const ids = bilan.nonChiffrees.map((n) => n.id).join(', ');
+    const raisons = [...new Set(bilan.nonChiffrees.map((n) => n.raison))].join(' ; ');
+    const n = bilan.nonChiffrees.length;
+    lignes.push(`${etiquette('Non chiffre')}${n} etape${n > 1 ? 's' : ''} hors melange (${ids}) — ${raisons}`);
+  }
+
+  // Le montant manque, et la raison du silence est affichee avec le tiret :
+  // c'est la seule forme admise pour une valeur absente.
+  lignes.push(
+    `${etiquette('Montant')}${TIRET}  aucun montant estime : les jetons ne sont comptes qu'apres l'execution`
+  );
+
+  return lignes;
+}
+
+function legende() {
+  const echelle = PALIERS.map((p) => `${jaugePalier(p)} ${p}`).join(' < ');
+  return `  Jauge de palier : ${echelle}   ·   ${jaugePalier(null)} palier non connu avant l'execution`;
+}
+
+function rendrePlan(plan, opts = {}) {
+  const { resume, etapes } = normaliserPlan(plan);
+  const bilan = resumerPlan(plan);
+
+  if (!etapes.length) {
+    return [
+      `PLAN DE DISPATCH — ${resume}`,
+      '',
+      '  Aucune etape a afficher : le plan est vide ou sa table est illisible.',
+      "  Rien n'a ete route, donc rien n'a ete estime.",
+    ].join('\n');
+  }
+
+  const colonnes = colonnesPlan(plan, opts);
+  const largeurTable = colonnes[colonnes.length - 1].debut + colonnes[colonnes.length - 1].largeur;
+  const enTete = {};
+  colonnes.forEach((c) => { enTete[c.cle] = c.titre; });
+
+  return [
+    ...lignesTete(resume, bilan),
+    '',
+    ligneDe(enTete, colonnes),
+    '  ' + TIRET.repeat(largeurTable - INDENT),
+    ...etapes.map((e) => ligneDe(valeurs(e), colonnes)),
+    '',
+    legende(),
+  ].join('\n');
+}
+
+module.exports = {
+  PALIERS,
+  jaugePalier,
+  normaliserPlan,
+  resumerPlan,
+  colonnesPlan,
+  rendrePlan,
+};
+
+// Rendu direct depuis le terminal, sur un plan JSON :
+//   node .claude/hooks/lib/dispatch-plan-format.js chemin/du/plan.json
+// POURQUOI : le plan doit etre lisible dans le terminal aujourd'hui, sans
+// attendre qu'un appelant soit cable.
+if (require.main === module) {
+  const fs = require('fs');
+  const cible = process.argv[2];
+  if (!cible) {
+    process.stderr.write('usage : node dispatch-plan-format.js <plan.json>\n');
+    process.exit(2);
+  }
+  let charge = null;
+  try {
+    charge = JSON.parse(fs.readFileSync(cible, 'utf8'));
+  } catch (err) {
+    process.stderr.write(`plan illisible (${cible}) : ${err.message}\n`);
+    process.exit(1);
+  }
+  process.stdout.write(`${rendrePlan(charge)}\n`);
+}

package/install/templates/.claude/hooks/lib/plain-language.js

@@ -1,16 +1,8 @@
 'use strict';
 
-// Plain-language core — the shared, testable heart of the "parler reel" guard
-// (Mantra IA-26). Two jobs, no I/O beyond the slip flag:
-//
-//  1. scanText: find the KNOWN repeat-offender words in an assistant reply and
-//     return each with its plain-French replacement. This is the mechanical net
-//     for words we already know we misuse; the generative rule (the principle in
-//     .claude/rules/plain-language.md + the voice anchor) handles the long tail.
-//  2. slip flag: a tiny file under _byan-output/ that the Stop hook writes when a
-//     reply slipped, and the next-turn voice anchor reads + clears to remind the
-//     agent. NO re-answer, NO blocking — the correction is carried FORWARD to the
-//     next turn, which is the whole point (avoid the costly regen loop).
+// Lexical suggestions are available only to explicit review callers.
+// They neither prove misuse nor replace text. Normal Stop hooks receive no
+// lexical hits; punctuation is checked separately by voice-conformance.
 
 const fs = require('fs');
 const path = require('path');
@@ -108,7 +100,8 @@ function stripCode(text) {
 }
 
 // Find every distinct offender present in the prose. Returns [{ bad, good }].
-function scanText(text) {
+function scanText(text, { reviewLexicon = false } = {}) {
+  if (!reviewLexicon) return [];
   const prose = stripCode(text);
   if (!prose) return [];
   const hits = [];
@@ -136,8 +129,8 @@ function formatReminder(hits) {
     .map((h) => `"${h.bad}" -> ${h.good}`)
     .join(' ; ');
   return [
-    'Rappel langage (IA-26) : au dernier tour tu as glisse du jargon ou de',
-    `l'anglais gratuit -> ${shown}. Reformule en francais reel et coherent ce`,
+    'Indications lexicales à examiner selon le sens et le destinataire (IA-26) :',
+    `${shown}. Aucun mot interdit par sa fréquence, aucun remplacement automatique. Rédige ce`,
     'tour-ci, sans refaire la reponse precedente.',
   ].join(' ');
 }